# BriefGate

## In one paragraph (quotable summary)

BriefGate is a client-intake service for agencies, freelancers and AI coding
agents: you list what a project needs — logo, copy, photos, structured answers,
logins — and the client gets one branded portal link, with no account to create,
that works on a phone. BriefGate reminds the client on a schedule you choose
(default day 2, 5 and 9, then weekly, held outside 8:00–19:00 in the client's own
time zone), validates each answer against 12 typed item types, encrypts submitted
credentials and reveals them exactly once, and hands the results back as typed
data through MCP or the REST API, or as a single ZIP from the dashboard. It runs
in the EU (servers in Nuremberg, files in Cloudflare R2 with EU jurisdiction).
There is a free tier with one active intake and ten items, no time limit; paid
plans start at $29/month (Solo) and add custom branding, the secrets vault and
unlimited items. Docs: https://briefgate.dev/docs · Pricing as JSON:
https://api.briefgate.dev/pricing.json · OpenAPI:
https://api.briefgate.dev/v1/openapi.json

BriefGate is client intake for agencies, freelancers and AI coding agents. It
collects the files, texts, structured answers and credentials a project needs
from a client, chases the client automatically, and hands everything back in one
place. Requests can be created by hand in the browser dashboard — no code, no
agent — or by an AI coding agent through MCP or the REST API.

## When an AI agent should use BriefGate

Use it when a task is blocked on something only a human outside this
conversation can provide: files (logo, product photos), copy, brand assets,
structured answers, or credentials/logins — and that person may take hours or
days to respond, so something needs to chase them without you polling by hand.

Do not use it when the information is already available (in the repo, in the
conversation, in an earlier BriefGate intake) or when the person you are
talking to right now can just answer directly — BriefGate is for people who
are not in this conversation.

Flow: call `define_intake` with the typed items you need, then poll
`get_intake_status`. An item staying `pending`, or the intake staying `sent`
or `in_progress`, is the normal state while BriefGate chases the client — not
an error. Once items are submitted, call `get_intake_results` for typed
values back (its `missing` array names anything still outstanding). If a
submitted value is wrong or incomplete, call `request_revision` with a note
instead of asking again yourself. `secret` items (passwords, API keys) are
released through `get_intake_results` once — the plaintext is present only on
the first successful read (`first_reveal: true`); store it immediately.
Secrets are encrypted server-side on arrival, not end-to-end — see
https://briefgate.dev/docs/security.

## The problem it solves

Web and design projects stall waiting on the client: the logo, the page copy,
the opening hours and the WordPress password live in a person's head or inbox.
Asking again by email or Slack costs time and goodwill, and nothing tracks what
is still missing. For AI coding agents it is worse — an agent can build a
website in an afternoon, but has no way to ask a non-technical client for these
things, chase them, validate what comes back, or notice when it arrives.

## Two ways to use it

BriefGate is not agent-only. A person can do everything by hand in the browser,
and an agent can do everything through MCP or the API — pick either, or mix
them on the same account. The client sees the same portal either way.

- **By hand in the browser dashboard — no agent, no code, no API key** — https://app.briefgate.dev/app:
  create an intake from scratch, from one of 3 onboarding samples (website,
  branding, campaign), or from a template (the built-in public templates —
  restaurant, advisor, club/association — are Czech-only; saving your own
  needs the Solo plan or higher), send the client the portal link, track
  progress, organize intakes into folders, request a revision on a submitted
  item — Solo plan or higher; an item otherwise auto-approves once the
  intake's configurable auto-approve window elapses — download everything as
  one ZIP, invite teammates onto the account (1 seat on Free/Solo/Studio, 3 on
  Agency). A first-run wizard sends a real test intake to the signer's own
  inbox so a new account can see the client side before inventing a real
  project.
  Step-by-step guide: https://briefgate.dev/docs/dashboard-quickstart
- **AI coding agent** — via MCP (13 tools on the hosted endpoint, at
  `https://mcp.briefgate.dev/mcp`) or the REST API below.

Landing pages for people who arrive without an agent:
https://briefgate.dev/collect (English), https://briefgate.dev/cs/sber-podkladu
(Czech).

## How it works

1. The request is created — by hand in the dashboard (pick the items, or start
   from a sample or a template), or by an agent calling `define_intake` (MCP) or
   `POST /v1/intakes` (REST) with typed items: keys, labels and constraints.
