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

> ## Agent Instructions
> If you are an AI assistant operating Infinite for a user, read the skill first: https://docs.infinite.dev/agent-skill.md (setup per host, tool reference, rules for moving money, journeys).
> When operating Infinite for a user, use the MCP server. Sign in at https://bot.api.infinite.dev/mcp (production, acts as the user) or send `Authorization: Bearer <key>` to https://bot.api.infinite.dev/mcp/sse. Prefer its tools over raw HTTP; use REST only for steps no tool covers, and check `get_endpoint_schema` before guessing a request shape.
> Net-new Infinite Connect (org_connect) is operator-assisted: do not grant end users shared org_connect Auth Kit membership or the shared platform org API key — those credentials are org-wide on /v1. BYO org keys onboard under that customer's org id. Operator sessions should show org_connect in get_organization_info.
> The key decides the tools. Every organization key (`sk_sandbox_…` / `sk_live_…`) gets docs, onboarding, `get_account_balance`, and request logs for your own organization. BYO organizations add payees an agent will pay with `create_payee` (payable once ACTIVE). Platform Connect sessions instead get bound-customer payment lookups (`get_quote`, `get_transfer`, `list_transfers`, `list_account_balances`), payee drafts (`create_payee_draft` / `get_payee_draft`; screening only, never payable), and transfer drafts that wait for Infinite approval (`create_transfer_draft` / `get_transfer_draft`; never POST /v1/transfers). Where offered, platform `create_transfer` files a real transfer that Infinite holds in review before funding; it cannot be submitted from DRAFT.
> An agent key (`sk_sandbox_agent_…` / `sk_live_agent_…`) moves money within that agent's limits: `create_transfer` → `submit_transfer` → `wait_for_transfer`.
> On sandbox organization-key sessions, `sandbox_approve_customer` (makes the capabilities you pass READY, and related ones may turn READY too; `request_capabilities` is not needed), `sandbox_fund_account`, and `sandbox_complete_transfer` stand in for verification, funding, and settlement, so a whole flow runs from MCP. BYO keys can pass `customerId` on each call without binding; platform sessions must bind a customer first (`create_business_customer` auto-binds, or send `X-Infinite-On-Behalf-Of`).
> When searching documentation without a key, use the docs MCP at https://docs.infinite.dev/mcp.
> Start in sandbox (https://sandbox.api.infinite.dev). Do not use production unless the user explicitly asks.
> Confirm amount, currency, and payee with the user before any payment is submitted. Pass the invoice number as `reference` on `create_transfer`; the summary says what the payee will see.
> REST amounts are integer minor units (`"4000"` = 40.00 USD). MCP payment tools take exact decimal strings (`"40.00"`). Never mix them.
> Agent denials return `403 { denial: { code, message, window, limit, used, remaining, attemptedAmount, currency }, hint }` with decimal amounts; per-transfer denials omit `used` and `remaining`. Report them to the user; do not work around them.

# Quickstart

# Quickstart Guide

Get up and running with the Infinite API in under 5 minutes.

## Prerequisites

Before you begin, make sure you have:

* An Infinite account with API access
* Your API keys (available in the dashboard)
* Basic knowledge of REST APIs

## Step 1: Authentication

All API requests require authentication using your API key. Include it in the `Authorization` header:

<CodeGroup>
  ```python Python theme={null}
  import requests

  headers = {
      'Authorization': 'Bearer sk_live_...',
      'Content-Type': 'application/json'
  }

  response = requests.get('https://api.infinite.dev/v1/customers', headers=headers)
  ```

  ```typescript TypeScript theme={null}
  const response = await fetch('https://api.infinite.dev/v1/customers', {
    headers: {
      Authorization: 'Bearer sk_live_...',
      'Content-Type': 'application/json',
    },
  });
  ```

  ```bash CLI theme={null}
  export INFINITE_API_KEY=sk_live_...
  infinite customers list --limit 10
  ```

  ```text MCP theme={null}
  List my customers.
  ```

  ```bash cURL theme={null}
  curl -X GET "https://api.infinite.dev/v1/customers" \
    -H "Authorization: Bearer sk_live_..."
  ```
</CodeGroup>

<Warning>
  Never expose your API keys in client-side code. Always make API calls from
  your backend server.
</Warning>

## Step 2: Create a Customer

Start by creating a customer record. Use `/v1/customers/individuals` for people and
`/v1/customers/businesses` for companies:

<CodeGroup>
  ```python Python theme={null}
  import requests

  data = {
      'customerName': 'John Doe',
      'email': 'john@example.com',
      'countryCode': 'US'
  }

  response = requests.post(
      'https://api.infinite.dev/v1/customers/individuals',
      headers={
          'Authorization': 'Bearer sk_live_...',
          'Content-Type': 'application/json',
      },
      json=data
  )
  ```

  ```typescript TypeScript theme={null}
  const customer = await fetch(
    'https://api.infinite.dev/v1/customers/individuals',
    {
      method: 'POST',
      headers: {
        Authorization: 'Bearer sk_live_...',
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        customerName: 'John Doe',
        email: 'john@example.com',
        countryCode: 'US',
      }),
    },
  );
  ```

  ```bash CLI theme={null}
  export INFINITE_API_KEY=sk_live_...
  infinite api POST /v1/customers/individuals --body '{
    "customerName": "John Doe",
    "email": "john@example.com",
    "countryCode": "US"
  }'
  ```

  ```text MCP theme={null}
  Create an individual customer named John Doe (john@example.com) in the US.

  # Infinite MCP is read-only today — run the CLI tab to execute.
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.infinite.dev/v1/customers/individuals" \
    -H "Authorization: Bearer sk_live_..." \
    -H "Content-Type: application/json" \
    -d '{
      "customerName": "John Doe",
      "email": "john@example.com",
      "countryCode": "US"
    }'
  ```
</CodeGroup>

## Step 3: Start Verification

Once you have a customer, initiate KYC verification:

<CodeGroup>
  ```python Python theme={null}
  import requests

  response = requests.post(
      'https://api.infinite.dev/v1/verification/initiate',
      headers={
          'Authorization': 'Bearer sk_live_...',
          'Content-Type': 'application/json',
      },
      json={
          'name': 'John Doe',
          'email': 'john@example.com',
          'type': 'INDIVIDUAL',
          'countryCode': 'US',
          'customerId': 'cus_...',
      },
  )
  ```

  ```typescript TypeScript theme={null}
  const verification = await fetch(
    'https://api.infinite.dev/v1/verification/initiate',
    {
      method: 'POST',
      headers: {
        Authorization: 'Bearer sk_live_...',
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        name: 'John Doe',
        email: 'john@example.com',
        type: 'INDIVIDUAL',
        countryCode: 'US',
        customerId: 'cus_...',
      }),
    },
  );
  ```

  ```bash CLI theme={null}
  export INFINITE_API_KEY=sk_live_...
  infinite api POST /v1/verification/initiate --body '{
    "name": "John Doe",
    "email": "john@example.com",
    "type": "INDIVIDUAL",
    "countryCode": "US",
    "customerId": "cus_..."
  }'
  ```

  ```text MCP theme={null}
  Start identity verification for customer cus_... — John Doe, john@example.com, an individual in the US.

  # Infinite MCP is read-only today — run the CLI tab to execute.
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.infinite.dev/v1/verification/initiate" \
    -H "Authorization: Bearer sk_live_..." \
    -H "Content-Type: application/json" \
    -d '{
      "name": "John Doe",
      "email": "john@example.com",
      "type": "INDIVIDUAL",
      "countryCode": "US",
      "customerId": "cus_..."
    }'
  ```
</CodeGroup>

## Step 4: Handle Webhooks

Set up webhook endpoints to receive real-time updates:

```javascript Express.js theme={null}
app.post('/webhooks/infinite', (req, res) => {
  const event = req.body;

  switch (event.type) {
    case 'customer.verified':
      console.log('Customer verified:', event.data);
      break;
    case 'transfer.completed':
      console.log('Transfer completed:', event.data);
      break;
    default:
      console.log('Unhandled event type:', event.type);
  }

  res.status(200).send('OK');
});
```

<Note>
  In production, always verify webhook signatures before processing events. See
  the [Webhooks guide](/guides/webhooks#verifying-webhooks) for details.
</Note>

## Sandbox Environment

For testing, use our sandbox environment:

* **Base URL**: `https://sandbox.api.infinite.dev`
* **API Key**: Use your sandbox API key (`sk_sandbox_...`)

## Next Steps

You're all set! Here's what to explore next:

<CardGroup cols={2}>
  <Card title="Core Concepts" icon="book-open" href="/concepts/customers">
    Learn about customers, verification, and transfers
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Detailed documentation for all endpoints
  </Card>

  <Card title="Webhooks" icon="webhook" href="/guides/webhooks">
    Set up real-time event notifications
  </Card>

  <Card title="SWIFT Payouts" icon="globe" href="/guides/swift-payouts">
    Accept crypto and send fiat via SWIFT
  </Card>
</CardGroup>


## Related topics

- [Introduction](/introduction.md)