# pitchboom MCP server

The **pitchboom MCP server** connects AI assistants such as Claude Code, Cursor and VS Code to pitchboom.io, the AI motion-design studio for video ads: your assistant creates a project from a product URL or a brief, shows you the quote and the storyboard, and downloads the finished MP4. It is a remote server at `https://pitchboom.io/api/mcp` (Streamable HTTP): sign in with OAuth from Claude, ChatGPT and other clients that support it, or send a personal API key.

MCP access is included in the Pro and Premium plans (from €99 a month, excl. VAT); Free accounts (the 500 signup credits) and Starter subscribers use the web app. Nothing is charged until you approve a quote and your assistant calls `confirm_operation`.

Last updated: 2026-10-25. HTML version: https://pitchboom.io/docs/mcp

## What the server does

It exposes the same production line as the web app, with the same credits: website analysis, AI script and storyboard, voice-over, music and rendering, then edits, translations, other formats and 4K exports of a finished video. Your assistant drives it with tools; you approve every quote and every storyboard.

| Property | Value |
| --- | --- |
| Endpoint | `https://pitchboom.io/api/mcp` |
| Transport | Streamable HTTP, stateless (no session to keep). Methods GET, POST and DELETE. |
| Authentication | OAuth 2.1 sign-in (PKCE, dynamic client registration), or `Authorization: Bearer pb_live_…` with a personal API key created at [Settings > API & MCP](https://pitchboom.io/settings/api) ([details](https://pitchboom.io/docs/mcp#authentication)) |
| Plans with MCP | Pro (€99 a month) and Premium (€300 a month), excl. VAT |
| Server | `pitchboom` 1.1.0; tools only (no resources, no prompts) |
| Tools | 23 (5 of them for source code), listed [below](https://pitchboom.io/docs/mcp#tools) |
| Without a key | `initialize` and `tools/list` answer, every tool call needs a key ([details](https://pitchboom.io/docs/mcp#discovery)) |

## Get started

1. Subscribe to Pro or Premium at [pricing](https://pitchboom.io/pricing).
2. Add the server to your client with one of the [snippets below](https://pitchboom.io/docs/mcp#install). Claude (web, desktop, mobile), ChatGPT and Claude Code only need the URL: they open pitchboom so you sign in and pick the access. Other clients send a key from [Settings > API & MCP](https://pitchboom.io/settings/api), shown once: copy it into your client right away.
3. Ask for a video, for example: "Make a 15-second 9:16 video ad for https://example.com and show me the quote first."

## Authentication and API keys

Two ways to sign in, with the same tools, credits and permission presets. **OAuth 2.1**: clients that support it (Claude custom connectors, ChatGPT apps, Claude Code, the MCP Inspector) find the sign-in on their own, open pitchboom.io in the browser, and you approve the app and pick its access. **Personal API key**: every request carries `Authorization: Bearer pb_live_…`; keys are created and revoked at [Settings > API & MCP](https://pitchboom.io/settings/api), signed in, on the Pro or Premium plan.

| OAuth detail | Value |
| --- | --- |
| Protected resource metadata (RFC 9728) | [/.well-known/oauth-protected-resource/api/mcp](https://pitchboom.io/.well-known/oauth-protected-resource/api/mcp), also named in the `WWW-Authenticate` header of every 401 |
| Authorization server | `https://oudenjihqiegsuchjhhk.supabase.co/auth/v1` (Supabase Auth's OAuth 2.1 server; metadata at `/.well-known/oauth-authorization-server/auth/v1` on that host) |
| Flow | Authorization code with PKCE (S256); dynamic client registration (RFC 7591); refresh tokens rotate |
| Consent | [/oauth/consent](https://pitchboom.io/oauth/consent): who asks, where you go back to, the access preset; connected apps are listed and disconnected at [Settings > API & MCP](https://pitchboom.io/settings/api) |
| Access tokens | 1 hour, checked on every request (signature, issuer, expiry, the app's live session and your approval) |

| Permission preset | Scopes | What the assistant can do |
| --- | --- | --- |
| Full access | Read, Prepare & edit, Spend credits | Read, prepare and edit, and spend credits after you confirm a quote. |
| No spending | Read, Prepare & edit | Prepare quotes, edit storyboards and drafts; confirming paid work stays in the app. |
| Read only | Read | List and inspect projects, videos, jobs and credits. Nothing changes. |

- Never put a key in a URL: a request with `?api_key=`, `?key=` or `?token=` is refused (`key_in_url`). Revoke a key that leaked that way.
- pitchboom stores only an HMAC of the key and checks it on every request, so a revocation, a plan change or a blocked account applies on the next call.
- Up to 10 active keys per account: one per client or machine makes revoking easy. Up to 10 connected apps besides.
- Disconnecting an app ends its sessions at once; it needs your approval again to reconnect.
- Neither a key nor a connected app carries admin rights, even on an admin account.

## Install in your client

Any MCP client that speaks Streamable HTTP works: through OAuth if it supports it (just the URL), otherwise with a custom header. Replace `pb_live_YOUR_KEY` with your key; where a client reads environment variables, keep the key there instead of in a file you share.

### Claude Code

Terminal:

```bash
claude mcp add --transport http pitchboom https://pitchboom.io/api/mcp --header "Authorization: Bearer pb_live_YOUR_KEY"
```

Add `--scope user` to use it in every project. Then run /mcp in Claude Code to check the connection.

### Claude Desktop

Paste into a chat in Claude Desktop's Code tab: Claude runs it for you (or run it in a terminal):

```
Add the pitchboom MCP server by running:
claude mcp add --transport http --scope user pitchboom https://pitchboom.io/api/mcp --header "Authorization: Bearer pb_live_YOUR_KEY"
```

--scope user makes pitchboom available in every Code session. Start a new chat afterwards and ask it to make a video.

### Claude custom connector

Claude (web or desktop): Customize > Connectors > Add custom connector:

```
Remote MCP server URL: https://pitchboom.io/api/mcp
OAuth Client ID / Secret (advanced settings): leave empty
```

Click Connect: Claude opens pitchboom, you sign in and pick the access (Full access, No spending or Read only), then you're back in Claude. No key to copy. On a Team or Enterprise organization, each member connects their own pitchboom account. Claude accounts with request headers can send a key instead: authorization = Bearer <key>.

### Cursor

~/.cursor/mcp.json (or .cursor/mcp.json in a project):

```json
{
  "mcpServers": {
    "pitchboom": {
      "url": "https://pitchboom.io/api/mcp",
      "headers": {
        "Authorization": "Bearer pb_live_YOUR_KEY"
      }
    }
  }
}
```

In a shared repository, put the key in an environment variable instead of the file.

- [Add to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=pitchboom&config=eyJ1cmwiOiJodHRwczovL3BpdGNoYm9vbS5pby9hcGkvbWNwIiwiaGVhZGVycyI6eyJBdXRob3JpemF0aW9uIjoiQmVhcmVyIHBiX2xpdmVfWU9VUl9LRVkifX0%3D)

The button opens Cursor with the server filled in; replace `pb_live_YOUR_KEY` with your key in Cursor's MCP settings.

### VS Code

.vscode/mcp.json:

```json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "pitchboom-key",
      "description": "pitchboom API key",
      "password": true
    }
  ],
  "servers": {
    "pitchboom": {
      "type": "http",
      "url": "https://pitchboom.io/api/mcp",
      "headers": {
        "Authorization": "Bearer ${input:pitchboom-key}"
      }
    }
  }
}
```

VS Code asks for the key once and stores it securely.

- [Install in VS Code](https://insiders.vscode.dev/redirect/mcp/install?name=pitchboom&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22pitchboom-key%22%2C%22description%22%3A%22pitchboom%20API%20key%22%2C%22password%22%3Atrue%7D%5D&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fpitchboom.io%2Fapi%2Fmcp%22%2C%22headers%22%3A%7B%22Authorization%22%3A%22Bearer%20%24%7Binput%3Apitchboom-key%7D%22%7D%7D)
- [Install in VS Code Insiders](https://insiders.vscode.dev/redirect/mcp/install?name=pitchboom&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22pitchboom-key%22%2C%22description%22%3A%22pitchboom%20API%20key%22%2C%22password%22%3Atrue%7D%5D&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fpitchboom.io%2Fapi%2Fmcp%22%2C%22headers%22%3A%7B%22Authorization%22%3A%22Bearer%20%24%7Binput%3Apitchboom-key%7D%22%7D%7D&quality=insiders)

The install link adds the same entry and asks for the key once (a password prompt).

### Codex CLI

Terminal:

```bash
export PITCHBOOM_API_KEY=pb_live_YOUR_KEY
codex mcp add pitchboom --url https://pitchboom.io/api/mcp --bearer-token-env-var PITCHBOOM_API_KEY
```

bearer-token-env-var takes the variable's NAME, not the key.

### Gemini CLI

Terminal (or mcpServers in ~/.gemini/settings.json):

```bash
gemini mcp add --transport http -s user --header "Authorization: Bearer pb_live_YOUR_KEY" pitchboom https://pitchboom.io/api/mcp
```

Without -s user it goes to the project's .gemini/settings.json. The settings entry is { "httpUrl": "https://pitchboom.io/api/mcp", "headers": { "Authorization": "Bearer <key>" } }.

### Windsurf (Devin Desktop)

mcp_config.json (macOS / Linux: ~/.config/devin/mcp_config.json):

```json
{
  "mcpServers": {
    "pitchboom": {
      "serverUrl": "https://pitchboom.io/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:PITCHBOOM_API_KEY}"
      }
    }
  }
}
```

Set PITCHBOOM_API_KEY in your environment: headers read ${env:NAME} variables, so the key stays out of the file.

### Other clients

Any MCP client with Streamable HTTP:

```bash
URL: https://pitchboom.io/api/mcp
Transport: Streamable HTTP
Header: Authorization: Bearer pb_live_YOUR_KEY
```

Never put the key in a URL. Clients that only run local servers (e.g. Claude Desktop chats without the Code tab) can bridge it: npx -y mcp-remote@latest <URL> --header "Authorization: Bearer <key>". Test with the MCP Inspector: npx @modelcontextprotocol/inspector

## Credits, quotes and confirmation

**Nothing is charged without `confirm_operation`** (or `approve_storyboard` for a video already launched). The rule is the web app's.

- `create_project`, `get_estimate`, `request_variant` and paid edits through `edit_video` only return quotes: `quote_id`, credits per video and in total, balance after.
- Your assistant shows you the quote and calls `confirm_operation` only after you approve that exact amount. Both spending tools are annotated `destructiveHint` and carry `anthropic/requiresUserInteraction`, so Claude Code asks you every time.
- Quotes expire after 30 minutes; `get_estimate` makes a fresh one.
- On confirmation the quoted credits are held from your balance, not spent. Each finished step consumes its share; whatever isn't used is released when the job ends.
- If a step fails on our side, the credits it consumed are refunded automatically. `cancel_job` stops a job and you pay only the finished steps.
- Storyboards pause for your approval before the voice-over and the render. If your edits make the video longer, `approve_storyboard` refuses the old total and returns the new one to show you.
- Free (0 credits): every read tool, `analyze_url`, `update_storyboard` and the edits of `edit_video` that need nothing new.

Prices are the web app's: Standard 13, Studio 100 credits per second. See [pricing](https://pitchboom.io/pricing) for the plans and the credits they include.

With a **No spending** key, the assistant prepares quotes and edits; you confirm paid work in the web app.

## Typical flow

1. `get_credit_balance`: balance, plan and the key's permissions.
2. Optionally `get_options` (accepted values, instead of guessing ids) and `list_brand_kits`.
3. `create_project` with a URL and/or a brief: it returns a quote. Show it to the user.
4. After the user approves: `confirm_operation(quote_id)`.
5. `get_job_status` (with `wait_seconds`) until the video waits for storyboard approval.
6. `get_storyboard`, then optional free changes with `update_storyboard`, and the user's approval.
7. `approve_storyboard(max_total)` with the total the user accepted.
8. `get_job_status` until it succeeds, then `get_video`: download right away, the links are valid for 1 hour and must not be stored or shared.
9. After rendering: `edit_video` for changes, `request_variant` for translations, other formats, new takes or 4K.

## Tool reference

The 18 tools every key on a plan with MCP sees, in `tools/list` order. Access is the key scope a tool needs (Read, Prepare & edit, Spend credits); the hints are the MCP annotations clients use to decide when to ask you.

| Tool | What it does | Access | Hints |
| --- | --- | --- | --- |
| `get_credit_balance` | Credit balance (available and on hold), recent usage, plan, monthly credits, 4K policy and this key's permissions. | Read | read-only |
| `get_options` | Every accepted setting and its id: goals, platforms, formats, durations, qualities with their credits per second, resolutions, languages, voices, music moods. | Read | read-only |
| `list_brand_kits` | Your Brand Kits (colors, fonts, tone, default kit) to pass to `create_project`. | Read | read-only |
| `list_projects` | Your projects, newest first, paginated. | Read | read-only |
| `get_project` | One project: settings, website-analysis status, its videos, the latest job and any open quote. | Read | read-only |
| `analyze_url` | Reads a website (screenshots, colors, fonts, logo, copy) into a draft project. Free; counts toward your plan's daily analyses. | Prepare & edit | changes data |
| `create_project` | Step 1 of 2: creates a draft project from a website URL and/or a brief and returns a quote. Nothing is charged. | Prepare & edit | changes data |
| `get_estimate` | Reads a quote, or makes a fresh one for a draft project. Nothing is charged. | Read | read-only |
| `confirm_operation` | Step 2 of 2: holds the credits of a quote the user approved and starts the work. | Spend credits | destructive, asks you first |
| `get_job_status` | Progress of a job: steps, credits held, used and released, approval waits; can wait for a change before answering. | Read | read-only |
| `cancel_job` | Stops a job: only the finished steps are paid, the rest of the hold is released. | Prepare & edit | destructive |
| `get_storyboard` | A video's storyboard: scenes, voice-over, on-screen texts, CTA, voice, music and version. | Read | read-only |
| `update_storyboard` | Edits a storyboard that waits for approval (texts, voice-over, order, timing, scenes, CTA, voice, music, pace). Free. | Prepare & edit | changes data |
| `approve_storyboard` | Approves the storyboard: voice-over, music and render run within the total the user accepted (`max_total`). | Spend credits | destructive, asks you first |
| `list_videos` | Your videos, newest first, filtered by project or status, paginated. | Read | read-only |
| `get_video` | One video with its versions and signed download links (MP4 1080p or 4K, poster). | Read | read-only |
| `request_variant` | Step 1 of 2 for a variant of a ready video: translation, other format (recomposed, not cropped), new take or 4K export. Returns a quote. | Prepare & edit | changes data |
| `edit_video` | Edits a rendered video: free edits apply at once; edits that need a new voice-over or a re-render return a quote. | Prepare & edit | changes data |

The 5 source-code tools come right after `analyze_url` (see [Sending product source code](https://pitchboom.io/docs/mcp#source-code)):

| Tool | What it does | Access | Hints |
| --- | --- | --- | --- |
| `prepare_code_upload` | Code, step 1: after the user's consent, returns a signed upload URL and the command that packs the repository. | Prepare & edit | changes data, asks you first |
| `complete_code_upload` | Code, step 2: analyses the uploaded bundle (secrets removed, design system, screens that can be shown). | Prepare & edit | changes data |
| `import_code_from_github` | Code: reads a public GitHub repository (private ones through the pitchboom GitHub App), with the same consent. | Prepare & edit | changes data, asks you first |
| `get_code_source` | Code: analysis status, stack, brand, screens that can be shown, privacy report and deletion date. Never returns code. | Read | read-only |
| `delete_code_source` | Code: deletes the uploaded code and everything derived from it now (Brand Kits and rendered videos stay). | Prepare & edit | destructive |

The full descriptions and input schemas are what `tools/list` returns, also published in the [server card](https://pitchboom.io/.well-known/mcp/server-card.json). Without a key, `tools/list` and the server card show the 18 core tools; the 5 source-code tools appear once a key is sent.

## Sending product source code (Claude Code)

From Claude Code, or any agent that can run shell commands in your repository, you can send your product's source code so videos rebuild your real interface. **Your assistant must ask you first: your code leaves your machine.** The tools return the consent text to show you.

1. `prepare_code_upload` with `consent_accepted=true` once you agree: it returns a `code_source_id`, a signed upload URL and a `pack_command`.
2. Run the `pack_command` in the repository (tracked files only, secrets and build folders excluded), then the `upload_command` (PUT).
3. `complete_code_upload`, then `get_code_source` until the analysis is ready.
4. `create_project` with `code_source_id` (and optionally the `screens` to show).

- Public GitHub repositories can be read with `import_code_from_github` instead (private ones through the pitchboom GitHub App), with the same consent.
- `get_code_source` never returns code; it shows the privacy report and the deletion date. `delete_code_source` deletes the code and everything derived from it at once (Brand Kits and rendered videos stay).
- Screens rebuilt from your code are priced per second on top of the quality: with your code: Standard +10, Studio +20 credits per second.
- Details: [privacy policy](https://pitchboom.io/legal/privacy).

## Errors

Errors before any tool runs are HTTP errors with a JSON body `{ "error": { "code", "message", "docs" } }`. A 401 also carries `WWW-Authenticate: Bearer realm="pitchboom"`; a 429 or 503 carries `Retry-After`.

| Status | Code | Meaning |
| --- | --- | --- |
| 401 | `missing_api_key` | No `Authorization: Bearer` header on a request that needs one (every tool call): sign in with OAuth or send a key. |
| 401 | `malformed_api_key` | The value isn't a pitchboom key (`pb_live_` followed by 32 letters and digits). |
| 401 | `invalid_api_key` | Unknown or revoked key: create a new one. |
| 401 | `token_expired` | The OAuth access token expired: the client refreshes it (or signs in again). |
| 401 | `invalid_token` | The OAuth token is invalid, its session ended or the app was disconnected: sign in again from the client. |
| 401 | `key_in_url` | A key was sent in the URL: send it in the header and revoke the exposed key. |
| 429 | `rate_limited` | Too many requests: wait for `Retry-After` seconds. |
| 503 | `auth_unavailable` | The key couldn't be checked right now: retry after a few seconds. It is not a revocation. |
| 503 | `rate_limit_unavailable` | The request counters are unreachable: retry after a few seconds. |

A tool that can't do what was asked returns a tool result with `isError: true` and one line that starts with `ERROR <code>:` and says how to fix it, for example:

Tool error:

```
ERROR quote_expired: This quote expired (30 minutes). Get a fresh one with get_estimate and confirm it again with the user.
```

| Code | What to do |
| --- | --- |
| `plan_required` | The account's plan doesn't include this (MCP needs Pro or Premium; 4K and long durations depend on the plan). |
| `insufficient_scope` | The key's or app's preset doesn't allow this tool: create a key with more access, or disconnect the app and connect it again with more. |
| `insufficient_credits` | Not enough credits for the quote: top up, or pick fewer or shorter videos. Nothing was charged. |
| `quote_expired` | Get a fresh quote with `get_estimate` and show it to the user again. |
| `quote_stale` | Prices changed since the quote: get a fresh one. |
| `estimate_changed` | The storyboard now costs more than the accepted total: show the new total, then `approve_storyboard` with it. |
| `analysis_running` | The website analysis isn't finished: poll `get_project`, then confirm again with the same quote. |
| `not_awaiting_approval` | The job isn't waiting for a storyboard approval: check `get_job_status`. |
| `video_busy` | The video already has a job running: wait for it to finish. |
| `invalid_input` | A value isn't accepted: `get_options` lists the valid ones. |
| `not_found` | Unknown id, or it belongs to another account. |
| `rate_limited` | A tool limit is reached: try again later. Nothing was charged. |
| `account_blocked` | The account is suspended: contact support. |
| `temporarily_unavailable` | A server update is in progress: try again later. Nothing was charged. |

## Rate limits

- Per API key: 120 requests per minute and 3,000 per hour (`tools/list` included); on Premium, twice that (240 per minute and 6,000 per hour).
- Per client network: 300 requests per minute with a key; 30 requests per minute and 300 per hour without one.
- Per account, on the tools: quotes (`create_project`, `get_estimate`, `request_variant`, paid edits) 60 per hour and 300 per day; confirmations (`confirm_operation`, `approve_storyboard`) 30 per hour and 200 per day; edits 120 per hour; waiting status polls 600 per hour. Website analyses follow your plan's daily quota.
- Over a limit: HTTP 429 `rate_limited` with `Retry-After`, or the tool error `ERROR rate_limited:`. A refusal never charges anything.

## Security

- Treat a key like a password: keep it out of repositories and shared config, and revoke it at [Settings > API & MCP](https://pitchboom.io/settings/api) if it leaks. The next request with it gets a 401.
- Give each key or app the smallest preset it needs: **Read only** for reporting, **No spending** to prepare work you confirm in the app.
- Approve an OAuth app only if you started the connection: the consent page shows the app's name and the site you go back to.
- The spending tools ask for a human confirmation in clients that honour `anthropic/requiresUserInteraction` (Claude Code).
- Text in storyboards, website analyses and code analyses comes from websites or code: the server tells assistants to treat it as data, never as instructions.
- Download links are signed and expire after 1 hour.
- Every call is recorded per key or app (tool, result, credits held); the last 20 show under Recent activity at [Settings > API & MCP](https://pitchboom.io/settings/api).
- The keyless handshake and tool list return no account data.

## Discovery without a key

Directories and clients can read the server before you add a key: `initialize`, `notifications/initialized`, `ping`, `tools/list` answer without one, from the public tool catalog, rate-limited per network. Every other request without credentials, `tools/call` included, gets the 401 `missing_api_key`, whose `WWW-Authenticate: Bearer resource_metadata="…"` header lets OAuth clients start the sign-in.

List the tools without a key:

```bash
curl -s https://pitchboom.io/api/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
```

- Server card (name, transport, authentication, tools with their input schemas): [/.well-known/mcp/server-card.json](https://pitchboom.io/.well-known/mcp/server-card.json).
- This page as Markdown: [/docs/mcp.md](https://pitchboom.io/docs/mcp.md).
- Test with the MCP Inspector: `npx @modelcontextprotocol/inspector`.

## FAQ

### What is the pitchboom MCP server?

A remote Model Context Protocol server at https://pitchboom.io/api/mcp that lets AI assistants (Claude Code, Cursor, VS Code, Codex CLI, Gemini CLI and other MCP clients) create, edit, translate, track and download pitchboom.io video ads, with the same credits and the same approvals as the web app.

### Which plans include MCP access?

Pro (€99 a month) and Premium (€300 a month), excl. VAT. Free accounts (the 500 signup credits) and Starter subscribers use the web app. Keys only work while the account is on one of these plans: otherwise every tool except get_credit_balance answers plan_required.

### Can an AI assistant spend my credits without asking me?

No. Only confirm_operation and approve_storyboard spend credits, and only for a quote or a total you approved; every other tool is free or returns a quote. Claude Code asks you before each of those two calls. A key with the No spending preset can't call them at all. Quotes expire after 30 minutes.

### Does it work in claude.ai or ChatGPT?

Yes. Add https://pitchboom.io/api/mcp as a custom connector in Claude (web, desktop or mobile) or as an app in ChatGPT's developer mode: they sign you in with OAuth, you approve the app on pitchboom and pick its access. Claude Code, Cursor, VS Code and other clients work with OAuth too, or with an API key in the Authorization header.

### What happens if a video fails?

Credits are held when you confirm and each finished step consumes its share. If a step fails on our side, what it consumed is refunded automatically and the rest of the hold is released. Cancelling a job pays only the finished steps.

### How do I revoke an API key?

At https://pitchboom.io/settings/api, where connected OAuth apps are disconnected too. pitchboom checks the key or token on every request, so the next call gets a 401. You can hold up to 10 active keys.

### Is the tool list public?

Yes. initialize and tools/list answer without a key so directories and clients can show what the server does; they return no account data. Every tool call needs a key. The same list is in https://pitchboom.io/.well-known/mcp/server-card.json. Without a key it shows the 18 core tools; the 5 source-code tools appear once a key is sent.

### Does pitchboom see my source code?

Only if you send it, with prepare_code_upload or import_code_from_github, after your assistant asks you. Secrets and build folders are excluded when packing, the analysis never returns code, and delete_code_source deletes it and everything derived from it at once.

## Related

- [Pricing and plans](https://pitchboom.io/pricing)
- [Create an API key](https://pitchboom.io/settings/api)
- [How pitchboom works](https://pitchboom.io/how-it-works)
- [This page as Markdown](https://pitchboom.io/docs/mcp.md)
- [Server card (JSON)](https://pitchboom.io/.well-known/mcp/server-card.json)
- [Privacy policy](https://pitchboom.io/legal/privacy)