2. BriefGate emails the client a branded portal reachable by magic link. No
   account, no password, no registration on the client's side. The portal
   renders in the client's language: Czech, Slovak, Polish, German, Spanish or
   English.
3. The client answers, uploads files and submits credentials. BriefGate
   validates each item against its declared type, and reminds them on the
   schedule chosen for the intake; every reminder lists only what is still
   missing.
4. In the dashboard you watch items arrive and download everything as one ZIP.
   An agent instead gets a webhook, or calls `get_intake_results` and receives
   typed JSON — file URLs with checksums, structured objects, validated strings,
   and secret values released once to a key holding the `secrets:read` scope —
   plus a `missing` array naming anything still outstanding.
5. The project continues: you have the materials, or the agent keeps building.

## Who it is for

- Web agencies and freelancers running several client projects at once — by
  hand from the dashboard, without ever touching MCP or the API
- Anyone whose work stalls waiting on assets, content or credentials from a client
- AI coding agents: Claude Code, Cursor, Codex, Windsurf, any MCP-compatible client
- Custom agent loops over the REST API

## How it differs from a form builder

A form builder leaves you to design the form, then read the answers and chase
the gaps yourself. BriefGate adds what a form does not: reminders that list only
what is still missing, per-item validation, revision requests (Solo plan or
higher), one-time secret reveal, and everything back in one ZIP or as typed
JSON. For agents, the item types, the typed response, the `missing` array, the
idempotency and the webhooks exist so an automated caller can act on the outcome
without a person in the middle. The human-facing half — the portal, the
reminders — never mentions agents, MCP or APIs.

## Base URLs

- API: https://api.briefgate.dev
- Portal (client-facing): https://p.briefgate.dev
- App (dashboard, browser or agent — see "Two ways to use it" above): https://app.briefgate.dev/app
- Machine-readable pricing: https://api.briefgate.dev/pricing.json (no auth)
- OpenAPI spec: https://api.briefgate.dev/v1/openapi.json (no auth)
- Full documentation, one file (auto-generated, for a single large fetch): https://briefgate.dev/llms-full.txt
- Support: support@briefgate.dev (data protection: privacy@briefgate.dev)

## AI assistants

BriefGate connects to any MCP-capable AI assistant through the same hosted
endpoint. Per-client setup (Claude Code, Cursor, OpenAI Codex, claude.ai,
Claude Desktop, VS Code/GitHub Copilot, Gemini CLI, ChatGPT, Windsurf), with
what's confirmed working vs. not yet run end-to-end by us, stated plainly for
each: https://briefgate.dev/docs/ai-assistants

## n8n

`n8n-nodes-briefgate` is a community node for the n8n workflow automation
platform: a BriefGate action node (create/list/get status/get results/send
reminder, also usable as an AI Agent tool) and a BriefGate Trigger node for
webhook events. Verified by n8n: on n8n Cloud add it from the canvas nodes
panel (Verified Community Nodes enabled in the Admin Panel); on self-hosted
n8n also via Settings → Community Nodes. npm: n8n-nodes-briefgate. Source and workflow
templates: https://github.com/sekera-radim/n8n-nodes-briefgate. Guide:
https://briefgate.dev/docs/n8n

## Zapier

BriefGate for Zapier is a private beta, not yet listed in Zapier's app
directory; anyone can use it through the invite link
https://zapier.com/developer/public-invite/246461/bf6cf6f634d011065659aba77f0ab803/
Instant triggers: Intake Completed, Item Submitted, Client Viewed Portal,
Intake Overdue. Actions: Create Intake, Send Reminder. Searches: Find Intake,
Get Intake Results (always excludes secret items, which stay unrevealed).
Guide: https://briefgate.dev/docs/zapier

## Authentication

All API requests require a Bearer token:

```
Authorization: Bearer bg_live_xxxxx
(Keys created with `mode: test` are `bg_test_…`: they see only their own intakes and those intakes never email or text a client — sends are recorded as skipped.)
```

Scopes: `admin`, `intakes:read`, `intakes:write`, `secrets:read`. `admin` includes all others; webhook endpoints specifically require `admin` (`intakes:read`/`intakes:write` are not enough).

## MCP tools

