> Tillcast is live: the API at https://api.tillcast.com/v1 and the dashboard at https://dashboard.tillcast.com. A key prints on real printers, so do not call the API unless asked. A job carries its receipt as "document", an array of blocks (the recommended way), or as "receiptline", ReceiptLine text, exactly one of the two: read https://docs.tillcast.com/create-a-print-job.md and https://docs.tillcast.com/concepts/documents.md before you write a job body. Do not code against what does not exist yet: webhooks, a template language, stored templates (a job has no template field), OAuth connections and connectors for Make, Zapier and n8n, and OAuth sign-in for the MCP server. SDKs for TypeScript (@tillcast/sdk, version 0.2.0 or later for blocks) and Python (tillcast) exist as pre-1.0 versions. To show a receipt in a web page without printing, there are the npm packages @tillcast/preview and @tillcast/html-render (0.x, no API key, no call to Tillcast to draw): read https://docs.tillcast.com/preview-a-receipt.md. The docs are the source of truth: check the index https://docs.tillcast.com/llms.txt and https://docs.tillcast.com/roadmap.md before you code against anything. For clean Markdown of any page, append .md to the page URL. The Tillcast MCP server is live at https://api.tillcast.com/mcp and takes an API key as a bearer token (setup: https://docs.tillcast.com/connect-an-ai-assistant.md). It acts on the live account and its tools print on real paper, so do not connect to it or call its tools unless the owner asked you to. The MCP server at https://docs.tillcast.com/_mcp/server is a different one: it only searches these docs and cannot call the Tillcast API.

# Create a print job

> How to create a Tillcast print job with cURL, TypeScript or Python: the request and its fields, the 201 answer, reading the job, retrying with an idempotency key, the usual refusals, and receipts to copy.

A print job is one document for one printer. You create it with one call, `POST /v1/printers/{printer}/jobs`. Tillcast renders the document for the printer and queues it, and the printer takes it on its next poll and prints it. This is the call your software makes for every receipt, ticket and report.

> **The API prints on real paper**
>
> A key prints on real printers. Keep it in an environment variable, never in code, and send your tries to the printer you mean to print on.

## What you need

* **An API key** with the scope `jobs:write`, and `jobs:read` to read a job back. Make it in the dashboard, under **API keys**. See [Authentication and API keys](/api/authentication).
* **The id of a printer**, `prn_...`. It is in the answer that adds the printer, in the printers list of the dashboard, and in `GET /v1/printers`, which you can filter by [`client_reference_id`](/concepts/client-reference-id). The printer does not have to be online: the job waits for it.
* **For the SDKs,** `npm install @tillcast/sdk` or `pip install tillcast`, version 0.2.0 or later. See [SDKs](/getting-started/sdks).

The samples on this page read the key and the printer id from `TILLCAST_API_KEY` and `TILLCAST_PRINTER_ID`. If you have no key or printer yet, the [quickstart](/quickstart) sets both up step by step.

## The smallest job

