PRACTICAL FIELD GUIDE
Signup returns 409 email_taken: what it means and how to handle it
An email_taken response (HTTP 409, "Email already registered") means the signup address already exists in that project's user store. The app should handle that outcome deliberately rather than retrying account creation in a loop.
MCPBackend editorial team · · Examples are illustrative
The short answer
MCPBackend returns HTTP 409 with the code email_taken from POST /v1/{projectId}/auth/signup when that email address already has an account in this project. Nothing is created and no token is returned. The body is { "error": { "message": "Email already registered", "code": "email_taken" } }.
Treat it as an expected outcome, not a crash: tell the person an account already exists and offer the log-in form. Do not retry the signup, because it will keep returning 409.
Why you see email_taken
- The person already signed up. The most common case, often weeks earlier and forgotten.
- A double submit. Two clicks send two signups: the first returns 201 with a token, the second returns 409. The account exists and the first response holds a valid session.
- A retry after a timeout. The first request succeeded but its response was lost, so the retry hits the duplicate.
- Different capitalisation. Emails are lower-cased before they are stored, so Alice@Example.com and alice@example.com are the same account.
- Reused test data. A seed script or test that signs up the same address twice in the same project.
- Not a cause: the same email in another project. Users belong to one project, so staging and production accounts with one address are separate and do not trigger email_taken.
Handle it in your signup form
let submitting = false;
async function signup(email, password) {
if (submitting) return; // block double submits
submitting = true;
try {
const res = await fetch(`${base}/v1/${projectId}/auth/signup`, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ email, password }),
});
const body = await res.json();
if (res.status === 201) return saveSession(body.token, body.user);
switch (body.error?.code) {
case "email_taken": return showError("An account with this email already exists.", { link: "/login" });
case "bad_request": return showError(body.error.message); // invalid email, or password under 8 characters
case "auth_disabled": return showError("Sign-up is not enabled for this app yet.");
default: return showError("Sign-up failed. Please try again.");
}
} finally {
submitting = false;
}
}Does email_taken leak which emails are registered?
It can. Login deliberately returns the same invalid_credentials error for a wrong email and a wrong password, but signup has to refuse a duplicate, so a 409 confirms the address has an account. For most apps that is acceptable and the clearer message helps users. If it matters for yours, word the on-screen message neutrally (for example "Couldn't create an account with this email. Try logging in.") and rate-limit the form. The API response itself stays 409.
Put it into practice
- Inspect the status and documented JSON code returned by signup.
- Offer the supported login route when appropriate and preserve a useful error state.
- Verify the behavior with a designated duplicate test address.
What this looks like
ILLUSTRATIVE EXAMPLE
A double-click submits signup twice; the first request creates the user and the second reports a duplicate address.
A boundary to keep clear
Do not invent an automatic account-recovery flow that the current platform does not provide. Plan recovery requirements separately.
Read next
MCPBackend context
Application email/password authentication is separate from the developer dashboard login and MCP OAuth connection. The current app-user tokens are project-scoped and do not automatically expire. Do not assume built-in refresh, password reset, per-token revocation or social login; check supported behavior before designing those flows.
Take the next step
Inspect the current project contract, try the change with disposable data, and verify the result through the same credentials your app will use. Record the expected response and one denied-access case before release.
Frequently asked questions
What does email_taken mean?
The signup email already has an account in this MCPBackend project. The API returns HTTP 409 with code email_taken and message Email already registered, and creates nothing.
Why do I get email_taken on a brand-new signup?
Usually the form submitted twice, or a retry ran after the first request had already succeeded. Disable the button while the request is in flight and check whether the first response returned 201.
Is email_taken case-sensitive?
No. Emails are lower-cased before they are stored and looked up, so different capitalisations of one address are the same account.
Can the user reset their password instead?
There is no built-in password reset flow today. Send them to log in, and check what the product supports before promising a reset link in your app.
Sources and further reading
These references explain the underlying protocols and design principles. For supported MCPBackend operations and exact request shapes, inspect your project’s generated API contract.