Hosted endpoint (no install, no key to paste): `https://mcp.briefgate.dev/mcp` — Streamable HTTP with OAuth 2.1 (PKCE, public clients). A header-based alternative for CI/scripts still works: `Authorization: Bearer bg_live_xxxxx`.
Add to Claude Code (hosted, OAuth): `claude mcp add --transport http briefgate https://mcp.briefgate.dev/mcp`, then inside Claude Code run `/mcp` → briefgate → Authenticate — opens a browser to sign in and approve access.
Add to Claude.ai (hosted, OAuth): Settings > Connectors > Add custom connector, URL `https://mcp.briefgate.dev/mcp`.
Add to Claude Code (local, via npx, device login): `claude mcp add briefgate -- npx -y @briefgate/mcp` then `npx -y @briefgate/mcp login` — prints a code, opens the dashboard, stores the resulting key in `~/.briefgate/credentials.json`.
Add to Claude Code (local, via npx, API key): `claude mcp add briefgate -- npx -y @briefgate/mcp --api-key bg_live_xxxxx`
Cursor / Windsurf / any MCP client: hosted URL with OAuth or an `Authorization: Bearer` header, or the `npx -y @briefgate/mcp` command with either `login` or `BRIEFGATE_API_KEY` in env.

13 tools work on the hosted endpoint and map 1:1 to REST endpoints below. `login`/`logout` are two further utility tools that exist only in the local `npx` package (not on the hosted endpoint, where connecting already does OAuth) — 15 tools total there.

| Tool | Description | Key params |
|---|---|---|
| `define_intake` | Create a new intake and (optionally) email the client portal link | `project_name`, `client.email`, `client.name`, `items[]`, `branding` (`logo_url`/`accent_color`/`sender_name`/`reply_to`), `chase_schedule`, `template`, `due_date`, `retention`, `send` (bool), `folder_id` |
| `get_intake_status` | Poll for current status, progress and chase history | `intake_id` |
| `get_intake_results` | Retrieve typed values for approved (or all submitted) items | `intake_id`, `only_new` (bool), `include_pending` (bool) |
| `request_revision` | Flag an item and ask the client to resubmit with a note | `intake_id`, `item_key`, `note` |
| `send_chase` | Send a manual reminder outside the schedule | `intake_id`, `channel` (`email`) |
| `list_intakes` | List intakes, optionally filtered | `status`, `client_email`, `folder_id`, `q` (free-text search), `limit`, `offset` |
| `add_items` | Append new items to an already-sent intake | `intake_id`, `items[]` |
| `update_item` | Change an existing item's definition (not its `key` or `assignee`) | `intake_id`, `item_key`, `type`, `label`, `help`, `required`, `constraints`, `options`, `pattern` |
| `update_intake` | Edit a sent intake without re-inviting the client | `intake_id`, `project_name`, `due_date`, `chase_schedule`, `max_reminders`, `folder_id`, `client.name`/`.phone`/`.language`/`.timezone` (not `.email` — see `manage_recipients`) |
| `manage_recipients` | Add, remove, or reinstate an extra recipient on the same portal link | `intake_id`, `action` (`add`/`remove`/`reinstate`), `email`, `name` |
| `manage_webhook` | Create, list, or delete webhook endpoints | `action` (`create`/`list`/`delete`), `url`, `events[]`, `format`, `webhook_id` |
| `list_folders` | List folders used to group intakes by client or project | — |
| `create_folder` | Create a new folder (fails with `folder_exists` on a duplicate name) | `name` |

## Core REST endpoints

### API keys
Creating, listing and revoking a key (other than the one making the request) is dashboard-session only — an API key cannot manage other keys.
- `POST /v1/keys` — create a key, with `scopes[]`
- `GET /v1/keys` — list keys
- `DELETE /v1/keys/:id` — revoke a key
- `DELETE /v1/keys/current` — revoke the key making the request (the one exception: works with an API key)

