# Quickstart: take your first payment

> Go from a new business account to your first paid payment link with the Anytime Capital Payments API: create a key, create a link, verify a webhook.

Source: https://anytime-capital.com/docs/quickstart · Markdown: https://anytime-capital.com/docs/quickstart.md · All docs: https://anytime-capital.com/docs/llms-full.txt

This guide takes you from a new account to a paid payment link and a verified webhook in about fifteen minutes. You need a terminal and, for the webhook, a server reachable over `https://`.

## 1. Open a business account and get verified

[Create your business account](https://anytime-capital.com/business/get-started) and finish verification in **Settings → Verification**. The API answers `403 NOT_ENROLLED` until your business is verified and set up for card payments.

> **Start in test mode:** You don't have to wait for verification to build: turn on **Test mode** in the dashboard header, create a test key (`ak_test_…`) and follow this guide with test data and the sandbox test cards. No real money moves. See [Test mode](https://anytime-capital.com/docs/test-mode.md).

## 2. Create a secret key

In **Settings → Developers**, choose **Create key** and copy it: it's shown once. Keys made in test mode start with `ak_test_`, live ones with `ak_live_`. Keep it in an environment variable on your server, never in front-end code. Check it works:

```bash
export ANYTIME_API_KEY="ak_live_…"

curl "https://anytime-capital.com/api/v1/payments?limit=1" \
  -H "Authorization: Bearer $ANYTIME_API_KEY"
```

A `200` with `{"object": "list", …}` means you're connected. A `401` means the key is wrong; see [Authentication](https://anytime-capital.com/docs/authentication.md).

## 3. Create a payment link

**curl**

```bash
curl -X POST https://anytime-capital.com/api/v1/payment-links \
  -H "Authorization: Bearer $ANYTIME_API_KEY" \
  -H "Idempotency-Key: order-1042" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Consulting — October",
    "amountCents": 12500,
    "singleUse": true,
    "metadata": { "orderId": "1042" }
  }'
```

**Node.js 18+**

```javascript
import { randomUUID } from "node:crypto";

// Server-side only: the key never reaches the browser.
const res = await fetch("https://anytime-capital.com/api/v1/payment-links", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.ANYTIME_API_KEY}`,
    "Content-Type": "application/json",
    "Idempotency-Key": randomUUID(), // store it with the order and reuse it on retries
  },
  body: JSON.stringify({
    title: "Consulting — October",
    amountCents: 12500,
    singleUse: true,
    metadata: { orderId: "1042" },
  }),
});
const link = await res.json();
if (!res.ok) throw new Error(`${link.error.code}: ${link.error.message}`);
console.log(link.url); // send the customer here
```

**Python**

```python
import os, uuid, requests

res = requests.post(
    "https://anytime-capital.com/api/v1/payment-links",
    headers={
        "Authorization": f"Bearer {os.environ['ANYTIME_API_KEY']}",
        "Idempotency-Key": str(uuid.uuid4()),  # store it with the order and reuse it on retries
    },
    json={"title": "Consulting — October", "amountCents": 12500, "singleUse": True, "metadata": {"orderId": "1042"}},
    timeout=30,
)
link = res.json()
if not res.ok:
    raise RuntimeError(f"{link['error']['code']}: {link['error']['message']}")
print(link["url"])  # send the customer here
```

**Response (201)**

```json
{
  "object": "payment_link",
  "livemode": true,
  "id": "pl_4kTz8QwN2xYb6RcD1mPa",
  "url": "https://anytime-capital.com/pay/business/pl_4kTz8QwN2xYb6RcD1mPa",
  "title": "Consulting — October",
  "description": null,
  "amountCents": 12500,
  "currency": "usd",
  "active": true,
  "singleUse": true,
  "shippingCents": 0,
  "collectShipping": false,
  "allowDiscountCodes": false,
  "successUrl": null,
  "confirmationMessage": null,
  "requireTermsConsent": false,
  "metadata": {
    "orderId": "1042"
  },
  "items": [],
  "createdAt": "2026-10-01T09:30:00.000Z",
  "deactivatedAt": null,
  "allowQuantity": false,
  "maxQuantity": null,
  "customFields": [],
  "tipsEnabled": false,
  "payWhatYouWant": false,
  "minAmountCents": null
}
```

## 4. Send the customer to the link

Redirect the customer to `url`, email or text it, or show it as a QR code. To keep customers on your site, open the same link as a Pay button or an inline checkout: see [Checkout](https://anytime-capital.com/docs/checkout.md). Add `successUrl` when you create the link to bring them back to your site afterwards.

## 5. Confirm payment with a webhook

In **Settings → Developers**, choose **Add endpoint**, enter your `https://` URL and pick `payment.succeeded`. Store the signing secret as `ANYTIME_WEBHOOK_SECRET`, verify the `Anytime-Signature` header on every request, and mark order `data.metadata.orderId` paid. The full verification code for Node.js, Next.js and Python is on [Webhooks](https://anytime-capital.com/docs/webhooks.md).

