ack-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ack-mcp Create a signed payment request for $5 to my DID."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ack-mcp
MCP server for the Agent Commerce Kit — exposes ACK-ID and ACK-Pay operations as tools for AI agents via the Model Context Protocol.
Tools
Tool | Description |
| Generate a cryptographic keypair with a |
| Create a |
| Create a |
| Resolve a DID URI to its DID Document |
| Create an unsigned controller credential (W3C VC) |
| Sign a credential, returning a JWT |
| Verify a signed credential JWT |
| Create a signed JWT with an arbitrary payload |
| Verify a signed JWT and return its payload |
| Create a signed payment request token |
| Verify and parse a payment request JWT |
| Create an unsigned payment receipt (W3C VC) |
| Verify a signed payment receipt JWT |
Related MCP server: A2A Client MCP Server
Quick start
With Claude Code
{
"mcpServers": {
"ack": {
"command": "npx",
"args": ["ack-mcp"]
}
}
}With Claude Desktop
Add to claude_desktop_config.json:
{
"mcpServers": {
"ack": {
"command": "npx",
"args": ["ack-mcp"]
}
}
}From source
git clone https://github.com/ak68a/ack-mcp.git
cd ack-mcp
npm install
npm startDevelopment
npm install
npm test # Run tests
npm run build # Build for distribution
npm start # Run the server (dev mode via tsx)How it works
The server uses stdio transport and registers 13 tools that wrap the agentcommercekit SDK. An AI agent can:
Generate identities — create DIDs and keypairs
Issue credentials — create and sign W3C Verifiable Credentials proving agent-owner relationships
Verify identities — verify credentials and resolve DIDs
Create payment requests — issue signed payment request tokens for HTTP 402 flows
Verify payments — verify payment request tokens and payment receipts
All cryptographic operations use the ACK SDK's key management — keys are passed as JWK JSON strings between tool calls, and DIDs are used as identifiers throughout.
License
MIT
Available Tools
13 toolsack_create_controller_credentialA
Create an unsigned W3C Verifiable Credential proving that a subject DID (e.g. an agent) is controlled by a controller DID (e.g. the owner). Pass the JSON output to ack_sign_credential to get a signed JWT.
Inputs: subjectDid (required), controllerDid (required), issuerDid.
ack_create_did_pkhA
Create a did:pkh DID URI from a blockchain chain ID and wallet address. Use for representing on-chain identities (e.g. Ethereum wallets) as DIDs.
Inputs: address (required), chainId (required).
ack_create_did_webA
Create a did:web DID URI from a URL. Use for agents or services hosted at a known web address. The domain must host a .well-known/did.json document for DID resolution to work.
Inputs: url (required).
ack_create_jwtA
Create a signed JWT with an arbitrary payload. Use for challenge-response authentication, signed messages between agents, or any custom signed payload. The JWT is signed with the provided JWK and includes the signer's DID as the issuer.
Inputs: payload (required), signerDid (required), signerJwk (required).
ack_create_payment_receiptA
Create an unsigned payment receipt as a W3C Verifiable Credential. The output is unsigned JSON — you must pass it to ack_sign_credential with the receipt issuer's JWK and DID to get a signed JWT, then verify it with ack_verify_payment_receipt.
Inputs: payerDid (required), issuerDid (required), paymentOptionId (required), paymentRequestToken (required), +1 more.
ack_create_payment_requestA
Create a signed payment request token (JWT) for use in HTTP 402 responses. Unlike receipts, this creates AND signs in one step. Verify the result with ack_verify_payment_request.
Inputs: signerDid (required), signerJwk (required), paymentOptions (required), description, +1 more.
ack_generate_keypairA
Generate a new cryptographic keypair with a did:key DID. Returns the JWK (private key), DID, and curve. Pass the jwk value to any tool that requires signerJwk. The DID can be used as signerDid, subjectDid, controllerDid, etc.
Inputs: curve.
ack_resolve_didA
Resolve a DID URI to its DID Document. Supports did:key, did:web, and did:pkh methods.
Inputs: did (required).
ack_sign_credentialA
Sign a W3C Verifiable Credential, returning a signed JWT string. Pass the JSON output from ack_create_controller_credential or ack_create_payment_receipt as the credential parameter. The resulting JWT can be verified with ack_verify_credential or ack_verify_payment_receipt.
Inputs: signerDid (required), signerJwk (required), credential (required).
ack_verify_credentialA
Verify a signed credential JWT (from ack_sign_credential). Checks signature, expiration, and optionally trusted issuers. Set verifyControllerClaims to true to also verify the controller relationship against the subject's DID document (requires did:web or similar — did:key does not support this). Returns {valid: true/false}.
Inputs: jwt (required), trustedIssuers, verifyControllerClaims.
ack_verify_jwtA
Verify a signed JWT and return its decoded payload. Checks the signature against the issuer's DID. Use for verifying challenge-response tokens or any signed message from another agent.
Inputs: jwt (required), issuer.
ack_verify_payment_receiptA
Verify a signed payment receipt JWT (from ack_sign_credential after ack_create_payment_receipt). Checks receipt signature, receipt claims, and optionally the embedded payment request. Returns {valid: true/false}.
Inputs: receipt (required), paymentRequestIssuer, trustedReceiptIssuers.
ack_verify_payment_requestA
Verify and parse a payment request JWT (from ack_create_payment_request). Returns the decoded payment request if valid, including payment options and issuer. Returns {valid: true/false}.
Inputs: token (required), issuer.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 13 tools
Most tools target distinct operations: DID creation, key generation, JWT handling, and payment flows are clearly separated. The only potential confusion is between sign/verify JWT and sign/verify credential, but the descriptions make the arbitrary-payload vs. W3C-credential distinction clear.
All tools follow the consistent ack_<verb>_<noun> pattern, e.g., create_did_web, verify_credential, generate_keypair. There are no mixed conventions or vague generic names.
13 tools is well within the ideal range for a domain spanning DIDs, JWTs, verifiable credentials, and payment receipts. Each tool covers a distinct step in the identity/payment workflow without obvious redundancy.
The core lifecycle is well covered: keypair generation, DID creation/resolution, JWT sign/verify, credential sign/verify, and the payment request/receipt flow. Minor gaps exist, such as no generic credential-creation tool or revocation mechanism, but most workflows are composable from the provided operations.
Related MCP Connectors
Verifiable agent identity with content-addressed DIDs, capability ads and capability search.
Tamper-evident proof creation and verification for AI agents via MCP, A2A, and REST.
Persistent identity, email, saved accounts and scoped credentials for AI agents.
AI agent infrastructure for discovery, authorization, execution, identity, and signed receipts.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI applications to interact with decentralized storage through a standardized Model Context Protocol interface, allowing file uploads, retrievals, and identity management.13Apache 2.0
- FlicenseAqualityNot gradedmaintenanceEnables LLMs to interact with Agent-to-Agent (A2A) protocol compatible agents, allowing them to send tasks, receive responses, track task status, and query agent capabilities through the Model Context Protocol.5-

Cheqd MCP Toolkitofficial
AlicenseNot gradedqualityDmaintenanceEnables AI agents to securely manage decentralized identities, verifiable credentials, and trust registries on the Cheqd network via the Model Context Protocol.1Apache 2.0- AlicenseBqualityFmaintenanceProvides persistent memory, reasoning engine, agent-to-agent sharing, and immutable audit trail for AI agents via the Model Context Protocol.12MIT