Connect your AI to Bool

Bool runs a remote MCP server — one endpoint that any Model Context Protocol client can connect to. Once it’s connected, your AI can create Bool projects, deploy websites, and check on what’s live, all on your behalf.

You only need two things:

Server URL: https://bool.com/api/mcp
Transport: Streamable HTTP (remote)

That’s it. How you add those depends on your client — pick yours below.

The fast way: just ask

Most modern AI clients can add an MCP server themselves. Before hunting through settings, try simply telling your AI:

Add the Bool MCP server at https://bool.com/api/mcp as a connector.

If your client supports it, it’ll walk you through connecting and then sign you in (see Signing in below). If that doesn’t work, use the per-client steps below.

Signing in

Bool needs to know it’s really you. There are two ways to authenticate, and you usually don’t have to think about it — the client picks one for you:

Sign in with Bool (recommended). Clients that support connectors (Claude, ChatGPT) pop open a Bool login the first time you use the server. Log in, approve access, and you’re done — no keys to copy.
Personal access token. Clients that connect by config file (Cursor, VS Code, and most others) authenticate with a token. Create one at Settings → API tokens, click New token, and copy the value (it starts with bool_live_). Treat it like a password — anyone with it has your access to that workspace. Each token is scoped to a single workspace.

By default the AI can see projects across all the workspaces you belong to (personal and shared), and it respects the same permissions you have. Ask it to target a specific workspace — or use list_workspaces to see them and pass a workspace_id — to narrow things down. A token is the exception: it’s bound to a single workspace and only ever acts there.

Connect your client

Claude (desktop or web)

Open Settings → Connectors and click Add custom connector.
Paste the server URL: https://bool.com/api/mcp.
Save, then click Connect — a Bool login opens. Sign in and approve.

Bool’s tools now show up in the chat’s tools menu.

ChatGPT

In a workspace that allows custom connectors, go to Settings → Connectors → Add.
Paste https://bool.com/api/mcp and choose OAuth for authentication.
Connect, sign in to Bool, and approve access.

Cursor

Add Bool to your MCP config (Settings → Tools & MCP, or edit ~/.cursor/mcp.json directly):


{
  "mcpServers": {
    "bool": {
      "url": "https://bool.com/api/mcp",
      "headers": {
        "Authorization": "Bearer bool_live_your_token_here"
      }
    }
  }
}

Replace bool_live_your_token_here with a token from Settings → API tokens.

VS Code (Copilot agent mode)

Add a server to .vscode/mcp.json in your workspace (or your global mcp.json):


{
  "servers": {
    "bool": {
      "type": "http",
      "url": "https://bool.com/api/mcp",
      "headers": {
        "Authorization": "Bearer bool_live_your_token_here"
      }
    }
  }
}

Any other MCP client

The pattern is the same everywhere — point the client at the remote server and give it your token:

URL: https://bool.com/api/mcp
Transport: Streamable HTTP (sometimes labeled “HTTP” or “remote”)
Auth: an Authorization: Bearer bool_live_… header, or the client’s OAuth flow if it has one

What your AI can do

Once connected, these tools are available.

Projects and deploying

Tool	What it does
list_workspaces	List the workspaces you can act in (personal and shared), so you can target one by id.
list_projects	List your projects with their live URLs and visibility — across all your workspaces, or just one if you name it.

| create_project | Create a new Bool project and start a headless AI turn to build it from a prompt. Returns immediately; poll get_project_status for the live URL. | | prompt_project | Send a prompt to an existing project’s AI and run a headless turn in the background. It can auto-publish the result. | | publish_project | Build and publish a project (or a specific snapshot) to its public URL. | | get_project_status | Poll a project’s active AI turn and see its live URL / deployment state. | | update_project | Rename a project, change its description, or change its visibility. Owner-only. | | move_project | Move an existing project to a different workspace. Owner-only. | | fork_project | Fork (remix) an existing project into your workspace, optionally copying its data. | | delete_project | Permanently delete a project, including its database, files, deployments, screenshots, and attachments. Owner-only. | | list_templates | List the starter templates you can pass to create_project. | | get_project | Look up a project’s live URL and version history — and change its visibility. |

