Integrations overview
Real apps talk to other services: a database to store data, Stripe to take payments, and the tools your business already runs on. Berrybell calls these connections integrations (or app connectors). Once connected, the AI can use them as it builds.
A few of them also reach your published app while it runs — the managed database, payments, and any key you deliberately publish into the app's build (a browser Google Maps key, for example). Everything else is a build-time connection that the AI uses on your behalf.
Where integrations live
Most connections belong to your workspace, so every project in it can use them. You reach the catalog from the Integrations page in the dashboard, or from the App connectors dialog inside the Studio.
Berrybell's own per-project services aren't connectors you add. They're features of the project, and they live in its settings under Cloud — Database, Storage, Domains, Auth, Email, Payments, Variables and Schedules — and under Analytics. File storage, for example, is part of Berrybell Cloud (see File storage).
PostHog, Plausible, Sentry, Resend, Postmark and Cloudflare R2 aren't in the catalog and can't currently be connected. A project that already has a Resend or Postmark sender still sees it under Cloud → Email.
You don't need an email provider for the email Berrybell sends itself, all of it under Cloud → Email: sign-in emails, notifications to you, and your app's emails to customers from templates you write. For newsletters or other marketing email, store your own provider's key as a secret (see Variables & secrets).
Ways to connect
Curated services
The catalog lists 14 services: Slack, Microsoft Teams, WhatsApp Business, Supabase, Notion, Google Drive & Calendar, Figma, Linear, Jira, OpenAI, Anthropic and Google Maps Platform, plus Berrybell Cloud and Stripe, which Berrybell manages for you (see below).
To find one, type in Search connectors…, or narrow the list from the sidebar: Enabled, All and Custom, each with a count; Categories — AI, Commerce, Data & storage, Design, Maps & location, Messaging and Productivity; and the vendor rows Google and Microsoft. In the Studio's App connectors dialog, and on narrow screens, the same filters appear as chips above the list. Services you've connected read Enabled and are listed first.
Pick a service to open its page, then choose Connect followed by its name. How it connects depends on the service:
- Slack, Microsoft Teams, Supabase, Google Drive & Calendar and Jira connect only by signing in to that service. Where that sign-in isn't available, the card reads Coming soon and is listed last, and the service's page says so (Connecting Slack is coming soon.) instead of offering a button.
- Notion, Figma and Linear also accept an API key: choose Use an API key instead under the sign-in button, or, where sign-in isn't available, Connect opens the key form directly.
- WhatsApp Business, OpenAI, Anthropic and Google Maps Platform connect with your own key.
A key added for a sign-in-only service is refused — entering slack as the
provider under Custom API key, for example, gets "slack" does not accept API
keys. A connection made earlier still reads Enabled, rather than Coming
soon, even if sign-in to that service is no longer available, and its page is
where you manage or remove it.
Your own API key
For a catalog service that takes keys, paste yours on its page (Use an API key
instead, where sign-in is also offered). For a service
that isn't in the catalog at all, open Custom and choose Custom API key:
name the provider, paste the key, and give Berrybell the service's API base
URL, which must be a public https:// address. Keys are encrypted at rest,
usable immediately, and there's no sign-in redirect.
Your own OAuth app
For any OAuth2 service Berrybell doesn't curate, open Custom and choose Custom OAuth2. Supply the Authorize URL and Token URL, the API base URL the AI's calls go to, your Client ID and Client secret, and the Scopes you want. Use PKCE (S256) is on by default.
A remote MCP server
Register an MCP server by URL and its tools become available to the AI. Open Custom, choose MCP server, and fill in:
- Display name — Berrybell Cloud, Berrybell Payments and GitHub are reserved and can't be used.
- Server URL — a public
https://address; a local or private address is refused. - Transport — HTTP or SSE.
- Auth — None, Bearer (a token) or Header (a header name and its value).
Then choose Add & test. Berrybell runs a real handshake, which confirms that
an MCP server answered within 8 seconds: over HTTP, with a result to its
initialize request; over SSE, with a stream that opens as text/event-stream.
If the handshake fails, the server is still saved, in an error state, and you're returned to the catalog without a message. Open Custom, where the server is marked error, and open it: its Status line gives the reason. Fix the problem and retest with Test connectivity (see Managing a connection). The AI can't use the server until a test succeeds. The reasons you may see there:
- 405 or 501 — the address isn't an MCP endpoint. A static file host answers
this way, and so does any address for a server that only runs locally over
stdio (an
npx …command), which has no URL to point at. - 404 — check the path; most servers expose
/mcpor/sse. - 401 or 403 — the server wants credentials; set Bearer or Header auth.
- A JSON-RPC error — the server rejected the handshake, and its own message is shown.
How connecting works
- Open Integrations in the dashboard, or App connectors in the Studio.
- Choose the service you want, or open Custom and choose Custom API key, MCP server or Custom OAuth2.
- Authorize it — by signing in to that service, or by providing the details it asks for.
- The connection is now available to the AI (an MCP server once its handshake succeeds), at Ask each time until you change its permissions.
After that, you can just ask in the chat: "store signups in the database" or "charge customers for the Pro plan," and the AI wires it up using the connected service.
Managing a connection
Each connection shows a status: connected, pending, expired, revoked or error. Open one and you can:
- Test connectivity (the pulse icon beside the status). What that checks
depends on the connection:
- an MCP server — Berrybell runs the handshake again and records the result;
- an API key — it only confirms that Berrybell holds a key. It doesn't prove the key is valid: a wrong key shows up as an error from the service the first time the AI uses it;
- a connection you signed in to — it confirms Berrybell holds a token, refreshing it first if it's about to expire;
- Berrybell Cloud and Stripe — it reports whether the entry is connected.
- Refresh token (the circular-arrows icon), on connections you signed in to (the OAuth ones).
- Remove it — this is the disconnect button. It also removes any key that connection had published into an app's build, and the app stops shipping it from its next publish. It doesn't revoke the key or sign-in at the service itself.
You can't change a connection's key after you connect, or which apps receive a key it publishes. To replace a key or change the apps, Remove the connection and connect again — which also puts its permissions back to Ask each time.
Turning on the managed database creates a Berrybell-managed Berrybell Cloud entry in Integrations, under Data & storage, and using Stripe payments creates a Stripe entry, under Commerce. They're there so you can set the AI's permissions on them; nothing else about them can be changed, and they can't be removed from the list.
There's one entry per project, but Integrations shows a single Berrybell Cloud card and a single Stripe card for the whole workspace, and each opens only one project's entry, without naming the project. If more than one project in the workspace has a database or payments, you can't currently reach the others' entries from Integrations.
The Berrybell Cloud entry stays for as long as the project has its database, and there's no off switch for the database in the Studio (see Your project database). Payments has no off switch either: disconnecting your Stripe accounts under Cloud → Payments stops payments, but the Stripe entry stays. In a workspace with only one such project, set the entry to Never allow to keep the AI away from it.
Controlling what the AI can do
Each integration has permissions that decide how freely the AI may use it. Open the connection and go to Manage my agent's permissions. The Enable row, named after the connection (Enable Stripe, for example), sets the policy for the whole connection:
- Always allow — the AI can use it without asking.
- Ask each time — the AI asks for your approval before each request.
- Never allow — it's off-limits; the AI can't reach the service even if it tries.
Some services break down further. Where a provider declares its individual operations, Fine-grained permissions list them under the master row. Each one follows the master row — it reads Default (Ask each time), or whichever policy the master row has — until you give it a policy of its own, and Never allow on the master row always wins. Berrybell Cloud's database splits into Read database, Add data, Modify database, Run security checks and more; Stripe into Create product, Batch create products, Create price and Check go-live status; and Google Maps into buckets chosen so you can cap what the AI is able to spend on your own Google bill.
Every new connection starts at Ask each time, including Berrybell Cloud and Stripe. Loosen it one action at a time — for example, Always allow on Read database while changes to your data keep asking.
Changing permissions needs the Editor role or above (see Team & roles).
Approval prompts
When a request needs your approval, a card appears above the message box. It reads Agent wants to use followed by the connection's name, and shows a badge naming the operation where there is one, the exact call — the method and path, or the MCP tool — and up to about 1,500 characters of the request body. It notes: Approval covers exactly this request — a different body or path will ask again. Choose:
- Deny — the call isn't made.
- Always allow — the call goes through, and the permission switches to Always allow: only for the operation named on the card, or for the whole connection when there isn't one. Waiting requests that it now covers go through too, without a card of their own.
- Allow once — just this request goes through.
One card shows at a time, oldest first, with a line such as 2 more requests waiting after this one when others are queued. Answering a card needs the Editor role or above.
How long a request waits for you depends on the connection:
- Berrybell Cloud, Stripe and MCP servers — the AI stays paused on the call for up to 30 minutes, and the wait doesn't count against the run's time limit. If nobody answers, the call isn't made: the AI finishes the work that doesn't depend on it and tells you what's waiting on your approval.
- API-key and sign-in connections — the request is held for 90 seconds. After that the AI may retry the same request, and the card stays answerable for up to 10 minutes.
Cards still open when the AI's work ends are withdrawn, since nothing would act on the answer.
Changes to production
On a project with environments, a change to production through Berrybell Cloud or Stripe asks every time, even when the permission is Always allow. Reads aren't covered by this rule; they follow their permission as usual. Never allow still blocks the call. The card's preview starts On production:, and only your answer to that card lets that call through — no earlier approval covers it. Choosing Always allow on it changes the permission, but the next change to production still asks. See Production asks first.
Your credentials stay protected
The AI never receives your token or API key. It's given a short-lived Berrybell token instead, and calls the service through a broker that:
- swaps in the real secret server-side, for the length of that one request;
- re-checks the connection's permissions and status on every request;
- pins the destination to the service's own address, so a request can't be redirected somewhere else.
Because the check happens per request, removing a connection takes effect on the AI's very next call. Your raw secrets are never shown in the chat, and none reaches your app's front-end unless you publish it on purpose, like a browser key.