briefbuster.co is hosted on Cloudflare. It measures traffic with Cloudflare Web Analytics and PostHog.
| Technology | Version | First seen |
|---|---|---|
| Frontend Build Tools & CSS3 | ||
| – | 9 Nov 2026 | |
| – | 9 Nov 2026 | |
| – | 9 Nov 2026 | |
| CDN & Hosting1 | ||
| – | 9 Nov 2026 | |
| Analytics & Tag Management2 | ||
| – | 9 Nov 2026 | |
| Authentication & Identity1 | ||
| – | 9 Nov 2026 | |
| Fonts & Icon Fonts1 | ||
| – | 9 Nov 2026 | |
| Security, WAF & Bot Protection1 | ||
| – | 9 Nov 2026 | |
The crew hasn’t read this site’s colors yet. We read a palette when we capture a site’s screenshot, busiest sites first. Meanwhile, browse palettes from other sites.
Counted from every stack change we've recorded: of the sites we watched running one of this site's tools, how many went on to add another. A pattern across sites, not a forecast for this one.
route2.mx.cloudflare.netroute1.mx.cloudflare.netroute3.mx.cloudflare.netrayne.ns.cloudflare.comganz.ns.cloudflare.comv=spf1 include:_spf.mx.cloudflare.net ~allv=DMARC1; p=reject;# Shared canvases (/c/<uuid>) are deliberately NOT disallowed here. Unfurl bots # (Slackbot, WhatsApp, TelegramBot, Twitterbot, LinkedInBot) obey robots.txt, so a # Disallow would kill link previews outright. They're kept out of search engines by # `noindex` instead, which the worker injects per-request — see worker/src/meta.ts. User-agent: * Disallow: /api/ Disallow: /admin Disallow: /account Disallow: /s/ Disallow: /board/ Sitemap: https://briefbuster.co/sitemap.xml
# BRIEFBUSTER
> BRIEFBUSTER is an AI-assisted tool for busting open creative briefs: submit a brief, get back a hand of "cards" — real campaign examples, creative moves, cognitive biases, trends and more — then pin keepers to a session's canvas, generate "what if" provocations, fuse ingredients into campaign ideas, and arrange everything into a shareable board. Agents get the core creative tools through an MCP server and broader functionality through a REST API, both authenticated with the same per-user API key.
Key facts for agents:
- Base URL: https://briefbuster.co — REST under `/api/*`, MCP server at `/mcp`.
- Auth: API key, created on the Account page (https://briefbuster.co/account, sign-in required — a human
signs in with an emailed code or with Google; /api/public/signup reports the current signup posture). Send as `x-api-key: <KEY>` or `Authorization: Bearer <KEY>`. A key acts AS ITS OWNER, in the workspace it was created in — sessions and pins you create appear in that user's web UI.
- Every card carries a `gist` — a one-sentence summary; public detail lives in the card's `data`; factory example/move transcripts, scenes and private craft details stay server-side. Brand voice-of-customer verbatims are public card detail within the workspace's access scope.
- Workspaces can add SIGNATURE PACKS — their own cards (type `custom`, `data.description` markdown + `data.link_url`), private to the workspace. Pack slugs are extra `mix` keys in retrieve calls; `list_sessions` (MCP) and `GET /api/workspace/decks` return them (route paths keep the historical `decks` wire name). Signature cards ride retrieval only — search covers the factory library.
- Input that can't be used answers HTTP 422 with `"buster": true` in the body — most often a brief rejected as unusable; reword and retry.
- Rate limits answer 429 with a `Retry-After` header. Budgets are per USER (your keys share one, they don't multiply it) over three windows — minute, hour and day; the day ceiling applies to the routes that cost us money (LLM calls, ideation, uploads, canvas renders) and to library reads (search_cards / get_card, i.e. GET /api/search, /api/card/:id: 30/min, 300/hr, 1,000/day). Cards themselves are metered as well: every call that deals library cards (retrieve, search, card by id, a session bust, explore_wider) counts the cards returned against a per-user budget set by the workspace's plan (600/day and 6,000/month on Free, 2,000/day and 10,000/month on a trial, 4,000/day and 30,000/month on a paid plan) and answers 429 with scope `cards:day` / `cards:month` when it's spent. A working session never gets near it (a heavy day is under 1,000 cards). explore_wider takes at most 10 chapters per exploration; after that, bust a fresh angle. Every workspace is on a plan (https://briefbuster.co/pricing); what the plan doesn't include answers 402 `{"error":"plan_required","feature","plan","message"}`. Features: `api` (every API-key request, REST and MCP, and creating a key), `sharing` (minting a public link, sharing a session to the workspace), `sketches`, `autobust`, `brand_intelligence` (switching a pack on), `trends` (GET /api/trends and search_trends); limits: `busts` (busts per creator per UTC day: POST /api/sessions, POST /api/sessions/:id/query, create_session, add_brief), `sessions` (sessions a creator owns in the workspace, remixes included), `brands`, `signature_packs`, `favors` (the monthly pool autobust, Buster tasks and sketches draw on). Nothing over a limit is locked or deleted — only new creation is refused; unsharing and deletion always work.
## MCP server
Streamable HTTP, stateless (POST returns JSON; no session id). Connect from Claude Code:
claude mcp add --transport http briefbuster \
https://briefbuster.co/mcp \
--header "Authorization: Bearer YOUR_API_KEY"
Or in a JSON MCP client config: `{"type": "http", "url": "https://briefbuster.co/mcp", "headers": {"Authorization": "Bearer YOUR_API_KEY"}}`.
Tools:
- retrieve_cards(brief, mix?, workspace_brand_id?) — brief → one interleaved hand of cards across card types; the main inspiration tool. `mix` = cards per key, e.g. {"move": 8, "example": 20, "our-research": 5}; keys are the factory types plus the workspace's signature-pack slugs; 0 excludes one. `question` (session-only) and `custom` (use the pack's slug) are rejected, not ignored. Omit `mix` and you get the workspace's own blend, scaled to fill a whole hand; a `mix` you pass is used verbatim, not rescaled. workspace_brand_id: with an ACTIVE Brand Intelligence pack, that brand's harvested feeds (competitor angles `comp`, category conventions `norm`, customer voices `voc`) join the deal ON TOP of the factory blend, pooled under three extra mix keys — `brand` / `competition` / `voices` — and the hand grows to 60; keepers join the brand dial even without an active intelligence pack.
- search_cards(query, type?, medium?, source?, move_kind?) — semantic search with filters (factory library; signature packs surface via retrieve_cards).
- search_trends(query?, limit?) — query the live TRENDSHROOMS feed of freshly-harvested cultural phenomena (spiky, ephemeral trends, distinct from the timeless library). With query → semantic search; without → the most recently spotted. Only trends from the last ~8 weeks surface. Not on the Free plan (plan_required, feature `trends`). Each returns what/provocation/evidence (dated links)/spotted.
- get_card(id) — one card as the app shows it: gist, insight, brief, idea, the working note, media, and its type's detail rows in `data`. The private factory craft layer (transcripts, scenes and mechanism) stays server-side — it feeds what_if / fuse / add_hex directly.
- what_if(brief, card_id, session_id?, deliverable?, workspace_brand_id?) — apply a card's move to a brief → a concrete provocation. deliverable: a free-text phrase ("a radio spot") that forces the provocation to BE that artefact, not a territory around it; omit for unconstrained. workspace_brand_id: a brand whose creative DNA (hard voice rules, traits, exemplars, lexicon) seasons the output; defaults to the session's bound brand when session_id is given. Returns {what_if, brand} — brand = the name whose DNA applied, or null.
- fuse(ingredients, brief? | session_id?, deliverable?, workspace_brand_id?) — collide up to 12 ingredients (cards and/or free-text, optionally weighted) into ONE campaign idea {name, desc, brand}. deliverable + workspace_brand_id: same semantics as what_if.
- list_brands() — the workspace's brands (free objects, docs/BRANDS.md): id, name, profile (markets/vertical/website/competitors as [{name, note?}]), creative DNA (voice: constraints/traits/exemplars/lexicon/truth; creative memory: platform = the enduring campaign idea, avoid = burned ground never proposed again, works = proven learnings used as a springboard), and `pack` — the Brand Intelligence state (null = none; `market`/`activated_at` present = the brand's harvested feeds join retrieval wherever the brand is active). Brand ids feed create_session/update_session/what_if/fuse/retrieve_cards.
- list_sessions(limit?, offset?) — the workspace this key acts in + its signature packs (slug/name/description — the slugs are valid retrieve_cards mix keys) + a page of readable sessions there (limit default/max 100, offset default 0; returns total/limit/offset alongside sessions; own + teammate-shared; `mine: 0` = a teammate's, co-editable when workspace-shared).
- create_session(brief, workspace_brand_id?) — start a named session; returns the first hand of cards + its `root_id`. workspace_brand_id binds a brand — its DNA then seasons every what_if/fuse in the session.
- get_session(id) — brief, search history, pinned cards, attachments; `can_edit` says whether content writes (pins, what-ifs, brief, searches) will stick, `can_write` whether you own it (settings: title, sharing, delete).
- update_session(session_id, title?, brief?, visibility?, deliverable?, workspace_brand_id?) — edit the session. brief + deliverable + workspace_brand_id are content (any co-editor); title + visibility are creator-only. deliverable null/"" rotates vessels per idea; workspace_brand_id null unbinds the brand.
- delete_session(session_id) — permanently delete a session you own (or workspace owner/admin). Cleans up pins, searches, attachments, and the live BoardRoom.
- add_brief(session_id, brief) — run another search in a session → a fresh hand of cards.
- explore_wider(session_id, root_id?) — LLM reframes the search along a lateral angle and retrieves fresh cards excluding everything already seen. Repeatable, up to 10 chapters per exploration (then it errors in Buster's voice — add_brief a fresh angle).
- read_attachment(attachment_id, offset?) — extracted text of an attached document, paged.
- share_session(session_id, action? | visibility?, share_attachments?) — public canvas link (share/rotate/unshare) and workspace sharing (private/workspace).
- remix_session(session_id) — copy a readable session into a new one the key's owner controls.
- pin_card(session_id, card_id, what_if?, brief?) / unpin_card(session_id, card_id) — pin a card to the session's canvas (auto-placed) / remove it.
- add_note(session_id, text, color?, x?, y?, w?, h?) — pin a post-it note. Omitted x/y deals it into the next open grid slot. color is one of the marker names: ink, yellow, red, orange, green, teal, blue, purple, pink, brown (shared/palette.json).
- add_text(session_id, text, color?, x?, y?) — a headline-sized marker scribble (≤500 chars — a word or two, not a note's paragraph).
- add_sticker(session_id, shape, color?, x?, y?, s?, r?) — drop a sticker. shape is one of STICKER_SHAPES (shared/stickers.ts): airplane, angry-albatross, angry-beaver, angry-spider, arrow, arrow-2, blot, cat, cat-2, confusion, crap-cloud, cupcake, eyeglasses, fear, heart-arrow, key, middle-finger, mouth, music, oval, oval-2, poop, question-bubble, star, sticker, target, toilet-paper — an unrecognized shape is rejected, not dropped silently. s scales 0.2–4, r rotates −180 to 180 degrees.
- add_hex(session_id, links, idea?, deliverable?, x?, y?) — drop a loaded idea machine: a hex wired to up to 6 elements already on the board (pinned cards, notes, scribbles, images, sketches, links, doc chips — never stickers or other hexes), holding one campaign idea ideated from their content + the session's brief exactly as a hand-made hex would. Pass idea {name, desc} (e.g. a fuse result) to seat it instead of ideating; empty links = a brief-only hex; omit x/y and it lands beside its ingredients. The user can reroll, rewire, cut and lock it like any hex — and an agent can rewrite or lock it via edit_element (idea/locked). Returns the new id, position and idea.
- place_elements(session_id, moves) — batch-arrange up to 50 elements in one call; moves = [{id, x?, y?, s?, r?, w?, h?}]. Works on any node, including pinned cards and the brief (transform fields only for those two and existing sketches — w/h are measured, not settable). Returns each element's final transform.
- edit_element(session_id, id, text?, color?, shape?, alt?, idea?, locked?) — edit an existing element's content; which fields apply depends on its type (note: text/color, sticker: shape/color, image: alt, hex: idea {name, desc} + locked — true freezes the idea against rerolls; the padlock in the hex chrome stays the user's override). Fields that don't apply to the element's type are rejected, not ignored.
- remove_elements(session_id, ids) — delete up to 50 elements. Refuses pinned cards (use unpin_card, which also cleans up the pin) and the brief.
- get_canvas(session_id) — see the canvas as structured data: every element (brief, cards, hexes + ideas + connections, notes, scribbles, stickers, images, sketches, links, doc chips) with content, position and size, plus spatial hints (clusters, overlaps — element pairs likely stacked on each other, judged over estimated sizes; stickers exempt — near_brief, bounds). Sizes are estimates where no client has measured, so the hints flag candidates, they don't certify a clean board — render the canvas to check the look. Reads the live board when one's open (not the cached snapshot), so writes — yours or anyone's — are always current. Returns `live` alongside `version`. The primary way to plan moves.
- render_canvas(session_id, w?, h?) — a faithful PNG snapshot of the whiteboard as a human sees it, returned as an MCP image block + metadata text block. On a live board, flushes pending writes to storage first, so the render is never stale mid-edit. Cached until the session changes; a cold render takes a few seconds. Default 1024×640, clamped 320–2000.
## REST API
JSON over HTTPS. REST is a **superset** of the MCP toolset: everything MCP can do has a REST twin, plus signature-pack admin, attachment upload, link extract, the browser-session-only appearance preference (PATCH /api/account/appearance with {playfulCardAngles:boolean}; public shares/renders use the session creator's value), house style (PATCH /api/workspace/style) / card-mix (PATCH /api/workspace/mix) writes, anatomy recompute (GET|PATCH /api/sessions/:id/facets, POST /api/sessions/:id/facets/recompute), and the whole-blob canvas layout PATCH /api/sessions/:id/canvas (live boards refuse layout PATCH with 409 {live: true} — the realtime doc owns them; use the /elements routes instead). Element-level canvas writes are NOT REST-exclusive: MCP's add_note/add_text/add_sticker/add_hex/place_elements/edit_element/remove_elements share one write path with REST's POST/DELETE/GET /api/sessions/:id/elements (add_hex's REST twin is the two-step: POST /api/sessions/:id/ideate for the idea, then a type:"hex" element create seating it with links). Either way, a write on a board someone has open lands live on every connected client, shown as a 🤖 chip in the who's-here bar (never as the key owner's own presence); on a board nobody has open it applies straight to the stored canvas.
Cards:
- POST /api/retrieve {brief, mix?, workspace_brand_id?} — brief → a hand of cards. mix keys = factory types + your signature-pack slugs; 0 excludes one (`question` and `custom` are rejected — the former is session-only, the latter isn't a key). Precedence: house defaults < the workspace's saved mix < the mix you pass. The first two are scaled to fill a whole hand; the mix you pass is used verbatim. workspace_brand_id: with an active Brand Intelligence pack the brand's harvested feeds join the deal on top of the factory blend (extra mix keys `brand`/`competition`/`voices`, hand grows to 60); keepers join the brand dial even without an active intelligence pack.
- GET /api/search?q=&type=&medium=&source=&move_kind= — semantic search (factory library).
- GET /api/trends?q=&limit=&offset= — the live TRENDSHROOMS feed (last ~8 weeks; the plan must include `trends` — not Free). q → semantic search; omit q → recent, newest first, paginated via offset. Returns {mode, trends}.
- GET /api/card/:id — one card as the app shows it (see get_card above). Active workspace required.
- POST /api/apply {card_id, brief?, session_id?, collide?, deliverable?, exclude_deliverable?} — what-if generation (`collide` folds in a random wildcard card for a fresh angle). `deliverable` = a free-text phrase forcing the provocation to BE that artefact (defaults to the session's pinned vessel, or a rotated one when unpinned); `exclude_deliverable` won't repeat a given vessel. Returns {what_if, deliverable, brand} — the vessel used + the brand whose DNA seasoned it (the session's bound brand; null when none).
- POST /api/cards/:id/report {reason?, session_id?} — flag a broken factory card for admin triage. One live report per user per card; a re-report rewrites the reason.
Sessions:
- POST /api/sessions {brief, attachment_ids?, deliverable?, workspace_brand_id?} — create (auto-named); returns the first hand of cards + rootId. deliverable pins "what we're making" from the start (free text, ≤120 chars); omit to rotate a vessel per idea. workspace_brand_id binds a brand (GET /api/workspace/brands for ids) — its creative DNA then seasons every what-if/hex in the session.
- GET /api/sessions?limit=100&offset=0 — paginated readable sessions (own + workspace-shared), newest first. Returns {sessions, total, limit, offset}; limit 1–100.
- GET /api/sessions/:id — brief + queries + pinned + attachments (+ can_edit / can_write).
- POST /api/sessions/:id/query {brief, mix?} — new search → a fresh hand of cards. `mix` rebalances THIS search only (same keys as /api/retrieve, plus `question` = how many Wonder Weeds ride beside the hand; 0 excludes); omit it and the workspace's saved mix applies. The resolved mix is stored on the chapter, so re-opening the session shows the cards it dealt.
- POST /api/sessions/:id/explore-wider {root_id?, mix?} — lateral reframe → fresh chapter. Without `mix` the chapter inherits its root's blend.
- PATCH /api/sessions/:id {title?, brief?, visibility?, deliverable?, workspace_brand_id?} — visibility: private | workspace. deliverable = what the session is making (a free-text phrase; null or "" rotates a different vessel per idea). brief + deliverable + workspace_brand_id (bind a brand; null unbinds) are content writes (any member on a shared session); title/visibility are creator-only. Workspace-shared sessions are co-editable: content routes (pins, query, explore-wider, ideate, brief, facets) accept any member; settings routes stay creator-only.
- DELETE /api/sessions/:id
- POST /api/sessions/:id/pins {card_id, what_if?, brief?, deliverable?, at?} / DELETE /api/sessions/:id/pins/:cardId — pin / unpin a card on the canvas (`deliverable` = the vessel a stored what-if was made for; `at` = {x, y} canvas coordinates, omit and the card is auto-placed in the next free slot below the brief).
- PATCH /api/sessions/:id/canvas {canvas} — replace the whole saved canvas layout blob. Answers 409 {live: true} once a board has gone live (someone has it open) — the realtime doc owns the layout then; use the /elements routes instead.
- POST /api/sessions/:id/share {action: share|rotate|unshare, share_attachments?} — public canvas link at /c/<uuid>.
- POST /api/sessions/:id/remix — copy into a session you own.
- POST /api/sessions/:id/ideate {inputs: [{kind, text, weight}], deliverable?, exclude_deliverable?} — fuse brief + inputs into one campaign idea. `deliverable` / `exclude_deliverable` shape + rotate the vessel exactly as /api/apply; returns {name, desc, deliverable, brand} — the vessel used + the brand whose DNA seasoned it (null when the session has none).
- POST /api/sessions/:id/elements {elements: [...patches]} — create or update canvas elements: notes, marker text, stickers, images, links, hexes (a type:"hex" create may carry idea {name, desc}, links — up to 6 on-board element ids — and deliverable), or move/resize/rotate anything already on the board (pinned cards and the brief included, transform fields only for those two and existing sketches). Up to 50 patches per call; omit a new element's x/y and it's dealt into an open spot. Lands live for anyone with the board open; otherwise applied straight to the saved canvas. Returns each element's final position.
- DELETE /api/sessions/:id/elements {ids: [...]} — remove canvas elements, up to 50 per call. Refuses pinned cards (unpin via /api/sessions/:id/pins/:cardId) and the brief.
- GET /api/sessions/:id/elements — the canvas as structured data, same shape as MCP's get_canvas. Reads the live board when it's open.
- Brands (docs/BRANDS.md — free workspace objects). Generation reads the STRUCTURED brand: profile facts (positioning, competitors, vertical/markets) + creative DNA (hard voice rules, traits with contrast, exemplar copy, lexicon, brand truth). Raw uploaded documents are stored as sources and never injected.
- profile.vertical is a slug from the fixed industry vocabulary (unknown values are dropped): cosmetics-personal-care, baby-kids, fmcg-food, fmcg-beverage,| – |
| 9 Nov 2026 |