---
title: "Check attendees in at the door"
description: "Scan an attendee's ticket code to let them in at an event's session, undo a mistaken scan, count who's in, and run automations and certificates of attendance off a check-in."
---

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

# Check attendees in at the door

Every attendee going to an event holds a ticket code of 10 letters and digits, like `T7K2M9QXWD`; the people still waiting on the [guest list](/merchant-api/guides/event-guest-lists) get theirs once you let them in. Their ticket in your store shows it as a QR code, and the code under it to read out. Your door scans the code and checks them in at the session that's on, once a session: a two-day event lets them in on each day. This guide checks people in. It uses the `sherpo` helper from [your first call](/merchant-api/first-call) and a token with `attendee:checkin`.

`attendee:checkin` is all a door needs. It checks attendees in and undoes it, and reads the door's counts and the events to check in, but never the guest list, which takes `customer:read`. A check-in it makes still runs the event's [automations](#automations-on-check-in) and issues its [certificates of attendance](#certificates-of-attendance), though it reads neither. A team member with only this permission sees only the merchant app's Check-in page.

## Find the event and the session

<a href="/merchant-api/reference/list-check-in-events/">`GET /products/check_in`</a> lists the events with a session held in person (at a venue of its own, or of an event that isn't online) that's still to run or ended in the last 12 hours, soonest first, at most 50. Each has how many are `going`, and each of its sessions how many are `checked_in`.

<a href="/merchant-api/reference/event-check-in-stats/">`GET /products/{product}/attendees/check_in/stats`</a> counts one event's door: who's going, and every session with how many were let in.

```bash
curl 'https://api.sherpo.io/merchant/v1/stores/STORE_ID/products/5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e/attendees/check_in/stats' \
  -H "Authorization: Bearer $SHERPO_TOKEN"
```

```js
const answer = await sherpo('GET', '/v1/stores/STORE_ID/products/5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e/attendees/check_in/stats');
```

Answers `200`, abridged:

```json
{
  "going": 42,
  "sessions": [
    {
      "id": "8d7c6b5a-4f3e-4d2c-9b1a-0f9e8d7c6b5a",
      "product_id": "5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e",
      "starts_at": "2026-11-07T18:00:00.000Z",
      "ends_at": "2026-11-07T21:00:00.000Z",
      "time_zone": "Europe/Rome",
      "venue": "Orto Botanico, Padova",
      "online_label": null,
      "created_at": "2026-09-12T10:00:00.000Z",
      "updated_at": "2026-09-12T10:00:00.000Z",
      "place": "Orto Botanico, Padova",
      "checked_in": 38
    }
  ]
}
```

## Check someone in

<a href="/merchant-api/reference/check-in-event-attendee/">`POST /products/{product}/attendees/check_in`</a> takes the `session` and either the `ticket_code` your scanner read or the `attendee` from the guest list:

```bash
curl -X POST 'https://api.sherpo.io/merchant/v1/stores/STORE_ID/products/5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e/attendees/check_in' \
  -H "Authorization: Bearer $SHERPO_TOKEN" \
  -H 'Idempotency-Key: door-T7K2M9QXWD' \
  -H 'Content-Type: application/json' \
  -d '{
  "session": {
    "id": "8d7c6b5a-4f3e-4d2c-9b1a-0f9e8d7c6b5a"
  },
  "ticket_code": "T7K2M9QXWD"
}'
```

```js
const answer = await sherpo('POST', '/v1/stores/STORE_ID/products/5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e/attendees/check_in', {
  body: {
    "session": {
      "id": "8d7c6b5a-4f3e-4d2c-9b1a-0f9e8d7c6b5a"
    },
    "ticket_code": "T7K2M9QXWD"
  },
  key: 'door-T7K2M9QXWD',
});
```

Answers `200`, abridged:

```json
{
  "result": "checked_in",
  "attendee": {
    "id": "2f1e0d9c-8b7a-4695-8483-7261f5e4d3c2",
    "status": "going",
    "cancel_reason": null,
    "tier": {
      "id": "9e8d7c6b-5a4f-4e3d-8c2b-1a0f9e8d7c6a",
      "name": "In person",
      "rank": 2
    },
    "customer": {
      "id": "7e6d5c4b-3a29-4180-9f7e-6d5c4b3a2918",
      "name": "Ada Lovelace",
      "email": "ada@example.com",
      "erased": false
    }
  },
  "check_in": {
    "id": "4a5b6c7d-8e9f-4a0b-8c1d-2e3f4a5b6c7d",
    "session_id": "8d7c6b5a-4f3e-4d2c-9b1a-0f9e8d7c6b5a",
    "checked_in_at": "2026-11-07T18:04:00.000Z",
    "checked_in_by": null,
    "token_id": "tok_door_scanner"
  },
  "checked_in": 39,
  "going": 42
}
```

- **`ticket_code`** is read however it's typed: case, spaces and hyphens don't matter. A code never holds `0`, `1`, `I`, `L`, `O` or `U`, so one with any of them, or of another length, names no attendee.
- **`result`** is `checked_in` when this call let them in, `already_checked_in` when an earlier call had (its `check_in` says when, and who or which token), or `not_going` when they hold no ticket to it: no longer (their `cancel_reason` says why), or not yet, while their request waits for your approval or they're on the waitlist (their `status` is `pending` or `waitlisted`). Only `checked_in` lets someone in; the other two name the person so your door can tell them why.
- **`check_in`** is the check-in that lets them in (`null` when they're `not_going`), with its `id`, which an [automation](#automations-on-check-in)'s run names as its trigger.
- **`attendee`** is who the code belongs to: their name, email and ticket type, so your door can check it's them. Their phone and the rest of the guest list stay out.
- **`checked_in`** and **`going`** count the session's door after the call.

Send an `Idempotency-Key` with every scan. A scan your scanner retries over a bad connection then answers as it did the first time, so it never reads as a copied ticket.

A code that names no attendee of this event, or that was cleared when its customer was erased, answers `not_found`. A refund or a revoke after someone was checked in keeps the check-in on record.

## Undo a check-in

<a href="/merchant-api/reference/undo-event-attendee-check-in/">`DELETE /products/{product}/attendees/{attendee}/check_in`</a> takes back the attendee's check-in at the `session`, as after a mistaken scan:

```bash
curl -X DELETE -g 'https://api.sherpo.io/merchant/v1/stores/STORE_ID/products/5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e/attendees/2f1e0d9c-8b7a-4695-8483-7261f5e4d3c2/check_in?session[id]=8d7c6b5a-4f3e-4d2c-9b1a-0f9e8d7c6b5a' \
  -H "Authorization: Bearer $SHERPO_TOKEN" \
  -H 'Idempotency-Key: undo-door-T7K2M9QXWD'
```

```js
const answer = await sherpo('DELETE', '/v1/stores/STORE_ID/products/5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e/attendees/2f1e0d9c-8b7a-4695-8483-7261f5e4d3c2/check_in', {
  query: [
    ['session[id]', '8d7c6b5a-4f3e-4d2c-9b1a-0f9e8d7c6b5a'],
  ],
  key: 'undo-door-T7K2M9QXWD',
});
```

Answers `200`, abridged:

```json
{
  "attendee_id": "2f1e0d9c-8b7a-4695-8483-7261f5e4d3c2",
  "session_id": "8d7c6b5a-4f3e-4d2c-9b1a-0f9e8d7c6b5a",
  "undone": true,
  "checked_in": 38,
  "going": 42
}
```

It answers `not_found` when they weren't checked in at that session. A session that let anyone in keeps its check-ins: [deleting it](/merchant-api/reference/delete-event-session) answers `conflict` on `event_session`, with `blocked_by` counting the `event_check_in` rows. So does deleting a session an automation names, with `blocked_by` counting `automation`.

## Read check-ins from the guest list

With `customer:read`, every row of the [guest list](/merchant-api/guides/event-guest-lists) carries its `check_ins`, one per session, each with its `id`, and `filter[checked_in_session]` keeps those let in at one session. The guest list's stats count `checked_in_by_session`. The ticket code is never on the guest list, its export or its webhooks: it's the attendee's alone.

## Automations on check-in

An automation whose `trigger` is `event.checked_in` runs its action for the customer let in. It names the event as its `product`, and optionally one of the event's sessions as its `session`, to run only on a check-in there:

```json
{
  "name": "Thanks for coming",
  "trigger": {
    "kind": "event.checked_in",
    "product": { "slug": "spring-meetup" },
    "session": { "id": "8d7c6b5a-4f3e-4d2c-9b1a-0f9e8d7c6b5a" }
  },
  "action": { "kind": "product.unlock", "product": { "slug": "meetup-recordings" } }
}
```

Create it with <a href="/merchant-api/reference/create-automation/">`POST /automations`</a>, which needs `automation:write` and `product:read`. A `product` that isn't an event answers `conflict` on `category`, and a `session` of another event answers `not_found`.

A rule runs once per customer, as a `product.reviewed` rule runs once per reviewer: on their first check-in at any of the event's sessions, or at the one it names. Letting them in at another session runs it no more. The run names the check-in's `id` as its trigger. A run whose customer no longer holds a check-in it runs on when it runs, as after a scan undone at once, is `skipped` with the reason `trigger gone`; a scan, an undo and a scan again still run it once. An undo after a run succeeded keeps what it unlocked or the discount code it made. Runs of an `event.checked_in` rule that weren't skipped are kept past the 92 days runs are kept, so a rule never runs twice for the same customer.

## Certificates of attendance

An event's certificate is earned by attendance when you create it with <a href="/merchant-api/reference/create-certificate/">`POST /products/{product}/certificates`</a> and `settings.earned_on` set to `attendance`, which needs `certificate:write`, or set it later with <a href="/merchant-api/reference/update-certificate/">`PATCH /products/{product}/certificates/{certificate}`</a>. One check-in at any of the event's sessions is attendance, and issues it to the customer let in, with no score or attempt. Without `earned_on`, it's issued only by hand, and `completion` is a course's alone: an event refuses it as `invalid`, as a course refuses `attendance`. Creating one, or switching a certificate to `attendance`, issues it to everyone already checked in, a short while after.

Undoing a customer's last check-in at the event takes back what a check-in issued them: the issue reads as revoked, and its `certificate.issued` webhooks not yet delivered are dropped, though one delivered can't be recalled. Their next check-in issues it again, under the same id. A certificate you <a href="/merchant-api/reference/revoke-certificate-issue/">revoked</a> or issued by hand stays as it is: no check-in or undo changes it.

Only a check-in counts as attendance, so an online attendee is checked in too: from the guest list in the merchant app, or here by their `attendee` in place of a `ticket_code`. Like a course's, an event's certificates need a plan with quizzes and certificates (see [Plans](/merchant-app/plans)).

Source: https://docs.sherpo.io/merchant-api/guides/event-check-in/index.mdx