## 6. Check your payments

```bash
curl "https://anytime-capital.com/api/v1/payments?status=paid&limit=10" \
  -H "Authorization: Bearer $ANYTIME_API_KEY"
```

> **Test first, then go live:** Run every step above in test mode with a test key: pay the link with the sandbox test card, and use the [event simulator](https://anytime-capital.com/docs/test-mode.md#test-your-integration) to send your endpoint refunds, disputes and renewals. Then swap in a live key and a live endpoint's secret; nothing else in your code changes.

## Node SDK

`@anytimecapital/node` wraps the API for Node.js 18 and later, with no dependencies: typed resources, `for await` over every page of a list, an Idempotency-Key on every write so its automatic retries (on `429`, `5xx` and network errors, honouring `Retry-After`) never act twice, typed errors, and webhook verification. It isn't on npm yet; until it is, call the API directly as above or generate a client from the OpenAPI document. Its whole interface is on [Node SDK](https://anytime-capital.com/docs/node-sdk.md).

**Preview**

```typescript
import { AnytimeCapital, AnytimeCapitalError } from "@anytimecapital/node";

const client = new AnytimeCapital({ apiKey: process.env.ANYTIME_API_KEY! });

const link = await client.paymentLinks.create(
  { title: "Order 1042", amountCents: 12500, singleUse: true, metadata: { orderId: "1042" } },
  { idempotencyKey: "order-1042-link" },
);

for await (const payment of client.payments.list({ status: "paid" })) {
  console.log(payment.id, payment.paymentLinkId, payment.metadata.orderId);
}

// Catch up on events (the last 30 days), e.g. after your webhook endpoint was down:
for await (const event of client.events.list({ type: "payment.*", createdFrom: "2026-10-20" })) {
  await handleOnce(event); // skip ids you've already handled
}

// In your webhook handler, with the raw request body. During a secret
// rotation, pass both secrets: an event verifies if either signed it.
const event = AnytimeCapital.webhooks.constructEvent(rawBody, signatureHeader, [
  process.env.ANYTIME_WEBHOOK_SECRET!,
  process.env.ANYTIME_WEBHOOK_SECRET_PREVIOUS!,
]);

// Every error carries the API's code and the Request-Id the request log shows.
try {
  await client.refunds.create({ paymentId: "pay_7Hq2LmX9cR4tVb" });
} catch (error) {
  if (error instanceof AnytimeCapitalError) console.error(error.code, error.requestId);
}

// Test mode only (an ak_test_ key): send your test endpoints a dispute now.
await client.testHelpers.events.create({ type: "dispute.opened" });
```

`client.events` lists and retrieves [events](https://anytime-capital.com/docs/webhooks.md#events-api) (the `events` permission). `constructEvent` accepts one signing secret or several, and checks every `v1=` in the header, so events signed during a [secret rotation](https://anytime-capital.com/docs/webhooks.md#rotating-the-signing-secret) verify with the old secret or the new one. With a test key, `client.testHelpers.events.create` sends your test endpoints a [simulated event](https://anytime-capital.com/docs/test-mode.md#test-your-integration).

## OpenAPI

The whole API is described in OpenAPI 3.1 at `https://anytime-capital.com/api/v1/openapi.json`: every endpoint with its parameters, bodies, responses and errors, the permission each needs (`x-anytime-permission`) and whether it takes an Idempotency-Key. It is public, so API clients, code generators and AI tools can load it directly. See [OpenAPI](https://anytime-capital.com/docs/openapi.md).

```bash
curl https://anytime-capital.com/api/v1/openapi.json
```

## Next steps

- [Accept a payment in Next.js](https://anytime-capital.com/docs/nextjs-checkout.md): This flow as a complete App Router app.
- [Invoices](https://anytime-capital.com/docs/invoices.md): Bill a customer by email with line items, tax and deposits.
- [Errors and retries](https://anytime-capital.com/docs/errors.md): One error shape, and how to retry safely.
- [AI agents](https://anytime-capital.com/docs/build-with-ai.md): Let Claude or your editor's assistant write the integration.

---

Anytime Capital is a fintech company, not a bank. Payment processing, banking and payout services are provided by Anytime Capital's licensed partners. Rates shown are for US card payments; international cards, currency conversion and disputes may carry additional fees shown in your dashboard before you accept a payment.