### Intakes
- `POST /v1/intakes` — create intake (same as `define_intake`)
- `GET /v1/intakes` — list intakes
- `GET /v1/intakes/:id` — get full intake detail (items, progress)
- `GET /v1/intakes/:id/status` — lightweight status/progress/chase history (same as `get_intake_status`)
- `PATCH /v1/intakes/:id` — update (chase_schedule, due_date, `client_brief`, etc. — not client.email, see recipients)
- `DELETE /v1/intakes/:id` — delete intake and all associated files
- `POST /v1/intakes/:id/brief/files` — attach a file to the client brief (`client_brief` on create/PATCH) shown at the top of the portal before the requested items; multipart, same content-sniffing/HEIC-conversion/antivirus pipeline as a client's own upload, max 10 files per intake
- `DELETE /v1/intakes/:id/brief/files/:fileId` — remove a brief attachment, releases its bytes from the storage quota
- `GET /v1/intakes/:id/brief/files/:fileId/url` — 302 redirect to a signed URL for a brief attachment (422 while it is still scanning or if it was flagged)
- `GET /v1/intakes/:id/results` — typed results, secrets revealed once (same as `get_intake_results`; API key only, needs `secrets:read`/`admin` to see secret values)
- `POST /v1/intakes/:id/items/:key/reveal` — reveal one secret item (dashboard session, owner only)
- `POST /v1/intakes/:id/send` — send a draft intake (only valid while `status` is `draft`)
- `POST /v1/intakes/:id/archive` — close an intake from any status without deleting it: cancels pending chases, blocks further edits/submissions/waivers (`409 intake_archived`, same as an already-archived intake returns elsewhere), keeps the row/files/history and the client portal link (which now resolves closed, `status: "archived"`); empty body, returns `{ intake }` (same single-object shape as `PATCH /v1/intakes/:id`, not the fuller `GET /v1/intakes/:id` bundle); reversible counterpart to `DELETE`, which is not
- `POST /v1/intakes/:id/chase` — send manual reminder
- `POST /v1/intakes/:id/revision` — request item revision (same as `request_revision`); requires the Solo plan or higher (`revisions` feature — `402 plan_required` on Free)
- `POST /v1/intakes/:id/items` — append items to a sent intake (same as `add_items`)
- `PATCH /v1/intakes/:id/items/:key` — edit an item's definition (same as `update_item`)
- `POST /v1/intakes/:id/items/:key/done` — tick off an owner task (`assignee: "owner"`); never completes the intake
- `POST`/`DELETE /v1/intakes/:id/items/:key/received-outside` — mark a client item as received outside BriefGate (e-mail, call…) with an optional `note`; counts as complete, can finish the intake; DELETE undoes it. Items carry `received_outside` + `received_outside_note`
- `POST`/`DELETE /v1/intakes/:id/recipients` — add/remove/reinstate a recipient (same as `manage_recipients`)
- `GET /v1/intakes/preview` — preview the invite email's subject/sender before sending (session only)
- `GET /v1/intakes/:id/download/preflight` — check ZIP size, skipped files and secret counts before downloading
- `GET /v1/intakes/:id/download?include_secrets=true|false` — download everything as one ZIP (`podklady.pdf`+`podklady.md`+files); `include_secrets` needs the owner's session or a `secrets:read`/`admin` key, and consumes the one-time reveal

### Clients
No clients table — this is a view over `intakes`, grouped case-insensitively by email, so it knows every client from before this endpoint existed and cannot drift from what was really sent.
- `GET /v1/clients` — list clients derived from past intakes (`q` search, `limit`/`offset`); name/language/phone/timezone/folder_id come from each client's most recent intake, ordered by intake count then recency; same `intakes:read` scope and test/live mode restriction as `GET /v1/intakes`

### Folders
- `GET /v1/folders` — list folders
- `POST /v1/folders` — create a folder
- `PATCH /v1/folders/:id` — rename or reorder
- `DELETE /v1/folders/:id` — delete (intakes inside move to Unfiled)