Your data model

Tool	What it does
list_entities	List a project’s entities (data models) with each one’s access mode and fields.
define_entity	Create a data model, or add fields to one. Safe and additive — it creates the table and adds missing columns, and never drops a column or changes a type, so re-declaring can’t lose data. Bool fills in `id`, `created_at`, and (on private entities) `owner_id` for you.

Your app’s records

These read and write your app’s real data as the project admin, so they see and change every row — including every end-user’s rows on a private entity.

Tool	What it does
list_records	Read rows from an entity, with filters, a sort, and paging (up to 500 per call).
create_records	Insert up to 50 rows. On a private entity you must say which end-user owns each row (`owner_id`), because an admin write has no signed-in user.
update_record	Patch one row by id, leaving its other fields untouched.
delete_record	Delete one row by id. Permanent — there’s no undo.

Developing locally

Tool	What it does
get_project_connection	The connection details a local app needs to use a Bool project as its backend. Ask it to include the app’s data key (owner-only) and it returns that too — see Develop locally (CLI).

You don’t call any of these directly — you just describe what you want, and your AI runs the steps (creating a project from a prompt, then polling until the deploy is live). For example:

Create a Bool project for this idea and give me the live URL.

List my Bool projects and tell me which ones are live.

Add a due_date to my tasks model, then show me every overdue task.

The record and entity tools act with full admin access to a project’s data. Deletes are permanent, and a connected AI can read every end-user’s rows. Only connect clients you trust, and prefer a workspace-scoped access token so the connection can only ever touch that workspace.

Agent workflow examples

With the lifecycle tools, an agent can build and ship apps without touching the Bool UI.

Build a new website from a prompt

Create a landing page for a SaaS called “Streamline” with a hero, features grid, pricing, and a sign-up CTA. Make it public and give me the live URL.

The AI calls create_project with the prompt, then polls get_project_status until active_turn is false and live_url is set.

Iterate on an existing project

Add a testimonials section to my landing-page project and keep the same live URL.

The AI calls prompt_project on the existing project; it runs a headless turn, publishes the result, and the URL stays the same.

Duplicate and customize a project

Fork my “streamline-landing” project into a Spanish version and update the copy to say “Agiliza”.

The AI calls fork_project, then prompt_project to edit the copy.

Clean up experiments

Delete every non-live project whose name starts with “draft-”.

The AI calls list_projects, filters by deployed: false, then calls delete_project for each match.

The data-model and record tools need a project on Bool’s current app runtime. Older projects don’t expose them — if your AI reports that a project has no entities, rebuild it as a new project.

Controlling who can see your app

Every project has a visibility setting that controls who can view the deployed app:

link — anyone with the URL, no login (fully public).
workspace — only members of the project’s workspace.
restricted — only you, plus anyone you explicitly share it with.

New projects use the workspace default (public for a personal workspace, members-only for a shared one). You can set a different visibility when you deploy — just ask, e.g.:

Deploy this and keep it private to just me.

To change an existing project’s visibility, ask your AI to update it (it uses get_project under the hood):

Make my landing-page project public.

A few rules apply: workspace visibility needs a shared/team workspace, making an app restricted or workspace may require a paid plan, and only the project’s owner can change its visibility. If a change isn’t allowed, the tool returns a clear message explaining why.

Troubleshooting

“Unauthorized” or a login loop. Your token is wrong, expired, or revoked. Create a fresh one at Settings → API tokens and update your config. For OAuth clients, disconnect and reconnect the server.
“Rate limit exceeded.” The server limits requests per minute per token. Wait the few seconds it suggests and retry; higher plans get higher limits.
Tools don’t appear. Confirm the URL is exactly https://bool.com/api/mcp and that your client is set to a remote / HTTP server, not a local command.