# CLI commands

Source: https://blocklive.io/docs/developers/cli/commands

Every command of the Blocklive CLI, its options, and what it prints.

## Commands

| Command                                                                  | What it does                                                                      |
| ------------------------------------------------------------------------ | --------------------------------------------------------------------------------- |
| `blocklive login`                                                        | Sign in through your browser ([signing in](https://blocklive.io/docs/developers/cli/sign-in)).                          |
| `blocklive logout`                                                       | Sign out here and end the sign-in on Blocklive.                                   |
| `blocklive whoami`                                                       | Who you're signed in as, what the sign-in may do, when it ends.                   |
| `blocklive events list`                                                  | The events you can see through this sign-in, newest first.                        |
| `blocklive event show <event>`                                           | One event: tickets sold, check-ins, ticket types.                                 |
| `blocklive guests list <event>`                                          | The event's guests. Managers and admins only.                                     |
| `blocklive promos list <event>`                                          | The event's promo codes, bulk codes and bulk imports.                             |
| `blocklive promos import <event> --file <codes.csv>`                     | Import bulk codes as drafts, after showing the plan.                              |
| `blocklive promos undo <event> [<import>]`                               | Your bulk imports, or undo one.                                                   |
| `blocklive invoices list <event>`                                        | Each order's invoice status, why it waits, and the seller of record.              |
| `blocklive invoice show <order>`                                         | One order's invoice, billing details and documents.                               |
| `blocklive invoice issue <order>`                                        | Issue an order's invoice, confirmed on Blocklive.                                 |
| `blocklive payment-account show <event>`                                 | Which account takes payments, and whether a switch would be refused.              |
| `blocklive payment-account switch <event> --to <account> --reason <why>` | Move card payments to another account (Blocklive admins), confirmed on Blocklive. |
| `blocklive developers list <team>`                                       | A team's or organization's developers, and whether developer access is on.        |
| `blocklive developers add <team> --email <address>`                      | Add or invite a developer, confirmed on Blocklive.                                |
| `blocklive domains list <team>`                                          | The custom domains of a team's events, and the DNS records to set.                |
| `blocklive domains claim <event> <hostname>`                             | Start connecting a custom domain to an event, confirmed on Blocklive.             |
| `blocklive help`                                                         | The list of commands and options.                                                 |

`<event>` is the event's ID or its slug, the last part of its link: the slug
of `blocklive.io/summer-opening` is `summer-opening`. The words `list` and
`show` can be left out:

```sh
blocklive event summer-opening
```

## events list

The events you can see through this sign-in, newest first.

```sh
blocklive events list
```

```text
WHEN                EVENT           SLUG            TEAM          YOU
13 Nov 2026, 18:00  Summer Opening  summer-opening  Night Market  manager
```

| Column  | Meaning                                                                                                             |
| ------- | ------------------------------------------------------------------------------------------------------------------- |
| `WHEN`  | When it starts, in the event's own time zone.                                                                       |
| `EVENT` | Its title.                                                                                                          |
| `SLUG`  | What to pass to `event show` and `guests list`.                                                                     |
| `TEAM`  | The team that runs it.                                                                                              |
| `YOU`   | Your role there: `door`, `manager`, `admin`, or `organization` for an organization admin. `key` through an API key. |

Without `--all` it shows the first 100 and then
`More events: use --all, or --limit.` when there are more.

## event show

One event, with how it's selling.

```sh
blocklive event show summer-opening
```

```text
Summer Opening  (active)
13 Nov 2026, 18:00 · Riverside Hall
Tickets sold: 212 · checked in: 0 · orders waiting: 3

TICKET TYPE        PRICE  SOLD  OF
General admission  25     200   400
VIP                60     12    40

On Blocklive: https://blocklive.io/manage/night-market/event/summer-opening/overview
```

-   **Tickets sold** counts confirmed purchases; **orders waiting** are
    purchases still being processed.
-   `OF` is how many tickets of that type there are.
-   The last line links to the event in Blocklive's admin, where refunds,
    cancellations and payouts are done.

## guests list

The event's guests: one row per ticket.

```sh
blocklive guests list summer-opening --all
```

```text
GUEST    EMAIL   TICKET             ORDER      CHECKED IN
Sam Lee  sam@…   General admission  confirmed  not yet
```

| Column       | Values                                                                 |
| ------------ | ---------------------------------------------------------------------- |
| `GUEST`      | The buyer's name.                                                      |
| `EMAIL`      | The buyer's email.                                                     |
| `TICKET`     | The ticket type.                                                       |
| `ORDER`      | `confirmed`, `pending`, `rejected` or `unknown`.                       |
| `CHECKED IN` | `in`, `not yet`, `no ticket yet` (the ticket isn't issued yet) or `?`. |

Who sees guests:

-   Managers and admins of the event or its team, as on the Attendees page.
-   Door staff see events and sales, not guests.
-   An organization admin sees its teams' events and sales, not their guests,
    unless they also hold a role at that team or event.
-   A sign-in through an API key lists the key's events only. Read attendees
    with the [developer API](https://blocklive.io/docs/developers) and the key.

Anyone else gets `forbidden` (exit code 3) with the reason, for example
`Your role at this event doesn't show its guests. Managers and admins see them.`

## promos list

An event's promo codes, bulk codes included, side by side with what is live,
and its bulk imports. What the promo codes editor shows.

```sh
blocklive promos list summer-opening --all
```

```text
CODE     OFF   USED  OF   EACH  TICKET  KIND  STATE
B-0001   100%  1     1    1     any     bulk  live
EARLY    20%   7     100  2     VIP     code  live
FRIENDS  15%   3     any  1     any     code  live, changes not published
LATE     5%    0     10   1     any     code  not published yet

Bulk imports:
  WHEN        CODES  STILL ON  BY
  8 Nov 2026  2      1         you
  7 Nov 2026  5      0         Mia Manager  undone 8 Nov 2026

Add, import or switch off codes on Blocklive: https://blocklive.io/manage/night-market/event/summer-opening/edit
```

| Column  | Meaning                                                                                      |
| ------- | -------------------------------------------------------------------------------------------- |
| `OFF`   | The discount, in percent.                                                                    |
| `USED`  | How many times it has been used.                                                             |
| `OF`    | How many times it can be used; `any` for no limit.                                           |
| `EACH`  | How many times one person can use it.                                                        |
| `KIND`  | `bulk` for a bulk code (card checkout only), `code` otherwise.                               |
| `STATE` | `live`; `live, changes not published`; `not published yet`; `off` (switched off or deleted). |

-   Codes are sorted by code, 100 a page (`--all` for every page). A code
    behind a token gate belongs to the gate and isn't listed.
-   **Bulk imports** are the last 20: how many codes each added, how many are
    still on, who imported them, and when one was undone.
-   Adding, importing and switching off codes is done in the event editor:
    the last line links to it.

Who sees them: the event's managers and admins, and the owner of its team's
organization. Door staff get `forbidden` with the reason.

## promos import

Imports bulk codes into an event as drafts, with the same rules as the event
editor's bulk import. Bulk codes can be 100% off and can unlock hidden
tickets, so the CLI only asks: you confirm the import on Blocklive, with
two-step verification. The codes work at card checkout only and go live
when the event is next published.

```sh
blocklive promos import summer-opening --file codes.csv --tickets "VIP" --percent 100
```

```text
Summer Opening: 248 codes to import (248 ticket discounts)
2 lines left out:
  LINE  CODE   WHY
  14    EARLY  already on the event
  77    sum 1  Codes are 3–40 letters, digits or dashes
Ask to import 248 codes into Summer Opening? [y/N] y
Confirm the import on Blocklive, with two-step, before 10:15:00:
  https://blocklive.io/cli/confirm#request=7b1e…
Imported 248 ticket discounts as drafts.
Publish on Blocklive to put them live: https://blocklive.io/manage/night-market/event/summer-opening/edit
```

-   The file is one code a line, or a CSV with a header row naming its
    columns (`code`, `discount`, `uses`, `per guest`, `tickets`, in any
    order), as in the event editor.
-   What a line leaves out comes from the options: `--percent` (default 100),
    `--uses` (default 1) or `--unlimited`, `--per-guest` (default 1),
    `--tickets "VIP;General"` (ticket type names, or `all`, the default).
-   Blocklive reads the file and shows the plan first: how many codes, and
    each line it leaves out and why. `y` (or `--yes`) sends the request;
    `--dry-run` stops after the plan.
-   The CLI then opens the confirm page (or prints its link; `--no-browser`
    to only print it) and waits. The page shows the event, how many codes and
    ticket discounts, the largest discount and how many codes unlock hidden
    tickets. Nothing is imported until you confirm there, with a new code
    from your authenticator, within 15 minutes. You can decline it there too.
-   The CLI imports up to 250 codes at a time; the event editor takes 1,000.
-   An event whose payments are self-custodial, or that takes crypto, can't
    have bulk codes. London's event, and Stable Summit's other events, can't be changed from the CLI until 15 November. The plan says so.

Who can import: the event's managers and admins, with a sign-in that may
**Edit drafts** (tick it when you approve `blocklive login`). Changes from
the CLI are limited per sign-in, event and person each hour.

## promos undo

Your bulk imports at an event, or undoes one of them.

```sh
blocklive promos undo summer-opening
blocklive promos undo summer-opening 7b1e…
```

Undoing shows what will change and asks first (`--yes` to skip); the undo
only works right after that plan, once. Codes never published are deleted;
published ones are switched off and go off at the next publish. Their uses
and orders stay. Only your own imports can be undone from the CLI; the event
editor undoes anyone's.

## invoices list

Each order of an event that has billing details or an invoice: its invoice
status, why it waits, and who the seller of record is. What the invoices
page shows.

```sh
blocklive invoices list summer-opening
```

```text
Invoicing: on · this event's payments go to the organiser

ORDER  BUYER           STATUS          SELLER         INVOICE     ID
#9     Lunar Fans Ltd  issued          the organiser  NMK-000001  2234…
#7     Ada Ruiz        needs review    not known yet              1234…

Why they wait:
  #7: Blocklive needs to confirm which account took this payment before it can be invoiced.

Issue invoices and change settings on Blocklive: https://blocklive.io/manage/night-market/invoices
```

| Status                        | Meaning                                                          |
| ----------------------------- | ---------------------------------------------------------------- |
| `issued`                      | An invoice exists (credit notes are listed with it).             |
| `being made`                  | An invoice is being made right now.                              |
| `ready to issue`              | Everything an invoice needs is there.                            |
| `billing details missing`     | The buyer hasn't entered billing details.                        |
| `invoice settings unfinished` | The organiser's invoice settings aren't finished.                |
| `needs review`                | Something waits for a person at Blocklive; the reason says what. |
| `not eligible`                | This order can't be invoiced; the reason says why.               |
| `invoicing off`               | Invoicing is off for the team.                                   |

-   **Seller of record** is whoever sold the tickets: the organiser, or
    Blocklive when its account took the payment. It's the issued invoice's,
    else the one the payment shows, else `not known yet`. The first line
    says whose account the event's payments go to now, for comparison.
-   25 orders a page, newest first (`--all` for every page; `--limit` up to
    25).
-   An invoice can be issued from the CLI (`invoice issue`, below); sending
    it and the invoice settings are on Blocklive: the last line links to
    them.

## invoice show

One order's invoice: status and reason, seller of record, the billing
details and every document (invoice, credit notes) with its number, date,
total and tax.

```sh
blocklive invoice show 12345678-1234-4234-8234-123456789abc
```

The order is named by its ID, as `invoices list` and `guests list --json`
show it.

Who sees invoices: the event's managers and admins, by their role at the
event or its team. Door staff, and an organization's owner without a role
there, get `forbidden` with the reason.

## invoice issue

Issues an order's invoice: a numbered document that can't be changed or
deleted, only credited. Invoices are confirmed on Blocklive, so the CLI only
asks: it opens the confirm page and waits.

```sh
blocklive invoice issue 12345678-1234-4234-8234-123456789abc
```

-   Only an order that is `ready to issue` (as `invoice show` says) can be
    asked for; one with its invoice, or still waiting for something, is
    refused with its status.
-   The confirm page shows the order, its seller of record, who it is billed
    to and the billing email. Nothing happens until you confirm there with a
    new code from your authenticator, within 10 minutes. Blocklive then
    issues it as the invoices page does.
-   It isn't emailed: send it from the invoices page. The CLI then says what
    the order has (`Issued: LUN-000003`, or why it wasn't issued).
-   The event's managers and admins can issue. Stable Summit's orders can't
    be issued from the CLI until 15 November.

## payment-account show

Which account takes an event's card payments, and whether switching it would
be refused now. Name an event, or a team for its default account and each
of its events. A name is tried as an event first, then as a team.

```sh
blocklive payment-account show summer-opening
```

```text
Summer Opening
Takes payments: stripe …Own9, the organiser's (Ana Ruiz), active
Team default: paypal …TEAM, the organiser's (Ana Ruiz), active
Last changed: 7 Nov 2026
Switching it: refused (3 card orders). This event has card orders paid to its current account, so its account can't change yet.

Payment accounts on Blocklive: https://blocklive.io/manage/night-market/settings/accounts
```

-   **Whose**: the organiser's own account, or Blocklive's when Blocklive is
    the merchant of record. Account IDs show their last 4 characters only.
-   **Switching it** says what Blocklive would do if a Blocklive admin
    switched the event's account now: refused while the event has card
    orders paid to its current account (card payments, and checkouts for
    money from the last 7 days), allowed otherwise. Setting an account where
    there is none isn't a switch.
-   For a team, its default only applies to new events: switching it is
    never refused, and every event keeps its own account. Each event is
    listed with its own account and switch answer.
-   Switching is done by Blocklive; the CLI never switches.

Who sees it: managers and admins of the event or team, and the owner of the
team's organization. Door staff get `forbidden` with the reason.

## payment-account switch

Moves where an event's (or a team's) card payments go. Only Blocklive's
admins change a payment account once it is set, so the CLI only asks: it
opens the confirm page and waits.

```sh
blocklive payment-account switch summer-opening --to <account ID> --reason "Organiser's own Stripe"
blocklive payment-account switch summer-opening --to team --reason "Back to the team's account"
```

-   `--to` is the account's ID, or `team` for the event's team default. A
    name is tried as an event first, then as a team (a team's switch changes
    new events only; every event keeps its own).
-   Blocklive refuses it at once when the event has card orders paid to its
    current account (they settle and refund there), when it already uses
    that account, or without a reason.
-   The confirm page shows from and to, the reason and the card orders.
    Nothing changes until you confirm there with a new code from your
    authenticator, within 10 minutes. If its account changed in between, the
    confirm is refused: run the command again.
-   Stable Summit's events can't be switched from the CLI until 15 November.

## developers list

Who manages API keys at a team or an organization, the invitations still open
there, and whether developer access is on. What the Developer page shows its
admins.

```sh
blocklive developers list night-market
blocklive developers list party-action-people --org
```

```text
Night Market (team)
Developer access: on, through Party Action People

DEVELOPER  EMAIL                  ADDED AT      ADDED
Ana Ruiz   an•••@studio.example   this team     5 Nov 2026
Max Kim    ma•••@partner.example  organization  2 Nov 2026

Invited, no answer yet:
  dev@agency.example  (until 12 Nov 2026)

Add or remove developers on Blocklive: https://blocklive.io/manage/night-market/developer
```

-   Name a team or an organization by its ID or slug. When a team and an
    organization have the same slug, the team is shown; `--org` picks the
    organization.
-   **Developer access** is `on` or `off`. At a team it's on through its
    organization's switch, or for that team alone when Blocklive switched it
    on.
-   A team lists its own developers and its organization's, who manage the
    team's keys too (`ADDED AT`). `paused` means their team or event moved
    since they were added: an admin there adds them again.
-   Developers' email addresses are masked, as on the Developer page.
    Invitations show the address that was typed.
-   Adding, inviting and removing developers is done on the Developer page:
    the last line links to it.

Who sees it: the team's admins, and the organization's owner for the
organization and every team in it. Anyone else gets `forbidden` (exit code 3)
with the reason. A team or organization outside your sign-in is `not_found`
(exit code 4). A sign-in through an API key gets `forbidden`.

## domains list

The custom domains of a team's events: each one's state and the DNS records
to set at the domain's DNS provider. What the team's domains page and the
domain editor show.

```sh
blocklive domains list night-market
```

```text
tickets.nightmarket.example  Summer Opening
  waiting for the TXT record (since 8 Nov 2026)
  Set these DNS records:
    TYPE   NAME                                             VALUE
    TXT    _blocklive-challenge.tickets.nightmarket.example  blocklive-domain=…
    CNAME  tickets                                          cname.vercel-dns.com

Connect, check or remove domains on Blocklive: https://blocklive.io/manage/night-market/settings/domains
```

| State                                            | Meaning                                                                      |
| ------------------------------------------------ | ---------------------------------------------------------------------------- |
| `waiting for the TXT record`                     | Claimed; Blocklive is waiting to see the ownership record.                   |
| `connecting`                                     | Ownership is proven; the domain is being connected.                          |
| `connected`                                      | It serves the event. `connected, DNS not right` when the records are off.    |
| `connected before the check; add the TXT record` | It serves the event, and its owner is asked to prove it with the TXT record. |
| `set before the check, not connected`            | A domain set on the event before the check, never claimed.                   |
| `being removed`                                  | A removal is in progress.                                                    |
| `held for Blocklive to review`                   | Blocklive holds the hostname; contact Blocklive.                             |

-   The records come from the same reads as the domain editor, cached for a
    minute. When they can't be read, the domain says so: run it again.
-   Claiming a domain can start in the CLI (`domains claim`, below);
    checking, connecting and removing a domain is done on Blocklive: the last
    line links to it.

Who sees them: the team's managers and admins. Door staff and an
organization's owner without a role at the team get `forbidden` with the
reason.

## domains claim

Starts connecting a custom domain to an event: Blocklive stores a claim and
the TXT record that proves you own the domain. Domains are confirmed on
Blocklive, so the CLI only asks: it opens the confirm page and waits.

```sh
blocklive domains claim summer-opening tickets.nightmarket.example
```

-   The domain is a name like `tickets.example.com`: no `https://`, path or
    port.
-   The confirm page shows the domain and what the event has now. Nothing is
    claimed until you confirm there with a new code from your
    authenticator, within 10 minutes.
-   An event with a domain in use removes it on Blocklive first. A claim
    still waiting for its TXT record moves to the new domain.
-   Then set its DNS records (`blocklive domains list <team>` shows them) and
    connect it on Blocklive. Nothing is served at the domain before that.
-   The event's managers and admins can claim; door staff and an
    organization's owner without a role at the team can't. Stable Summit's
    events can't be changed from the CLI until 15 November.

## developers add

Asks to make someone a developer of a team or an organization: who manages
its API keys. Access changes are confirmed on Blocklive, so the CLI only
asks: it opens the confirm page and waits.

```sh
blocklive developers add night-market --email ana@studio.example
blocklive developers add party-action-people --org --email dev@agency.example
```

```text
Asked to make Ana Ruiz (an•••@studio.example) a developer of the team Night Market.
Confirm it on Blocklive, with a code from your authenticator, before 10:10:00:
  https://blocklive.io/cli/confirm#request=…
Done: Ana Ruiz can now make API keys for Night Market. They get an email saying so.
```

-   Someone already on the team (or one of the organization's teams) is
    added, as from the Developer page's search, and gets an email saying
    so. Anyone else is invited: they accept on Blocklive.
-   The confirm page shows exactly who, where and which computer asked.
    Nothing changes until you confirm there with a new code from your
    authenticator, within 10 minutes. You can decline it there too.
-   `--org` when an organization has the team's name; `--no-browser` to
    only print the link.
-   At most 5 requests wait at once; changes from the CLI are limited each
    hour.

Who can ask: the team's admins and the organization's owner, as on the
Developer page. Removing a developer is done there. Stable Summit's team
can't get developers from the CLI until 15 November.

## Options

| Option               | What it does                                                                              |
| -------------------- | ----------------------------------------------------------------------------------------- |
| `--profile <name>`   | Use another saved sign-in. Default `default` (see [profiles](https://blocklive.io/docs/developers/cli/sign-in#profiles)).       |
| `--limit <n>`        | How many rows on a page, 1 to 100. Default 100.                                           |
| `--all`              | Every page, not just the first.                                                           |
| `--org`              | The name is an organization's (`developers list`).                                        |
| `--json`             | Print JSON instead of text (see [JSON output](https://blocklive.io/docs/developers/cli/scripts#json-output)).                   |
| `--api <url>`        | Which Blocklive to sign in to. Default `https://blocklive.io`. Only `https://` addresses. |
| `--insecure-storage` | Keep the sign-in in a file when the computer has no keychain.                             |
| `--help`, `-h`       | Show help.                                                                                |
| `--version`          | Show the version.                                                                         |

Options go anywhere after `blocklive`. An option the CLI doesn't know, or a
missing value, stops with exit code 2.

`--base-url` is the same as `--api`, and the `BLOCKLIVE_API_URL` environment
variable sets it too. A profile remembers the address it signed in to; to use
another, sign in with another `--profile`.
