The Faable MCP server connects Claude Code, Codex, Cursor and any MCP client to Faable Deploy and Faable Auth: deploy a repository and get the URL back, read why a build failed, see who signed in today and suspend an account — without pasting a single log into the chat.
claude mcp add --transport http faable https://mcp.faable.com/mcpThe first time, your client opens a browser: sign in with Faable, choose the project and allow what the agent may do. Nothing to paste. That screen lists every permission, changes included — nothing deletes.
Your agent already has the code open. With the Faable MCP server it also sees the platform: it finds the failed deployment, reads the reason and the end of the build log, tells you whether the fix is in your code or on our side — and fixes it.
It sees your users too. Ask who signed in, how many people joined this week or why someone can't log in, and it reads it from Faable Auth. Suspend an account, sign someone out of every device or resend a password email — with your go-ahead.
And it ships: “deploy this repository and give me the URL” creates the app, deploys it and waits until it is live.
npm run build fails with Module not found: Can't resolve 'sharp'. It's imported in lib/images.ts but missing from dependencies. I've added it — push and the next build will pass.ana@example.com from a single IP in ten minutes, with no success. Want me to sign that account out of every device and send a password reset?Every read and one deploy by default, for your apps and for the users who sign in to them. Reversible writes — create an app, suspend a user — only when the connection asks for them. Nothing is ever deleted: deleting stays in the CLI and the dashboard.
Your apps: deployments, logs, traffic, domains and secrets.
Find the app, see what is live, read why it broke.
whoamireadThe Faable account this server acts as, the active project and its Auth tenant, and server_version — the Faable CLI version this MCP server runs. Use it first when unsure whether the user is logged in or which project is active, or to check which version is serving.
list_projectsreadThe user's Faable projects. Apps, domains and Auth tenants live in a project; pass its id as project to the other tools.
list_appsreadThe apps of a project, with their live phase, URL and linked repository. Start here to find the app the user means.
list_blueprintsreadThe Faable catalogue: apps Faable installs and runs for you (WordPress…), each with the plans that may install it (Hobby, Pro), its database tiers and the inputs it asks for. Use it before install_blueprint.
get_appreadOne app: phase, URL, repository, deploy branch and mode, detected stack, and its newest deployment (which may have failed while an older one keeps serving). Use it to answer 'is my app up?' or 'what is deployed?'.
list_deploymentsreadRecent deployments of an app, newest first, with phase, commit and the first line of any failure reason. Use it to find the deployment behind 'my last deploy failed'.
get_deploymentreadEverything recorded about one deployment: phase, commit, detected stack, the runnable artifact, the FULL failure reason and, when it failed, fault — whether it is the user's to fix (user) or Faable's (platform). Without deployment, the newest one of the app.
get_build_logsreadThe build output of a deployment — the first thing to read when a deploy failed and the user asks why. The cause is usually at the end. Without deployment, the newest one that was not cancelled.
get_runtime_logsreadWhat the running app printed (last 24 hours, up to 200 lines). Use it when the app is up but misbehaving, or crashes after starting. A deployment retired more than a day ago has none — read its build logs instead.
get_app_trafficreadRequests the app served: status codes, busiest paths, failing paths and top_ips — the client addresses that sent the most (with the user-agent each sent most, how many distinct paths, last_seen in unix seconds). One IP hitting one path thousands of times is usually a keepalive pinger keeping the app awake: add_waf_rule with action sink and that client_ip stops it. blockable: false is a platform-internal address no rule can name. Trails reality by up to 15 minutes.
list_waf_rulesreadThe app's own WAF rules (what each matches — path pattern, user_agent, query or client_ip — and its action: deny = 403 at the edge, sink = 404 from Faable without waking the app, monitor = blocks nothing, limit = 429 over rate, allow = a path Faable blocks for every app reaches this one) and the names of the platform rulesets protecting it. enabled: false means none of them is enforced.
get_usagereadThis billing period's usage of a project: plan, apps, domains, deployments and egress.
get_quotareadToday's deploy allowance of a project and the builds held waiting for it. Use it when a deploy did not start: a held build is waiting, not failing.
list_challenge_sitesreadThe project's Faable Challenge sites (bot protection for forms): each one's id, name, domains and public site_key (what the widget embeds). The secret is never listed — it is shown once, by create_challenge_site or rotate_challenge_secret.
get_challenge_usagereadThis month's Faable Challenge usage of a project against its plan: verified (successful server-side verifications — what the quota counts) vs plan.verifications_month, and sites vs plan.sites (null = unlimited). Also challenges issued and solved, and failed verifications. Free: 1 site, 1,000 verifications/month; Hobby: 5 and 10,000; Pro: unlimited sites, 100,000.
list_domainsreadCustom domains of an app and whether their DNS is verified. Without app, every domain of the project with the app it serves: app_id: null is a domain linked to no app (its app was deleted), which answers DOMAIN_NOT_LINKED until attach_domain links it. redirect names the domain it sends every request to (the www half of a pair, or an alias); null when it serves its app.
check_domainreadDNS diagnostic of one custom domain: the CNAME it expects, what DNS answers today, and why it is not verified yet. prevalidation_cname.ready says whether the optional _acme-challenge record is in place, so the certificate is issued without waiting for the CNAME; status.tls_state is ok once the edge serves a valid certificate for the domain (status.tls_expires_at).
list_secretsreadThe environment variables set on an app. Names only — values are masked and this tool can never reveal them. Use it to check whether a variable the app needs is set.
Create an app from a repository, deploy and get the URL back — from Git or a local folder.
list_github_reposreadThe GitHub repositories Faable can deploy: those the Faable GitHub App is installed on. Use it before create_app to find the repository the user means. When the app is not installed (or the repository is missing), give the user install_url — installing it is a step in their browser.
deploy_appdeployBuild and deploy the latest commit of the app's deploy branch on Faable's servers — the same as a git push. Nothing is uploaded from this machine. With wait, returns once it is live (with the URL) or failed (with the reason and whether it is the user's code or Faable's); without it, returns the deployment id at once. Only for apps with push-to-deploy.
create_appmode=writeCreate an app from a GitHub repository in a project, link it and start its first deploy (the dashboard's Create & connect). Needs the Faable GitHub App installed on the repository; if the link fails, the new app is removed and the error says what to fix.
redeploymode=writeRebuild a failed deployment from the source it recorded. Without deployment, the newest failed one. Refused for code older than what production serves.
cancel_deploymentmode=writeStop a deployment that is still queued or building. Production keeps serving what it served. Without deployment, the one in flight.
Secrets, domains and how an app deploys.
install_blueprintmode=writeInstall an app of the Faable catalogue (WordPress…) in a project: its app, a volume for its files and a database with daily backups, with sign-in through Faable Auth (the dashboard's Install an app). Needs a Hobby or Pro project; the database is billed per month. list_blueprints says what each app asks for in inputs. The user installing it is the site's admin, by their verified email. With domain, the site lives on that domain: the result's dns is the record the user must create at their DNS provider — tell them, the site does not load there until it points at Faable.
restore_installationmode=writeBring back an app installed from the catalogue (WordPress…) that the user uninstalled, while its data is kept: 30 days, and only if its database was not deleted with it. It comes back as a new app with its files, a copy of its database, sign-in in the same Faable Auth tenant (same users) and its own domain if it had one (same DNS record). Without its own domain it gets a new faable.link address and the links in its content move there. Without installation, lists the uninstalled ones that can be restored. Needs a Hobby or Pro project.
set_secretsmode=writeAdd or update environment variables of an app. When the app is running, it restarts to apply them (only if a value changed); if its last deployment failed at runtime and nothing is running, Faable redeploys it with the new variables. Returns the names added, updated and unchanged — never the values — and redeploy: null when there was nothing to relaunch; otherwise status is started (follow deployment_id with get_deployment), needs_rebuild (the last deployment failed to build: retry failed_deployment_id with redeploy) or not_started (the platform refused the relaunch: retry it with redeploy to see why).
add_domainmode=writeAttach a custom domain to an app. Returns the CNAME record the user must create at their DNS provider; Faable verifies it and issues the certificate on its own. If the domain already serves traffic somewhere else, tell the user to create prevalidation_cname (_acme-challenge.<fqdn> CNAME) FIRST and switch the main CNAME only once check_domain shows it ready: the certificate then exists before traffic moves, with no TLS gap. If it says the domain is already in this project, use attach_domain instead: adding it again cannot work.
attach_domainmode=writeLink a custom domain of the project to an app: one left linked to no app (deleting an app leaves its domains in the project, answering DOMAIN_NOT_LINKED), or one moving from another of the project's apps. It keeps its id, its CNAME target and its certificate: nothing changes at the DNS provider. Use it instead of add_domain when add_domain says the domain is already in this project.
set_domain_redirectmode=writeMake a custom domain send every request to another domain of the same project (GET → 301, other methods → 308, path and query kept), e.g. www.example.com to example.com, or an old name to the new one. target: null stops it: the domain serves its app again. The target must be a domain of the project that serves (no chains). Deleting the target later deletes the domains that redirect to it. DNS and certificate do not change.
add_waf_rulemode=writeStop requests to an app at Faable's edge, before they reach (or wake) it. action: deny → 403 at the edge; sink → 404 answered by Faable without waking the app — use it to stop a keepalive pinger (find its IP with get_app_traffic top_ips) from keeping a free app awake, or for paths the app would 404 anyway; monitor → blocks nothing and reports what the rule would have stopped (list_waf_rules, the dashboard's Firewall tab), the safe first step; limit → requests over rate get a 429; allow → a path Faable blocks for every app (e.g. *.zip) reaches this app (path only). Select by pattern (anchored path regex), user_agent, query (a parameter name) or client_ip (address or CIDR, at most a /16 or an IPv6 /48), or a pattern AND one of them. client_ip is the connecting address, never X-Forwarded-For; when a custom domain sits behind the user's own proxy (Cloudflare's orange cloud) that address is the proxy's, and blocking it blocks part of every visitor. client_ip is not for limit or allow, nor with user_agent or query. Takes ~20 s to reach the edge. Returns the app's rules after the write.
remove_waf_rulemode=writeRemove one of the app's own WAF rules, addressed by everything that defines it: the same pattern, user_agent, query and client_ip it has in list_waf_rules (an address may be given as typed: 203.0.113.7/32 finds 203.0.113.7). action only when the same selector exists with two actions. Matching requests reach the app again within ~20 s.
create_challenge_sitemode=writeRegister a site for Faable Challenge (bot protection for the user's forms). Returns its public site_key (for the widget) and its secret (for the server-side verify), the secret only this once. Fails with plan_required when the plan's site limit is reached (Free 1, Hobby 5, Pro unlimited) — tell the user to upgrade the project.
update_challenge_sitemode=writeRename a Faable Challenge site or replace its domains. domains is the FULL new list (read it with list_challenge_sites and add or drop entries). The site key and secret do not change.
rotate_challenge_secretmode=writeIssue a new secret for a Faable Challenge site, e.g. when the old one leaked. The old secret stops working AT ONCE: until the user's server has the new one, its verifications fail. Confirm with the user first. Returns the new secret, only this once.
configure_repomode=writeChange the deploy branch, the monorepo root directory ("" clears it) or the deploy mode (push: every push; ci: once CI tags a release; workflow: the repo's own GitHub workflow). Applies to the next deploy.
link_repomode=writeLink a GitHub repository to an app that already exists, so a push deploys it (for a new app, create_app does both). What is live keeps serving until the next push — linking starts no deploy. Needs the Faable GitHub App installed on the repository; if not, the error says what to fix.
The users who sign in to your apps, and their logins.
Who logged in, how many, and why someone can't.
list_auth_tenantsreadThe Faable Auth tenants (user directories) of a project. Most projects have one and every Auth tool uses it; with several, pass the right one as tenant.
list_auth_loginsreadWho logged in to the app's Faable Auth, newest first: one row per login with the user's email, when, from which IP and with which method. Answers 'who logged in recently?' or 'did X log in today?'. For 'how many', use count_auth_users.
count_auth_usersreadHow many users of the Auth tenant match: logged in since a time ('how many users logged in today / this week'), signed up since a time ('how many sign-ups this month'), suspended, or all of them. Counts users, not logins.
list_auth_usersreadUsers of the Auth tenant. Find one by email or text, list the suspended ones, or sort: -last_login (most recent login first), last_login (longest without logging in), -logins_count (most active), -createdAt (newest sign-ups, the default). Sorting by last_login leaves out users who never logged in.
get_auth_userreadOne user of the Auth tenant by id or email: profile, verification, suspension (and why), last login and login count, the social identities they sign in with, and credentials — the email/username they actually TYPE at the database (password) login. That login identifier can differ from the profile email; when it does, a login failing with the profile email is the bug. Use it to confirm who a user is before suspending them, or to see why they can't log in (together with list_auth_logs).
diagnose_auth_loginreadGiven the exact email or username a person is trying to log in with, explain in one call whether it signs anyone in. logs_in: true → it is a real login identifier (so a failure is the password or a suspension, not the identifier). logs_in: false with profile_email_only populated → a user has that address as their PROFILE email but logs in with a different identifier (the usual trap: the address they were given is not the one on the account); login_identifiers lists what they must actually type. suggestions offers near matches when nothing matched. Use this first for 'X cannot log in'.
list_auth_logsreadThe Auth tenant's audit log, newest first: logins, failed logins (status: failed), sign-ups, password resets, admin changes (type prefix admin.user). Filter by user to answer 'why can't X log in?' — the failed attempts say why. On a failed login no user resolves, so each row also carries attempted_identifier: the email/username the person actually typed (diagnose_auth_login turns that into the account they should be using).
list_auth_sessionsreadThe devices a user is signed in on (one row per login session): IP, device, last activity and whether it is still active.
list_auth_connectionsreadHow users can log in to the Auth tenant: social providers (Google, GitHub…), passwordless (email or SMS codes) and username/password, and which are enabled.
list_auth_clientsreadThe applications (OAuth clients) of the Auth tenant: web apps, SPAs, native apps and machine-to-machine clients, with the signup bot protection each one applies (signup_protection).
list_auth_rolesreadRoles of the Auth tenant and how many API permissions each grants. A role assigned to a user gives them its permissions in tokens for APIs with RBAC on; team roles grant none. Use get_auth_role for what one role grants and who holds it.
get_auth_rolereadOne role of the Auth tenant, by id or exact name: the API permissions it grants (with their API) and the users it is assigned to.
get_auth_user_accessreadWhat a user of the Auth tenant may do: the roles assigned to them and the API permissions those roles grant, with the role behind each one. Answers 'why can (or can't) X do Y?'. A token carries the permissions the client requests that the user holds, for APIs with RBAC on.
list_auth_apisreadAPIs (resource servers) of the Auth tenant: the audience each token is issued for, its token dialect, whether RBAC is on and how many permissions its catalog has.
Suspend, sign out or re-invite a user — with your go-ahead.
suspend_auth_usermode=writeSuspend one user of the Auth tenant: they can no longer log in, and their sessions and refresh tokens stop working (access tokens already issued live until they expire). Reversible with reinstate_auth_user. Confirm with get_auth_user that it is the right person first, and say why in reason — it is recorded on the user.
reinstate_auth_usermode=writeLift the suspension of a user: they can log in again.
revoke_auth_sessionsmode=writeEnd every active session of a user (the 'sign out of all devices' button): they have to log in again on each device. Access tokens already issued live until they expire.
update_auth_client_fieldsmode=writeDeclare which custom profile fields the users of one Auth application may write on themselves (auth-js updateProfile, stored in user_metadata["faable.com/fields"]). add takes key, key:string:120 or key:enum:a,b,c; re-adding a key replaces it. inherit: true drops the app's own list and uses the tenant's again. An app's own list replaces the tenant's for that app. Only the fields: the app's URLs and settings are not changed here.
update_auth_client_loginmode=writeChoose which login methods one Auth application offers: which connections (by id or name, as list_auth_connections shows them) and whether the passkey button appears. only keeps exactly those connections and removes the rest; disable/enable change one at a time. A removed connection is refused at /authorize too, not just hidden. passkey needs the Pro plan. inherit: true drops the app's own settings and follows the tenant's again. Settings not mentioned keep their current value.
update_auth_client_signup_protectionmode=writeSet how one Auth application protects its signups and passwordless codes from bots: off relies on Actions only; on_risk asks for a proof-of-work challenge when the request looks automated (Tor, datacenter, odd user agent); always makes every signup and code to a new address solve it, and refuses client libraries older than @faable/auth-js 3.4.0 — check the app's auth-js version before choosing it. Nothing else on the app changes.
send_password_setupmode=writeSend a user the email (or code) to set or reset their password — to invite a user created by hand, or to unblock one who forgot it.
update_auth_usermode=writeChange a user's profile: email, name, email_verified. Changing email also moves their database login identifier (the email they type at the password login) so sign-in keeps working — pass profile_only: true to change only the profile email and leave the login identifier. Use this when someone cannot log in because the address they were given is not the one on their account. Confirm the person first with get_auth_user.
set_auth_user_passwordmode=writeSet a user's database password directly, to a value you choose or one this tool generates. Use it only when the person cannot receive a password-setup link at all (e.g. the email on the account does not exist) — with a link they pick their own password and it never passes through anyone else. Pass generate: true to get a strong password back once, or put the exact password in password. The password is sent to the CLI over stdin, never in the command line; it is returned only when generated.
get_auth_recovery_linkmode=writeMint a fresh password-reset link for a user and return it, so you can hand it over by another channel when the reset email will not reach them (e.g. the address on the account is not a real inbox). This ALSO sends the standard reset email. The link lets whoever holds it set the password, so treat it like a password; it works once, until used or expired. Returns link (email channel only), ticket_id and channel.
Live catalog of @faable/faable 4.48.0 — also as tools.json and llms.txt.
An agent that can deploy is an agent that can be talked into things. The server is designed around that.
list_secrets returns names only. set_secrets sends values straight to Faable and answers with which names changed — never the values.
Build output, runtime logs, commit messages and failure reasons are written by whoever deployed the code. They come back explicitly marked as untrusted content.
The hosted server has no tool that deletes apps, domains, secrets or anything else — only a local server started with --writes can delete. Its one destructive tool replaces a leaked Faable Challenge secret, and your client asks before it runs. Every call names its app and project — the server never deploys “whatever is in this folder”.
You sign in and choose the project an agent may act on; the consent screen lists everything it may do — read, deploy, change settings, manage your app's users — before you allow it. Disconnect it from your account page and it stops within a minute. The agent's own token never reaches the Faable API: the server trades it for a short-lived one, per call.
An MCP (Model Context Protocol) server that gives AI agents — Claude Code, Codex, Cursor, VS Code, Gemini CLI and any other MCP client — access to Faable Deploy. The agent can list your apps, read deployments, build and runtime logs, traffic, usage, domains and secret names, and deploy, without you leaving the editor.
Yes. Faable is in Claude's connector directory: open https://claude.ai/directory/connectors/faable, or search for Faable in Settings → Connectors in claude.ai or Claude Desktop, and click Connect. Claude opens a Faable sign-in where you choose the project and allow what it may do. Claude Code users can add the same hosted server with one command (above).
Hosted (https://mcp.faable.com/mcp) needs nothing installed: the first time, your MCP client opens a browser to sign in with your Faable account, and you choose the one project the connection may act on and what it may do. Local runs `npx -y @faable/faable mcp` over stdio on your machine and uses your `faable login` session, so it can reach every project you can.
Not through the hosted server: none of its tools deletes anything — apps, domains and secrets are deleted from the CLI or the dashboard. The local server started with --writes adds delete_app and delete_challenge_site, for agents you run on your own machine. Secret values never reach the agent: it can list the names of environment variables and set new values, but it never reads one back.
Not with deploy_app: it builds the latest commit of the app's deploy branch on Faable's servers — exactly what a git push does. Only the local server started with --writes has deploy_directory, which uploads a folder you name by its absolute path. The server never guesses an app from your working directory.
From your Faable account page, under Connected apps. A disconnected app loses access within a minute, and connecting it again asks you again.
Signed in with OAuth (claude.ai, Claude Code and most clients), you allow them on the Faable consent screen; with an API key, add ?mode=write to the hosted URL; locally, start the server with --writes. Then the agent can also create an app from a GitHub repository, set environment variables, add a custom domain, retry a failed build, cancel a build in flight and change the deploy branch, root directory or deploy mode. All of them are reversible.
Logs, commit messages and failure reasons are written by whoever deployed the code, so the server returns them explicitly marked as untrusted data, never as instructions. Combined with no deleting tools on the hosted server and writes only when you allow them, a hostile log line has very little to work with.
Create a Faable account, connect a repo, and hand the rest to the agent you already use. Hosted in the EU, free to start, no credit card required.