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.
drop_project	Deploy a project by uploading it — a static site, or a Vite + React source tree that Bool builds for you in the cloud. Creates a new project (optionally in a workspace you choose, with a visibility you set), or ships a new version to an existing one (the URL stays the same).
drop_project_inline	Same as `drop_project`, but the project is sent inline in the tool call instead of uploaded to a URL. For clients that can’t make outbound HTTP requests (sandboxed connectors); otherwise `drop_project` is preferred.
get_drop_status	Check on a deploy that’s in progress and get the live URL once it’s ready.
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 (uploading your files, then polling until the deploy is live). For example:

Deploy this folder to Bool 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.

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.
A deploy fails or the site root 404s. Make sure the uploaded archive has an index.html at its root (zip the folder’s contents, not the enclosing folder). For a framework app, upload the source — Bool builds it for you; you don’t need to run the build or upload a dist/ folder yourself.
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.