ArkForge Trust Layer
This server acts as a third-party cryptographic certifying proxy, generating independent, tamper-evident proofs for HTTP transactions anchored in immutable public logs.
certify_call— Route an HTTP request through ArkForge to any external API and receive a cryptographic proof bundle: Ed25519 signature, RFC 3161 timestamp, and Sigstore Rekor log entry. Returns a publicverification_urlanyone can use to independently verify the transaction.get_proof— Retrieve the full proof bundle for a previously certified call byproof_id, including request/response hashes, party info, timestamp authority details, and Rekor log entry.verify_proof— Get a human-readable summary of what a proof certifies, useful for auditors or compliance reviewers without parsing raw JSON.get_usage— Check your subscription tier (Free/Pro/Enterprise), proofs used, remaining credits, and billing reset date.
Use cases include compliance logging, dispute resolution, AI agent auditing, webhook verification, and any scenario requiring a trusted, immutable record of an HTTP interaction.
Provides cryptographic certification for GitHub webhook events, creating a tamper-evident record of received payloads and timestamps.
Allows LangChain developers to generate independent, verifiable proofs for all external API calls within their AI agent workflows.
Certifies actions within n8n automation workflows by routing HTTP calls through a proxy that signs and timestamps the transaction.
Generates independent cryptographic proofs for Stripe webhook events to verify the exact payload and timing of incoming notifications.
Enables the certification of HTTP actions in Zapier workflows, producing publicly auditable logs of automated transactions.
ArkForge Trust Layer — MCP Server
Third-party certifying proxy — get an independent cryptographic proof for any HTTP call.
Works with AI agents, webhooks, microservices, or any HTTP client. The proof is signed by ArkForge (independent third party) — not by the caller.
Get your free API key (500 proofs/month) →
Why this matters
When a system makes an HTTP call, there is no independent record of what was sent, what was received, or when it happened. Either party could deny or alter the transaction.
ArkForge fixes this by acting as a certifying proxy: the caller routes its request through ArkForge, which signs the full request+response bundle with an Ed25519 key, timestamps it via RFC 3161, and anchors it in Sigstore Rekor — an immutable, publicly auditable log.
The resulting proof is permanently verifiable at a public URL, by anyone, without contacting ArkForge.
This is the difference between a self-signed certificate and a CA-issued one. Other tools produce proofs signed by the caller itself. ArkForge produces proofs signed by an independent third party.
Related MCP server: @lucairn/mcp-server
Use cases
AI agents — audit trail for every external API call (Claude, GPT, Mistral, LangChain, AutoGen)
Webhooks — prove a Stripe or GitHub event was received with this exact payload
Microservices — tamper-evident log between internal services (compliance, fintech)
Data providers — prove an external API returned this value at this timestamp
Automations — certify an action in an n8n or Zapier workflow
Installation
{
"mcpServers": {
"arkforge": {
"command": "uvx",
"args": ["arkforge-mcp"],
"env": {
"ARKFORGE_API_KEY": "your_api_key_here"
}
}
}
}Get a free API key (500 proofs/month) at arkforge.tech.
Tools
certify_call
Route an HTTP call through ArkForge and get a cryptographic proof of the transaction.
target URL of the upstream API to call
payload JSON body (optional)
method "POST" or "GET" (default: "POST")
description Human-readable description included in the proof
agent_identity Identifier for the calling system (optional)Returns proof_id, verification_url, upstream_response, chain_hash, timestamp, and Ed25519 signature.
Use this instead of calling the API directly when you need an auditable record.
Example response:
{
"proof_id": "prf_20260310_143022_a1b2c3",
"verification_url": "https://trust.arkforge.tech/v1/proof/prf_20260310_143022_a1b2c3",
"upstream_response": { "status": "ok" },
"chain_hash": "e3b0c44298fc1c149afb...",
"timestamp": "2026-03-10T14:30:22.481Z",
"timestamp_authority": "verified",
"rekor_log_id": "https://rekor.sigstore.dev/api/v1/log/entries/...",
"seller": "api.example.com",
"signature": "MCowBQYDK2VwAyEA..."
}get_proof
Retrieve the full proof bundle for a given proof_id.
verify_proof
Get a human-readable summary of what a proof certifies — useful for explaining to a user or auditor what was independently verified.
get_usage
Check your remaining credits for the current month.
What each proof contains
Field | Description |
| Unique identifier — permanent public URL |
| SHA-256 of the exact request sent |
| SHA-256 of the exact response received |
| Combined hash — tamper-evident |
| Domain of the called API |
| RFC 3161 timestamp via FreeTSA (QTSP eIDAS on Enterprise) |
| Sigstore Rekor immutable log entry |
| Ed25519 signature by ArkForge's independent key |
Pricing
Plan | Proofs/month | Price |
Free | 500 | €0 |
Pro | 5,000 | €29/month |
Enterprise | 50,000 + QTSP eIDAS | €149/month |
REST API
The MCP server is one integration path. The same API works from any language or framework:
curl -X POST https://trust.arkforge.tech/v1/proxy \
-H "X-Api-Key: your_key" \
-H "Content-Type: application/json" \
-d '{"target": "https://api.example.com/action", "payload": {"data": "value"}}'Available Tools
4 toolscertify_callA
Call an external API and get a cryptographic proof of the transaction.
Use this INSTEAD of calling the API directly when you need an auditable, tamper-evident record of what was sent and received.
The proof is signed by ArkForge (independent third party), timestamped via RFC 3161, and anchored in Sigstore Rekor — not self-signed by your agent.
Args: target: URL of the upstream API to call (e.g. "https://api.example.com/v1/action") payload: JSON body to send to the upstream API (optional for GET requests) method: HTTP method — "POST" or "GET" (default: "POST") description: Human-readable description of what this call does (included in the proof) agent_identity: Identifier for the calling agent (optional, included in the proof)
Returns: JSON with proof_id, verification_url, the upstream API response, chain_hash, and timestamp. Share verification_url with any third party to let them independently verify what happened.
Inputs: target (required), payload, method, description, +1 more. Returns: result
get_proofA
Retrieve the full cryptographic proof for a given proof ID.
Returns the complete proof bundle: request/response hashes, parties, RFC 3161 timestamp, Sigstore Rekor log entry, and archive.org snapshot.
Args: proof_id: The proof identifier (e.g. "prf_20260310_143022_a1b2c3")
Inputs: proof_id (required). Returns: result
get_usageA
Check your ArkForge API usage and remaining credits for the current period.
Returns your tier (Free / Pro / Enterprise), proofs used, proofs remaining, and the reset date.
Inputs: no named parameters. Returns: result
verify_proofA
Get a human-readable summary of what a proof certifies.
Useful for explaining to a user or auditor what was independently verified, without reading raw JSON.
Args: proof_id: The proof identifier (e.g. "prf_20260310_143022_a1b2c3")
Inputs: proof_id (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool has a distinct and non-overlapping purpose: certify_call creates proofs, get_proof retrieves raw proof data, get_usage checks account status, and verify_proof provides human-readable summaries. There is no ambiguity about when to use which tool, as they target different stages of the proof lifecycle and administrative functions.
All tools follow a consistent verb_noun pattern with clear, descriptive names: certify_call, get_proof, get_usage, and verify_proof. The naming is uniform, using snake_case throughout, and the verbs (certify, get, verify) accurately reflect the actions without mixing conventions.
With 4 tools, this server is well-scoped for its purpose of providing cryptographic proof and verification services. Each tool serves a clear role in the workflow—creating, retrieving, verifying proofs, and managing usage—without being overly sparse or bloated, making it efficient for agents to navigate.
The tool set covers the core lifecycle of proof creation, retrieval, and verification, along with administrative usage checks. A minor gap exists in the lack of tools for managing or deleting proofs, but this does not hinder basic operations, and agents can still perform essential tasks without dead ends.
Maintenance
Related MCP Connectors
Free hosted notary: make any AI agent's actions provable in one call. Verify signed agent logs.
Attestation infrastructure for the agentic economy: signed, independently verifiable verdicts.
Notary for AI agents: seal fingerprints, verify proofs, check mandates. Anchored in Bitcoin.
Checks AI agent actions before they run. Signed, RFC 3161 timestamped evidence for audits.
Related MCP Servers
- AlicenseBqualityBmaintenanceThis server acts as a Portal (zero-trust Policy Enforcement Point) for AI agents. Every tool call is attested, measured against a sealed cryptographic reference, and logged to a tamper-evident continuity chain with signed receipts.1573 npmMIT
- AlicenseAqualityBmaintenancePrivacy-preserving AI gateway. Sanitises PII before prompts reach Anthropic / OpenAI / your LLM, then emits a signed cryptographic certificate per call (Ed25519 + RFC 3161 + Sigstore Rekor). EU GDPR + AI Act ready. Free tier 500/mo with BYOK.12MIT
- AlicenseBqualityBmaintenanceA governance proxy for AI tools — every MCP/agent tool call is policy-gated, secret-redacted, and written to a hash-chained, offline-verifiable audit trail.13MIT

EVIDIQ Circuit MCPofficial
AlicenseNot gradedqualityBmaintenanceVerifiable API proxy and circuit breaker guard for autonomous agents, offering TLS attestation, payload schema inspection, circuit breaker enforcement, webhook signature verification, and 0G-anchored receipt attestation.1MIT