> ## 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.

# 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` |

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.