### Templates
A handful of public templates (accountId is null, `is_public: true`) ship with every deployment and are visible to any authenticated caller, and even to an unauthenticated one, on any plan including Free — reading and consuming a template needs no paid plan. The built-in public templates are Czech-only today: `restaurant-web-cs`, `advisor-web-cs`, `club-web-cs`.
- `GET /v1/templates` — list templates (public + the account's own; no `?public=true` or other query filter exists — filter client-side)
- `GET /v1/templates/:slug` — get one template by slug (public or the account's own)
- `POST /v1/templates` — create a template from an item array, plus optional `settings` (every other create-intake field: chase cadence, retention, branding, folder, `due_in_days`) applied as defaults when an intake is created from it — the intake's own request always wins on a field it sets; requires the Solo plan or higher (`custom_templates` feature — `402 plan_required` on Free); dashboard's "Save as template" button next to Send stores items + language + this same `settings` shape (chase schedule/interval, quiet hours, max reminders, email copy overrides, auto-approve hours, retention, folder, due-in-days) — it does not carry over the account's branding or the client's own contact details; dashboard session only — an API key cannot create templates; use `template: "<slug>"` on `define_intake`/`POST /v1/intakes` to consume one (`items` is still required there too, even with `template` set)

### Webhooks
All routes below need the `admin` scope on an API key; only the account owner may register, remove, test or retry (any member may list/view on a dashboard session).
- `POST /v1/webhooks` — register endpoint
- `GET /v1/webhooks` — list registered endpoints
- `DELETE /v1/webhooks/:id` — deregister
- `POST /v1/webhooks/:id/test` — send a synthetic test event
- `GET /v1/webhooks/:id/deliveries` — delivery history (last 100 attempts)
- `POST /v1/webhooks/:id/deliveries/:deliveryId/retry` — re-queue one delivery (doesn't reset the attempt count)

### Account and billing
- `GET /v1/account` — account info, current tier, branding (logo, accent color, sender name), `billing_grace_until` / `billing_grace_expired` when a renewal payment failed (same fields on `GET /v1/auth/me`)
- `POST`/`DELETE /v1/account/logo`, `POST`/`DELETE /v1/account/signature` — upload/remove the logo and the e-mail signature image (business card) shown at the bottom of every client e-mail (multipart `file`, dashboard session only); both URLs come back as `brand_logo_url` / `brand_signature_url` on `GET /v1/auth/me`
- `PATCH /v1/account` — update those settings, incl. `sending_local_part` (the part before @ on a verified sending domain, default `intake`) and `send_client_thank_you` (the one thank-you e-mail the client gets when an intake completes; on by default, never in test mode; owner notice + webhook unaffected)
- `GET /v1/usage` — current period usage vs plan limits
- `GET /v1/audit` — audit log (session only, account owner only; param `action`, e.g. `secret.revealed` — no per-intake filter, filter client-side)
- `POST /v1/billing/checkout` — start Stripe Checkout (dashboard session only)
- `POST /v1/billing/portal` — Stripe Customer Portal URL (dashboard session only)

Custom sending/portal domains (Studio or Agency plan) are dashboard-only too, no REST endpoint at all.

### Team seats
All dashboard-session only, no API key — except `accept`, which needs no session and proves itself with the invite token instead.
- `GET /v1/team` — list members and pending invites
- `POST /v1/team/invites` — invite an email into a seat (owner-only; 402 `quota_exceeded` reason `seats` once members + pending invites fill the plan limit)
- `DELETE /v1/team/invites/:id` — cancel a pending invite (owner-only)
- `POST /v1/team/invites/accept` — accept with `{token, name, password}`; creates the member and returns a session cookie
- `DELETE /v1/team/members/:id` — remove a member (owner-only; the owner can't be removed)

### Portal (client-facing, no auth)
- `GET /portal/:slug` — serve portal UI
- `POST /portal/:slug/redeem` — exchange magic link token for session cookie

### Public (no auth)
- `GET /pricing.json` — machine-readable plan limits and pricing (also at `/v1/pricing.json`)
- `GET /v1/openapi.json` — OpenAPI 3.1 spec for the whole API
- `GET /healthz` — liveness
- `GET /readyz` — readiness (DB + object storage + email provider)

## Item types

All items share: `key` (string, unique in intake), `type`, `label`, `help` (optional), `required` (bool, default true).

| Type | Description | Key constraints |
|---|---|---|
| `text` | Single-line string | `max_chars`, `pattern` (regex, top-level field), `min_chars` |
| `longtext` | Multi-line string | `max_chars`, `min_chars` |
| `image` | Single image file | `formats` (extension list, e.g. `svg`,`png`), `min_width`, `min_height`, `max_width`, `max_height`, `max_bytes`, `transparent_background` (bool) |
| `file` | Single file of any type | `formats` (extension list), `max_bytes` |
| `file_list` | Multiple files | `formats`, `min_count`, `max_count`, `max_bytes` per file |
| `url` | URL string with format validation | `pattern` (top-level field) |
| `color_list` | Multiple hex colors | `min_count`, `max_count` |
| `select` | Enum choice, exactly one value | `options: [{value, label}]` |
| `multiselect` | Enum choice, one or more values | `options: [{value, label}]`, `min_count`, `max_count` |
| `boolean` | True/false toggle | — |
| `structured` | Object or array, rendered as form | `schema` (JSON Schema) |
| `secret` | Encrypted credential, one-time reveal | Auto-expires 30d after submission (configurable) |

`secret` values are encrypted server-side on arrival — HTTPS in, then a libsodium sealed box under a server-held public key, before anything is written to the database — not in the client's browser, not end-to-end, not zero-knowledge; BriefGate's server holds the private key and can decrypt for the one-time reveal. See https://briefgate.dev/docs/secrets.

## Error codes

| Code | HTTP status | Meaning |
|---|---|---|
| `invalid_request` | 400 | Malformed JSON, or a request invalid given the resource's current state |
| `unauthorized` | 401 | Missing or invalid API key |
| `forbidden` | 403 | Key lacks the required scope, or an owner-only action was attempted (e.g. `secrets_owner_only`) |
| `not_found` | 404 | Resource does not exist or belongs to a different account |
| `conflict` | 409 | Duplicate identifier (idempotency key, folder/template name) — returns the existing resource |
| `gone` | 410 | A one-time value expired and was purged. Re-reading an already-revealed secret is NOT this — that's HTTP 200 with `already_revealed: true` |
| `payload_too_large` | 413 | Reserved — no endpoint returns it today. An oversized uploaded file is `422 unprocessable` (`file.too_large`) instead |
| `download_too_large` | 413 | The intake's ZIP download exceeds the size limit — fetch large items individually via `get_intake_results` instead |
| `unprocessable` | 422 | Failed validation: missing/malformed field, out-of-range value, or structurally valid but semantically invalid |
| `rate_limited` | 429 | Too many requests; honour `Retry-After` (seconds) |
| `quota_exceeded` | 402 | Plan limit reached (active intakes, storage) |
| `plan_required` | 402 | Feature not available on current plan (e.g. secrets vault on Free) |
| `internal_error` | 500 | Unexpected server error; safe to retry with backoff |
| `service_unavailable` | 503 | Database temporarily unreachable; honour `Retry-After` and retry |

All error responses include `error` (code string), `message` (human-readable), and `request_id`.

## Webhook events

Signature header: `X-BriefGate-Signature: t=<unix>,v1=<hex>`
Verify: `HMAC-SHA256(webhook_secret, "${t}.${rawBody}")`, tolerance 300s.

| Event | Key payload fields |
|---|---|
| `item.submitted` | `intake_id`, `project_name`, `item_key`, `item_label`, `item_type`, `file_count` (file/image/file_list items only) — no client email |
| `intake.completed` | `intake_id`, `project_name` |
| `client.viewed` | `intake_id`, `slug`, `project_name` — no IP, deduplicated server-side |
| `chase.bounced` | `intake_id`, `chase_id`, `provider_message_id`, `event_type` (`bounced`\|`complained`), `recipient`, `still_chasing`, `bounce_type`, `delivered_before` |
| `intake.stalled` | `intake_id`, `project_name`, `missing_items` (string[]) |
| `intake.overdue` | `intake_id`, `project_name`, `due_date`, `outstanding_items` |
| `intake.archived` | `intake_id`, `project_name` |

Return HTTP 2xx to acknowledge. Return HTTP 410 to permanently deregister the endpoint. Retry schedule: immediate, then +1m, +5m, +30m, +2h, +6h (6 attempts total).

## Rate limits

| Tier | Requests per hour |
|---|---|
| Free | 60 |
| Solo | 600 |
| Studio | 1,500 |
| Agency | 3,000 |

Rate limits are per account: every API key on the account draws from the same hourly counter, so creating more keys does not raise the limit.

Prefer webhooks over polling. A `rate_limited` 429 response includes `Retry-After` in seconds. If polling is required: Free — no more than once per 5 minutes; Solo — once per 30s; Studio — once per 15s; Agency — once per 12s.

## Chase schedules

| Schedule | Reminders |
|---|---|
| `gentle` | T+3d, T+8d, then every 14 days. No weekends. |
| `default` | T+2d, T+5d, T+9d, then weekly. |
| `aggressive` | T+1d, T+3d, T+5d, then every other day. |
| `off` | No automatic reminders. Manual `send_chase` only. |
| `custom` | Your own cadence: `chase_interval` + `chase_interval_unit` (`minutes`/`hours`/`days`, 5 minutes to 90 days, default every 3 days). Add `chase_at_time` ("07:00", whole-day intervals only) to pin it to a local time. |

Reminders are held outside 8:00–19:00 client local time (based on `client.timezone`); set `respect_quiet_hours: false` to send around the clock, and note that `chase_at_time` outranks quiet hours. An intake stops after `max_reminders` reminders (default 3, max 1000, or `"unlimited"`) and fires `intake.stalled`.

Free plan intakes may only use `default` or `off`; `gentle`, `aggressive` and `custom` require the Solo plan or higher (`402 plan_required` otherwise).

## Plans

| Plan | Price | Active intakes | Items/intake | Storage | Rate limit | Secrets | Notes |
|---|---|---|---|---|---|---|---|
| Free | $0 | 1 | 10 | 1 GB | 60/h | No | "Powered by BriefGate" shown |
| Solo | $29/mo | 15 | Unlimited | 25 GB | 600/h | Yes | Annual: $23.20/mo |
| Studio | $50/mo | 30 | Unlimited | 50 GB | 1,500/h | Yes | 1 seat, custom domains, priority support. Annual: $40/mo |
| Agency | $79/mo | 60 | Unlimited | 100 GB | 3,000/h | Yes | 3 seats, custom domain. Annual: $63.20/mo |

Promotion code: `AGENT20` gives 20% off subscription invoices for the first 3 months (on annual billing: 20% off the first annual payment). It is entered on the Stripe Checkout page; there is no API parameter for promotion codes.

Failed renewal payment: the account keeps its plan for a 14-day grace period (`billing_grace_until`). Every owner gets an e-mail with the amount, the deadline and a Stripe portal link to update the card; the dashboard shows a banner until payment succeeds, and Stripe retries the card itself. After the grace period, Free limits apply to new intakes only — existing intakes keep running, nothing is deleted. Paying restores the plan automatically.

## About the maker

BriefGate is built and operated by Radim Sekera, a backend and full-stack
developer (Czech Republic, remote). Site with other products and background:
https://sekera.dev.

## Full documentation

- Webhooks: https://briefgate.dev/docs/webhooks
- Chase engine: https://briefgate.dev/docs/chase
- Secrets vault: https://briefgate.dev/docs/secrets
- Download everything as a ZIP: https://briefgate.dev/docs/zip
- Client portal: https://briefgate.dev/docs/portal
- Custom domains: https://briefgate.dev/docs/custom-domains
- Templates: https://briefgate.dev/docs/templates
- Billing and plans: https://briefgate.dev/docs/billing
- Rate limits: https://briefgate.dev/docs/rate-limits
- GDPR and data privacy: https://briefgate.dev/docs/gdpr
- Claude Code integration guide: https://briefgate.dev/docs/claude-code-client-intake
- n8n community node guide: https://briefgate.dev/docs/n8n
- Zapier integration (beta) guide: https://briefgate.dev/docs/zapier

## Use cases (auto-generated)

- Your agent finished the build. Now it's waiting on a human.: https://briefgate.dev/use-cases/ai-agency-client-intake
- Claude Code Is Ready to Build. The Client Isn't.: https://briefgate.dev/use-cases/claude-code-client-intake
- Your Agent Needs the Client's Password. Now What?: https://briefgate.dev/use-cases/client-credentials-for-ai-agents
- The website is ready to build. The client's files are not.: https://briefgate.dev/use-cases/client-intake-for-web-agencies
- Getting Usable Files Out of a Client, Not Just Files: https://briefgate.dev/use-cases/collect-assets-for-website
- Getting the Words for the Site Out of the Client's Head: https://briefgate.dev/use-cases/collect-website-content-from-client
- Your Cursor agent finished the build. Now it's waiting on the client.: https://briefgate.dev/use-cases/cursor-client-intake

Hub: https://briefgate.dev/use-cases (Czech: https://briefgate.dev/cs/use-cases)
For AI agents (install lines for Claude Code, Cursor, Codex): https://briefgate.dev/agents (Czech: https://briefgate.dev/cs/agenti)

## Use-case guides (auto-generated)
- Guides hub (checklists & how-tos): https://briefgate.dev/guides
- A client portal with no account: https://briefgate.dev/docs/client-portal-without-account
- Async human input for coding agents: https://briefgate.dev/docs/async-human-input-for-coding-agents
- Automate client intake with Zapier: https://briefgate.dev/docs/zapier-client-intake-automation
- Best Way to Collect Files From Clients: https://briefgate.dev/docs/how-to-request-files-from-clients-tools
- Brand Design Brief Checklist: https://briefgate.dev/docs/logo-and-brand-design-brief-checklist
- BriefGate With AI Assistants: https://briefgate.dev/docs/ai-assistants
- BriefGate vs Clustdoc for developers: https://briefgate.dev/docs/clustdoc-alternative
- BriefGate vs Content Snare for developers: https://briefgate.dev/docs/content-snare-alternative
- BriefGate vs Dropbox file requests: https://briefgate.dev/docs/dropbox-file-requests-alternative
- BriefGate vs Dubsado: collecting client assets: https://briefgate.dev/docs/dubsado-alternative
- BriefGate vs FileInvite: https://briefgate.dev/docs/fileinvite-alternative
- BriefGate vs Google Forms for client files: https://briefgate.dev/docs/google-forms-alternative-for-client-files
- BriefGate vs HoneyBook: assets without a CRM: https://briefgate.dev/docs/honeybook-alternative
- BriefGate vs Jotform: https://briefgate.dev/docs/jotform-alternative
- BriefGate vs Typeform: https://briefgate.dev/docs/typeform-alternative
- BriefGate vs email + Drive/Dropbox: https://briefgate.dev/docs/email-and-drive-alternative
- Case Study: Reminders vs Slack Follow-ups: https://briefgate.dev/docs/case-study-automated-client-reminders
- ChatGPT as an MCP Client: https://briefgate.dev/docs/chatgpt-client-intake
- Client API Keys to Your Coding Agent: https://briefgate.dev/docs/client-api-keys-without-chat-history
- Client Intake Automation in n8n: https://briefgate.dev/docs/n8n-client-intake-automation
- Client Intake Form Template: https://briefgate.dev/docs/client-intake-form-template
- Client Intake for Claude Code: https://briefgate.dev/docs/claude-code-client-intake
- Client Intake for Claude Desktop: https://briefgate.dev/docs/claude-desktop-client-intake
- Client Intake for Cursor Agents: https://briefgate.dev/docs/cursor-client-intake
- Client Intake for Gemini CLI: From the Terminal: https://briefgate.dev/docs/gemini-cli-client-intake
- Client Intake for OpenAI Codex: https://briefgate.dev/docs/codex-client-intake
- Client Intake for VS Code (Copilot): https://briefgate.dev/docs/vscode-copilot-client-intake
- Client Intake for Windsurf: Assets From Cascade: https://briefgate.dev/docs/windsurf-client-intake
- Client Intake for claude.ai: Ask From a Browser: https://briefgate.dev/docs/claude-ai-client-intake
- Client Onboarding Automation: Deal to Kickoff: https://briefgate.dev/docs/client-onboarding-automation
- Client Onboarding Questionnaire for Web Design: https://briefgate.dev/docs/client-onboarding-questionnaire-web-design
- E-Commerce Website Intake Checklist: https://briefgate.dev/docs/ecommerce-website-intake-checklist
- Email Templates: Requesting Client Materials: https://briefgate.dev/docs/email-templates-requesting-materials-from-clients
- Get Website Content From Clients: https://briefgate.dev/docs/wordpress-website-content-collection-from-clients
- Get client assets into your coding agent: https://briefgate.dev/docs/how-to-get-client-assets-into-your-coding-agent
- Getting Client Logins Securely: https://briefgate.dev/docs/how-to-get-client-logins-securely
- How client credentials are stored: https://briefgate.dev/docs/client-credentials-encryption-explained
- How to Collect Client Assets with Claude Code: https://briefgate.dev/docs/client-assets-claude-code
- How to Collect Documents From Clients: https://briefgate.dev/docs/how-to-collect-documents-from-clients
- Mobile App Project Intake Checklist: https://briefgate.dev/docs/mobile-app-project-intake-checklist
- React to intake events in your code: https://briefgate.dev/docs/client-intake-webhooks-guide
- Reminders that arrive at a sensible hour: https://briefgate.dev/docs/reminder-cadence-design
- Route client files to Drive, Dropbox, Slack: https://briefgate.dev/docs/client-files-to-drive-dropbox-slack
- Sending logins to your developer safely: https://briefgate.dev/docs/how-to-send-logins-to-your-web-developer-securely
- Web Design Brief Checklist: https://briefgate.dev/docs/website-project-intake-checklist
- Web design client intake form template: https://briefgate.dev/docs/web-design-client-intake-form-template
- Website Copy From Clients: https://briefgate.dev/docs/website-copy-from-clients
- When a crawler finds a shared link: https://briefgate.dev/docs/shared-links-and-crawlers
- Why Clients Don't Send Materials: https://briefgate.dev/docs/why-clients-dont-send-materials