This job prints one line. The key in `Idempotency-Key` is new on every run, so every run prints. See [Retry safely](#retry-safely).

#### TypeScript

```ts
import { TillcastClient } from "@tillcast/sdk";

const client = new TillcastClient({ token: process.env.TILLCAST_API_KEY! });

const job = await client.jobs.create({
  printer: process.env.TILLCAST_PRINTER_ID!,
  "Idempotency-Key": `hello-${Date.now()}`,
  document: [{ type: "text", text: "Hello from Tillcast" }],
});
console.log(job.id, job.status);
```

#### Python

```python
import os
import time

from tillcast import Tillcast

client = Tillcast(token=os.environ["TILLCAST_API_KEY"])

job = client.jobs.create(
    printer=os.environ["TILLCAST_PRINTER_ID"],
    idempotency_key=f"hello-{int(time.time())}",
    document=[{"type": "text", "text": "Hello from Tillcast"}],
)
print(job.id, job.status)
```

#### cURL

```bash wordWrap
curl https://api.tillcast.com/v1/printers/$TILLCAST_PRINTER_ID/jobs \
  -H "Authorization: Bearer $TILLCAST_API_KEY" \
  -H "Tillcast-Version: 2026-10-01" \
  -H "Idempotency-Key: hello-$(date +%s)" \
  -H "Content-Type: application/json" \
  -d '{"document": [{"type": "text", "text": "Hello from Tillcast"}]}'
```

To run a TypeScript sample, use Node 22.18 or later (Node 24 does too), which runs TypeScript directly: the types are stripped and nothing else is needed. Save the sample as `send.mts` and run `node send.mts`. Code that needs more than stripping the types, such as an `enum` or a constructor parameter property, is refused with `ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX`: use a compiler or a loader, or run `node --experimental-transform-types send.mts`, which prints an experimental warning. The three tabs send the same request.

## The request

| Part                      | Meaning                                                                                                                                                                                                 |
| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `printer`, in the path    | The id of the printer, `prn_...`. A MAC address is not accepted.                                                                                                                                        |
| `Authorization` header    | `Bearer` and your key. The SDKs set it from `token`.                                                                                                                                                    |
| `Tillcast-Version` header | Optional. The API version your code was written for, `2026-10-01` today. The SDKs do not send it, so they get the current version. See [Versioning](/api/versioning).                                   |
| `Idempotency-Key` header  | Optional, 1 to 64 visible ASCII characters. Makes a retry safe. In TypeScript it is the property `"Idempotency-Key"` of the request, and in Python the argument `idempotency_key`.                      |
| `document`                | The receipt, as an array of 1 to 1,000 [blocks](/concepts/documents) in print order. Send this or `receiptline`, exactly one of the two.                                                                |
| `receiptline`             | The receipt as text in ReceiptLine, for documents written for other ReceiptLine tools. See [Advanced: ReceiptLine text](/concepts/documents#advanced-receiptline-text).                                 |
| `client_reference_id`     | Optional. Your own id for the job, such as the order number, 1 to 128 characters. Not unique. No personal data. See [Your own IDs](/concepts/client-reference-id).                                      |
| `metadata`                | Optional. Up to 10 pairs, 1 KB in all. No personal data.                                                                                                                                                |
| `expires_in`              | Optional. How many seconds the printer may be offered the job, from 60 to 604,800. The default is 86,400 (24 hours). A kitchen ticket that is an hour late is worse than none, so give it a short time. |

The body is closed: a field that is not in this table is refused with `400 parameter_unknown`. There is no `template` or `data` field: a template language and stored templates are in development and not available. Build the document in your code.

## The answer

The answer is `201` with the job. It is `queued`.

```json wordWrap
{
  "id": "job_01M466JX008T2V5X7Z9C1E3G5H",
  "object": "job",
  "printer": "prn_01M44X7TQ0A9R2H5J8K1M4N7P0",
  "customer": "cus_c3x9k2m3",
  "location": "loc_01M42YMFP03Q1P9N7M5K3H1G0F",
  "kind": "api",
  "status": "queued",
  "size_bytes": 156,
  "profile": "star-starprnt-utf8-80mm",
  "transport": "cloudprnt-star.1",
  "warnings": [],
  "result_code": null,
  "reason": null,
  "client_reference_id": null,
  "metadata": null,
  "created_at": "2026-10-17T09:30:00Z",
  "delivered_at": null,
  "completed_at": null,
  "expires_at": "2026-10-18T09:30:00Z"
}
```

* `id` is what you read the job back with.
* `warnings` lists what the renderer noticed in the document. It is always there, and empty when there is nothing to say.
* `profile` is the [profile](/printers/profiles) the document was rendered for, and `size_bytes` is the size of what the printer is sent.

Tillcast renders the document when it accepts the job, so a document that cannot be printed is an answer to this request, as in [When a job is refused](#when-a-job-is-refused), and not a job that fails later. All the fields are in [Jobs](/concepts/jobs#what-a-job-is).

## What happens next

The printer polls Tillcast, every 5 seconds by default. At its next poll it downloads the job, prints it and confirms. The job moves from `queued` to `delivered` to `printed`, or ends `failed`, `expired` or `cancelled`. See [Job states](/concepts/jobs#job-states).

Read the job with its id. These lines continue the sample above.

#### TypeScript

```ts
const status = await client.jobs.get({ job: job.id });
console.log(status.status, status.reason, status.result_code);
```

#### Python

```python
status = client.jobs.get(job.id)
print(status.status, status.reason, status.result_code)
```

#### cURL

```bash wordWrap
curl https://api.tillcast.com/v1/jobs/$JOB \
  -H "Authorization: Bearer $TILLCAST_API_KEY" \
  -H "Tillcast-Version: 2026-10-01"
```

Here `$JOB` is the `id` from the answer. If the status is `failed`, `reason` and `result_code` say why. With its spooler on, an Epson answers `printed` when it has accepted the page, so the paper decides.

* **Do not poll faster than you need.** A printer takes a job within about one poll interval. Webhooks, which would tell you without polling, are planned and not built yet. See [Webhooks and events](/events/webhooks).
* **Find the jobs of an order** with `GET /v1/jobs?client_reference_id=order-4711`. See [Jobs](/concepts/jobs#knowing-what-happened).
* **Cancel a job that is still `queued`** with `POST /v1/jobs/{job}/cancel`. A job that the printer has downloaded cannot be cancelled.
* Jobs are kept for 7 days after they end.

## Retry safely

A call can fail after Tillcast has accepted it: a timeout, a dropped connection, a `5xx`. If you send it again without a key, a second job is queued and a second receipt prints. With an `Idempotency-Key`, the retry answers the first job.

**What the SDKs retry, and what they do not** (checked in version 0.2.1 of both packages):

* They retry only when Tillcast **answered**: twice by default, when the status is `408`, `429` or a `5xx`. The Python package also retries `409`, which cannot succeed for a suspended customer. The retry sends the same request, so it carries the same key.
* They wait for the `Retry-After` header of the answer, up to 60 seconds for one wait, and otherwise 1 second and then 2. A `queue_full` answer sends `Retry-After: 30`, so one `jobs.create` can block for about a minute before it raises. In a request handler, set `maxRetries` (TypeScript) or `max_retries` (Python) to 0, on the client or on one call, and decide yourself what to do with a `429`.
* They **do not retry a timeout or a dropped connection**, which are the cases where Tillcast may already have accepted the job. The call raises after one try: `TillcastTimeoutError` or a `TillcastError` with no status in TypeScript, and an `httpx` error in Python. (The Python package retries when the connection is refused or cannot be made, because then nothing was sent, and not when the connection times out.) The default timeout is 60 seconds in both.

So the SDK does not cover a lost answer, and you must. Write down the print you intend **before** you call, and when the call raises without an answer, send the same request again yourself, with the same `Idempotency-Key` and the same body. Within 24 hours you get the first job back, never a second one. A request with another body is `422 idempotency_key_reused`.

Use one key for each print you intend, for example the order number and the kind of paper (`order-4711-bill`, `order-4711-kitchen`), and a new key for a new receipt. This sample sends the same request twice, as a retry would.

#### TypeScript

```ts
import { Tillcast, TillcastClient } from "@tillcast/sdk";

const client = new TillcastClient({ token: process.env.TILLCAST_API_KEY! });

const request: Tillcast.CreateJob = {
  printer: process.env.TILLCAST_PRINTER_ID!,
  "Idempotency-Key": "order-4711-kitchen",
  document: [{ type: "text", text: "Table 7: flat white" }],
  client_reference_id: "order-4711",
};

const first = await client.jobs.create(request).withRawResponse();
const again = await client.jobs.create(request).withRawResponse();

console.log(first.rawResponse.status, first.data.id);
console.log(again.rawResponse.status, again.rawResponse.headers.get("idempotent-replayed"), again.data.id);
```

#### Python

```python
import os

from tillcast import Tillcast

client = Tillcast(token=os.environ["TILLCAST_API_KEY"])


def send():
    return client.jobs.with_raw_response.create(
        printer=os.environ["TILLCAST_PRINTER_ID"],
        idempotency_key="order-4711-kitchen",
        document=[{"type": "text", "text": "Table 7: flat white"}],
        client_reference_id="order-4711",
    )


first = send()
again = send()

print(first.status_code, first.data.id)
print(again.status_code, again.headers.get("idempotent-replayed"), again.data.id)
```

#### cURL

```bash wordWrap
curl -i https://api.tillcast.com/v1/printers/$TILLCAST_PRINTER_ID/jobs \
  -H "Authorization: Bearer $TILLCAST_API_KEY" \
  -H "Tillcast-Version: 2026-10-01" \
  -H "Idempotency-Key: order-4711-kitchen" \
  -H "Content-Type: application/json" \
  -d '{"document": [{"type": "text", "text": "Table 7: flat white"}], "client_reference_id": "order-4711"}'
```

Run the cURL command twice to see the same. The first call answers `201`. The second answers `200` with the header `Idempotent-Replayed: true`, and the job in the answer has the same `id` as the first. Nothing new is queued and nothing prints twice. The same key with a different body is `422 idempotency_key_reused`. A key is remembered for 24 hours. See [Idempotency](/api/idempotency).

Idempotency stops the duplicates that your retries make. A Star printer can still print a job twice after a power cut, so make a repeated print harmless. See [Delivery and duplicates](/concepts/jobs#delivery-and-duplicates).

## When a job is refused

A refusal is an HTTP status and an error with a stable `code` to branch on, a `message` for a person, the `param` the error is about and a `request_id` to quote when you ask for help. A refused create writes nothing and leaves its key free.

The most common refusal is a document that cannot be printed as it is said: `422 document_invalid`, and `param` is the path of the first problem. This sample sends a table with two columns and a row of three cells. These lines continue the sample above.

#### TypeScript

```ts
try {
  await client.jobs.create({
    printer: process.env.TILLCAST_PRINTER_ID!,
    "Idempotency-Key": "order-4712-bill",
    document: [
      { type: "text", text: "Harbour Cafe" },
      { type: "table", columns: ["*", 9], rows: [["Flat white", "3.40", "1"]] },
    ],
  });
} catch (err) {
  if (!(err instanceof Tillcast.UnprocessableEntityError)) throw err;
  const { code, param, message, request_id } = err.body.error;
  console.error(code, param, message, request_id);
}
```

#### Python

```python
from tillcast import UnprocessableEntityError

try:
    client.jobs.create(
        printer=os.environ["TILLCAST_PRINTER_ID"],
        idempotency_key="order-4712-bill",
        document=[
            {"type": "text", "text": "Harbour Cafe"},
            {"type": "table", "columns": ["*", 9], "rows": [["Flat white", "3.40", "1"]]},
        ],
    )
except UnprocessableEntityError as err:
    error = err.body.error
    print(error.code, error.param, error.message, error.request_id)
```

#### cURL

```bash wordWrap
curl https://api.tillcast.com/v1/printers/$TILLCAST_PRINTER_ID/jobs \
  -H "Authorization: Bearer $TILLCAST_API_KEY" \
  -H "Tillcast-Version: 2026-10-01" \
  -H "Idempotency-Key: order-4712-bill" \
  -H "Content-Type: application/json" \
  -d '{"document": [{"type": "text", "text": "Harbour Cafe"}, {"type": "table", "columns": ["*", 9], "rows": [["Flat white", "3.40", "1"]]}]}'
```

The answer is `422`.

```json wordWrap
{
  "error": {
    "type": "invalid_request_error",
    "code": "document_invalid",
    "message": "document[1].rows[0] must have at most 2 cells (as many as the table has columns).",
    "param": "document[1].rows[0]",
    "request_id": "req_01M466JX008T2V5X7Z9C1E3G5H"
  }
}
```

`param` counts from 0 in the order of the document: block 1 is the table, and row 0 is its first row. The message never holds a piece of your text. In the SDKs the error is an exception, `Tillcast.UnprocessableEntityError` in TypeScript and `UnprocessableEntityError` in Python, and the body above is its `body`.

These are the refusals you meet most often. [Errors](/api/errors) lists every code.

| Status       | Code                                                            | Why, and what to do                                                                                                                                                                                                    |
| ------------ | --------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `401`        | `invalid_api_key`                                               | The key is wrong, revoked or expired. Check the key.                                                                                                                                                                   |
| `403`        | `insufficient_scope`                                            | The key lacks `jobs:write`. Make a key with the scope.                                                                                                                                                                 |
| `404`        | `resource_missing`                                              | No such printer. The id is wrong, the printer was deleted, it belongs to another organization, or the key is limited to one customer and the printer is another customer's. A MAC address is not a printer id.         |
| `409`        | `customer_suspended`, `location_suspended`                      | The customer is suspended or the location is paused, so no job is queued. Retrying does not help until it is reactivated. See [Suspension and pause](/concepts/suspension).                                            |
| `413`        | `document_too_large`, `rendered_too_large`, `request_too_large` | The document, what it renders to or the request is over a limit. Send less. See [Limits and refusals](/concepts/documents#limits-and-refusals).                                                                        |
| `422`        | `document_invalid`                                              | A block cannot be printed as it is said, or the job has both `document` and `receiptline`, or neither. `param` is the path of the first problem. See [Errors in a document](/concepts/documents#errors-in-a-document). |
| `422`        | `document_empty`                                                | The document has no block, or prints nothing.                                                                                                                                                                          |
| `422`        | `idempotency_key_reused`                                        | The key was used for a different request. Use a new key for a new receipt.                                                                                                                                             |
| `429`        | `queue_full`                                                    | The printer already has 50 jobs waiting. Wait for the seconds in the `Retry-After` header.                                                                                                                             |
| `500`, `503` | `internal_error`                                                | A problem on Tillcast's side, and nothing was queued. Send the same request again with the same key.                                                                                                                   |

## A receipt to copy

A title, a line with the table number and a table with two items, a rule and a total. This is the first document of [Receipt documents](/concepts/documents#a-first-document), with the key and the order number of a real order.

#### TypeScript

```ts
import { TillcastClient } from "@tillcast/sdk";

const client = new TillcastClient({ token: process.env.TILLCAST_API_KEY! });

const job = await client.jobs.create({
  printer: process.env.TILLCAST_PRINTER_ID!,
  "Idempotency-Key": "order-4711-bill",
  document: [
    { type: "text", text: "Harbour Cafe", align: "center", bold: true, size: 2 },
    { type: "text", text: "Table 7", align: "center" },
    {
      type: "table",
      columns: ["*", { width: 9, align: "right" }],
      rows: [
        ["Flat white", "3.40"],
        ["Lemon cake", "4.20"],
        { type: "rule" },
        [{ text: "Total", bold: true }, { text: "7.60", bold: true }],
      ],
    },
  ],
  client_reference_id: "order-4711",
});
console.log(job.id, job.status, job.warnings);
```

#### Python

```python
import os

from tillcast import Tillcast

client = Tillcast(token=os.environ["TILLCAST_API_KEY"])

job = client.jobs.create(
    printer=os.environ["TILLCAST_PRINTER_ID"],
    idempotency_key="order-4711-bill",
    document=[
        {"type": "text", "text": "Harbour Cafe", "align": "center", "bold": True, "size": 2},
        {"type": "text", "text": "Table 7", "align": "center"},
        {
            "type": "table",
            "columns": ["*", {"width": 9, "align": "right"}],
            "rows": [
                ["Flat white", "3.40"],
                ["Lemon cake", "4.20"],
                {"type": "rule"},
                [{"text": "Total", "bold": True}, {"text": "7.60", "bold": True}],
            ],
        },
    ],
    client_reference_id="order-4711",
)
print(job.id, job.status, job.warnings)
```

#### cURL

```bash wordWrap
curl https://api.tillcast.com/v1/printers/$TILLCAST_PRINTER_ID/jobs \
  -H "Authorization: Bearer $TILLCAST_API_KEY" \
  -H "Tillcast-Version: 2026-10-01" \
  -H "Idempotency-Key: order-4711-bill" \
  -H "Content-Type: application/json" \
  -d '{
    "document": [
      {"type": "text", "text": "Harbour Cafe", "align": "center", "bold": true, "size": 2},
      {"type": "text", "text": "Table 7", "align": "center"},
      {"type": "table", "columns": ["*", {"width": 9, "align": "right"}],
       "rows": [["Flat white", "3.40"], ["Lemon cake", "4.20"], {"type": "rule"},
                [{"text": "Total", "bold": true}, {"text": "7.60", "bold": true}]]}
    ],
    "client_reference_id": "order-4711"
  }'
```

On paper this is what a 58 mm printer prints. The text view is 32 characters wide, and it cannot show bold, underline or inverse. It shows a line of double size with a space after every letter.

```text
    H a r b o u r   C a f e
             Table 7
Flat white                  3.40
Lemon cake                  4.20
--------------------------------
Total                       7.60
```

Every block, with its fields, is in [Receipt documents](/concepts/documents). Text of your own, such as a name or an item, goes into a block as it is: nothing in a block is markup.

## The same receipt as ReceiptLine text

If you already have documents written for other ReceiptLine tools, send the text in `receiptline` instead of `document`. In JSON a line break is `\n`. The blocks are the way to write a receipt: in ReceiptLine text the characters of the language are yours to escape. See [Advanced: ReceiptLine text](/concepts/documents#advanced-receiptline-text).

#### TypeScript

```ts
import { TillcastClient } from "@tillcast/sdk";

const client = new TillcastClient({ token: process.env.TILLCAST_API_KEY! });

const job = await client.jobs.create({
  printer: process.env.TILLCAST_PRINTER_ID!,
  "Idempotency-Key": "order-4712",
  receiptline: "Harbour Cafe\nTable 7\n{width:*,9}\nFlat white | 3.40\nLemon cake | 4.20\n-\nTotal | 7.60",
  client_reference_id: "order-4712",
});
console.log(job.id, job.status, job.warnings);
```

#### Python

```python
import os

from tillcast import Tillcast

client = Tillcast(token=os.environ["TILLCAST_API_KEY"])

job = client.jobs.create(
    printer=os.environ["TILLCAST_PRINTER_ID"],
    idempotency_key="order-4712",
    receiptline="Harbour Cafe\nTable 7\n{width:*,9}\nFlat white | 3.40\nLemon cake | 4.20\n-\nTotal | 7.60",
    client_reference_id="order-4712",
)
print(job.id, job.status, job.warnings)
```

#### cURL

```bash wordWrap
curl https://api.tillcast.com/v1/printers/$TILLCAST_PRINTER_ID/jobs \
  -H "Authorization: Bearer $TILLCAST_API_KEY" \
  -H "Tillcast-Version: 2026-10-01" \
  -H "Idempotency-Key: order-4712" \
  -H "Content-Type: application/json" \
  -d '{"receiptline": "Harbour Cafe\nTable 7\n{width:*,9}\nFlat white | 3.40\nLemon cake | 4.20\n-\nTotal | 7.60", "client_reference_id": "order-4712"}'
```

```text
          Harbour Cafe
             Table 7
Flat white                  3.40
Lemon cake                  4.20
--------------------------------
Total                       7.60
```

## See the paper: the test print

To see paper without writing a document, queue a test page. In the dashboard, press **Test print** on the printer's page. With the API, call `POST /v1/printers/{printer}/test-print`, which takes no body and the scope `jobs:write`. The answer is a job whose `kind` is `test`, and the printer prints it at its next poll. Use a new `Idempotency-Key` each time: the same key answers the first test job and prints nothing.

#### TypeScript

```ts
import { TillcastClient } from "@tillcast/sdk";

const client = new TillcastClient({ token: process.env.TILLCAST_API_KEY! });

const test = await client.printers.testPrint({
  printer: process.env.TILLCAST_PRINTER_ID!,
  "Idempotency-Key": `test-${Date.now()}`,
});
console.log(test.id, test.kind, test.status);
```

#### Python

```python
import os
import time

from tillcast import Tillcast

client = Tillcast(token=os.environ["TILLCAST_API_KEY"])

test = client.printers.test_print(
    os.environ["TILLCAST_PRINTER_ID"],
    idempotency_key=f"test-{int(time.time())}",
)
print(test.id, test.kind, test.status)
```

#### cURL

```bash wordWrap
curl -X POST https://api.tillcast.com/v1/printers/$TILLCAST_PRINTER_ID/test-print \
  -H "Authorization: Bearer $TILLCAST_API_KEY" \
  -H "Tillcast-Version: 2026-10-01" \
  -H "Idempotency-Key: test-$(date +%s)"
```

A test print is never billed. A printer takes at most 5 test prints in any minute and 3 waiting at a time, so a printer that is not online refuses the fourth with `429 rate_limited` until it prints the three or an hour has passed. The short page and the full page, which shows every barcode type, QR code and image, are described in [First connection](/printers/first-connection#test-print).

## Where to go next

* Write real receipts: [Receipt documents](/concepts/documents), with every kind of block.
* Build the integration in your till or order system: [Integrate a point of sale](/integrate-a-pos).
* Handle failure: [Errors](/api/errors), [Idempotency](/api/idempotency) and [Jobs](/concepts/jobs).
* Install the packages: [SDKs](/getting-started/sdks).
* Browse every operation in the [API reference](/api-reference).