> ## Documentation Index
> Fetch the complete documentation index at: https://docs.agentcard.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Agentcard is for companies whose agent buys for their users. Pick one path: the opencommerce SDK (@agent-cards/commerce-sdk) gives your agent one buy tool that finds the product, builds the cart, gets the user's approval and places the order at real stores; the Agentcard SDK (@agent-cards/sdk) pays with the user's own card when your agent already shops in a browser (Browser Use, Kernel, Browserbase, Anchor or Notte); the Purchase API (POST /buy) does the same purchase flow over plain HTTP in any language; Issuing gives the agent its own card.
> Start with `npx agent-cards init` in the app's folder (Node 22 or later). No invite is needed: it creates your Agentcard account if you don't have one, installs the opencommerce SDK and puts the credentials in the env file, kept out of git. From a coding agent, run `npx agent-cards init --print --categories all --implementation tool --wallet vault --skip-install` to get the setup steps to apply yourself.
> Vault is by invitation: request it at https://agentcard.com/get-started?utm_source=docs&utm_medium=llms&utm_campaign=agent-instructions. opencommerce needs no invite.
> Never ask a user for a card number, expiry date or CVV in chat. Send them the Vault link; they add their card on Agentcard's page, and the agent never sees the number.
> Every purchase is approved by the user, with a passkey or Face ID, or by an auto-approval they granted. An approval covers one merchant and one exact total. If the total changes, ask again. When a result says the user already said yes, don't ask again.
> `init` writes PRODUCTION credentials, which place real orders, so test in sandbox first. For opencommerce, run `npx agent-cards credentials --mode sandbox` and put the two lines it prints in place of the production ones in the env file `init` wrote, because that command only prints them; sandbox then runs the whole flow against real stores and stops before payment, so no order is placed and nobody is charged. For Vault and Issuing, sandbox credentials issue test cards that no real merchant accepts; try the checkout against shop.agentcard.sh, a test store on Stripe test mode.
> Tell the user an order is placed only after Agentcard reports it placed.
> Vault is free up to 5,000 users (https://agentcard.com/pricing). opencommerce takes 1% of each completed order. Full docs in one file: https://docs.agentcard.com/llms-full.txt

# List recognized processors

> The processor card requests Agentcard can pause and complete for your company.

Ask which card requests Agentcard will pause for your company, and get one entry per processor request. The SDK sends this request on every `syncRegistry()`, so a new processor reaches your agents without an SDK release. Call it yourself only if you run your own interception: pause a request that matches an entry and leave every other request untouched.

**modes** `string`

Comma-separated modes to include: `token`, `cse`, `hosted_form`, `device_encrypt`. Default `token,cse`. Ask for `hosted_form` only if your runtime can finish a hosted-form submission.

**features** `string`

Comma-separated features your runtime has. `card_fields` means you check whether a request carries a card, so you also receive the Stripe endpoints that run with or without one (confirmation tokens, sources). Without it you receive only endpoints that always carry a card.

**capabilities** `string`

Comma-separated capabilities your runtime supports. Agentcard serves a processor whose card request needs more than a pause only when you name its capability, and only to a company Agentcard turned that processor on for. The SDK names every capability it supports; see "Ask for another processor" below.

```bash cURL theme={null}
curl "https://api.agentcard.sh/api/v2/checkout/recognizers?modes=token,cse&capabilities=capture_context" \
  -H "Authorization: Bearer $ORG_TOKEN"
```

```json 200 theme={null}
[
  {
    "psp": "stripe",
    "match": "api\\.stripe\\.com/v1/(payment_methods|tokens|setup_intents/seti_\\w+/confirm|payment_intents/pi_\\w+/confirm)",
    "hosts": ["^api\\.stripe\\.com$"],
    "encoding": "form",
    "passthroughHeaders": ["^authorization$", "^stripe-version$", "^x-stripe-client-user-agent$"],
    "cardFields": ["card[number]", "payment_method_data[card][number]"],
    "passWithoutCard": "api\\.stripe\\.com/v1/(sources|confirmation_tokens|payment_pages/cs_(?:test|live)_\\w+/confirm)"
  },
  {
    "psp": "shopify",
    "match": "(checkout\\.pci\\.shopifyinc\\.com|deposit\\.[a-z0-9-]+\\.shopifycs\\.com)/sessions",
    "hosts": ["^checkout\\.pci\\.shopifyinc\\.com$", "^deposit\\.[a-z0-9-]+\\.shopifycs\\.com$"],
    "encoding": "json",
    "passthroughHeaders": ["^shopify-identification-signature$"]
  },
  {
    "psp": "cybersource_flex",
    "capability": "capture_context",
    "match": "(?:test)?flex\\.cybersource\\.com/flex/v2/tokens(?![\\w/-])",
    "hosts": ["^flex\\.cybersource\\.com$", "^testflex\\.cybersource\\.com$"],
    "sandboxHosts": ["^testflex\\.cybersource\\.com$"],
    "hostEnvironmentPinned": true,
    "encoding": "jwe",
    "passthroughHeaders": []
  }
]
```

The response is a JSON array. Each entry names the processor (`psp`), the hosts the request goes to (`hosts`, anchored patterns matched against the hostname), the request's host and path (`match`, matched whole against hostname plus path, never against the query), how the card rides in the body (`encoding`), and the request headers to keep when the device replays the request (`passthroughHeaders`). An entry with `mode` absent is a `token` request. `sandboxHosts` with `hostEnvironmentPinned` marks a processor whose test and live hosts differ, so a test-mode client pays only on the test host and a live client only on the live host.

Match on the parsed URL, the way Agentcard does: a request is recognized only when its hostname matches one of `hosts` and its hostname plus path matches `match` in full. A URL that merely contains a processor endpoint in its query is not a card request, and a pause you cannot complete turns into a failed request for the page.

`/v2/checkout/*` and `/api/v2/checkout/*` are the same routes.

## See the processors you receive

Every company receives these, with the default `modes=token,cse`, whether or not it names a capability.

| Mode | Processors |
| - | - |
| `token` | Stripe, Shopify, Square, Recurly, Razorpay, Braintree, Checkout.com, Worldpay, Airwallex, Authorize.Net, Bambora, dLocal, EBANX, Global Payments, Mercado Pago, Mollie, Nuvei, Paysafe, PayU, Rapyd, Spreedly |
| `cse` | Adyen |
| `hosted_form` | Tranzila, on request with `modes=hosted_form` |

A purchase at Airwallex, Nuvei, Rapyd or Razorpay always waits for the user's approval, even when the user let your app pay without asking. [Enable auto-approval](https://docs.agentcard.com/vault/app-auto-approval.md#pay-without-an-approval) lists the purchases Agentcard pays without asking.

Agentcard serves three more to every company once your runtime names their capability, because the device has to do more than replay the request: CyberSource Flex Microform (`capture_context`), CyberSource Secure Acceptance (`cybersource_sa_token_create`) and Worldpay eProtect (`worldpay_eprotect_jsonp`). The SDK names all three on every sync.

## Ask for another processor

Agentcard turns some processors on for one company at a time. Agentcard checks the merchant checkouts that company pays through those processors first. Until Agentcard turns a processor on for your company, the list omits that processor even when you name its capability. Your agent neither pauses nor refuses a request Agentcard could not pay. The SDK then refuses `prepare()` for that processor before any network call:

```text theme={null}
CheckoutPreparationError: processor_interception_unavailable
```

| Code | What it means | What to do next |
| - | - | - |
| `processor_interception_unavailable` | The SDK has no recognizer for that processor on this company, so the SDK refuses `prepare()` before any network call. | Ask Agentcard to turn the processor on, run `syncRegistry()` again, then attach a fresh checkout controller and call `prepare()` with the same options. |

Agentcard turns on Fiserv, GMO Payment Gateway, Juspay, Datatrans, Authorize.Net DPM, Pelecard, ACI, CreditGuard, Primer, Payrails, Elavon Converge, WSPay, Shiji, Amadeus Checkout, Worldline MyCheckout, Verifone, eKashu, Moneris and Gr4vy per company today. If a merchant you need pays through one of them, ask Agentcard to turn the processor on for your company. Then run `syncRegistry()` again so the entry appears.

The refusal retires that checkout controller, so the same controller cannot prepare again. Attach a fresh checkout controller once the entry is in your list, and call `prepare()` with the same options. The response you receive is the truth for your company at that moment, so read the response rather than this page when the two differ.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.