# Acp Checkout Mcp

> Implement ACP checkout as an MCP server, exposing checkout operations as MCP tools. Use when building an MCP-based commerce server for AI agents that use tool-calling to complete purchases.

- **Type:** Skill
- **Install:** `agentstack add skill-orcaqubits-agentic-commerce-skills-plugins-acp-checkout-mcp`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [OrcaQubits](https://agentstack.voostack.com/s/orcaqubits)
- **Installs:** 0
- **Category:** [Finance & Payments](https://agentstack.voostack.com/c/finance-and-payments)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [OrcaQubits](https://github.com/OrcaQubits)
- **Source:** https://github.com/OrcaQubits/agentic-commerce-skills-plugins/tree/main/acp-agentic-commerce/skills/acp-checkout-mcp

## Install

```sh
agentstack add skill-orcaqubits-agentic-commerce-skills-plugins-acp-checkout-mcp
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# ACP Checkout — MCP Binding

## Before writing code

**Fetch live docs**:
1. Web-search `acp agentic commerce protocol MCP server implementation` for MCP binding guidance
2. Fetch `https://developers.openai.com/commerce/specs/checkout/` for checkout operation semantics
3. Web-search `site:github.com agentic-commerce-protocol MCP` for any official MCP examples
4. Fetch MCP SDK docs: web-search `site:github.com modelcontextprotocol python-sdk` or `typescript-sdk` for current SDK

## Conceptual Architecture

### What MCP Binding Means

ACP's REST checkout operations can be exposed as **MCP tools** via an MCP server. This allows AI agents that use tool-calling (Claude, ChatGPT, Gemini) to invoke checkout operations directly as tools rather than making raw HTTP calls.

### Mapping REST to MCP Tools

Each REST checkout operation becomes an MCP tool:

| REST Operation | MCP Tool Name | Description |
|---------------|---------------|-------------|
| POST /checkout_sessions | `create_checkout_session` | Create a new checkout session with items |
| POST /checkout_sessions/{id} | `update_checkout_session` | Update session (items, address, fulfillment) |
| GET /checkout_sessions/{id} | `get_checkout_session` | Retrieve current session state |
| POST /checkout_sessions/{id}/complete | `complete_checkout_session` | Submit payment to finalize |
| POST /checkout_sessions/{id}/cancel | `cancel_checkout_session` | Cancel the session |

### Tool Input Schemas

Each MCP tool accepts JSON input matching the corresponding REST request body. The tool's `inputSchema` should be derived from the ACP OpenAPI spec's request schemas.

### Tool Output

Each tool returns the CheckoutSession object (or error) as JSON, matching the REST response body.

### MCP Server Architecture

```
AI Agent (Claude/ChatGPT)
    ↓ tool call (JSON-RPC)
MCP Server (your code)
    ↓ business logic
Checkout Service (same logic as REST)
    ↓ payment
PSP (Stripe)
```

The MCP server wraps the same business logic that the REST endpoints use. The checkout service layer should be shared between REST and MCP bindings.

### Key Considerations

- **Idempotency** — MCP doesn't have HTTP headers, so pass `idempotency_key` as a tool parameter
- **API versioning** — Include `api_version` as a tool parameter or server configuration
- **Authentication** — MCP transport handles auth (stdio for local, SSE/streamable-HTTP for remote)
- **Error handling** — Return ACP error objects as tool errors with the same `type`/`code`/`message` structure
- **Statelessness** — Each tool call should be stateless; session state lives in the CheckoutSession object

### Use Cases

- AI agents that prefer tool-calling over raw HTTP
- Claude Desktop / Claude Code integrations
- Multi-agent architectures where commerce is one capability
- Rapid prototyping without building a full REST server

### Best Practices

- Share the checkout business logic layer between REST and MCP bindings
- Derive tool input schemas from the ACP OpenAPI spec (don't hand-write them)
- Include descriptive tool descriptions so the agent understands when to use each tool
- Test with the MCP Inspector before connecting to an agent

Fetch the latest ACP OpenAPI spec and MCP SDK documentation for exact schemas and server setup before implementing.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [OrcaQubits](https://github.com/OrcaQubits)
- **Source:** [OrcaQubits/agentic-commerce-skills-plugins](https://github.com/OrcaQubits/agentic-commerce-skills-plugins)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-orcaqubits-agentic-commerce-skills-plugins-acp-checkout-mcp
- Seller: https://agentstack.voostack.com/s/orcaqubits
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.