Emergent AI: what it builds, where your data lives, and what to check before launch

Emergent is an AI app builder: you describe an app and its agents write, test and publish it. Its docs list React or Next.js in front, Python with FastAPI or Next.js API routes behind, and a managed MongoDB Atlas database that rejects outside connections. So your data leaves through the API routes the agent wrote. Its docs describe no security scan of the generated app: checking who each route answers is your job.

The team behind Keybrum's attacksUpdated 10 min read

In short

  • Emergent's documented stack is React, Next.js, Tailwind and shadcn/ui in front, Python/FastAPI or Next.js API routes behind, MongoDB Atlas for data, and React Native with Expo for mobile. The docs add that the stack may vary.
  • Each app gets its own database, and the production cluster rejects external connections. A stranger cannot query MongoDB directly: they call your API.
  • Emergent's own help page says: without login, all data in your app is visible to anyone who finds the link.
  • The Universal LLM Key is embedded in published apps as a secret and draws from your credit balance on every model call. The docs describe no spend cap.
  • The pre-publish health check is a manual checklist. We found no automated security scan of generated apps in Emergent's help center.
On this page

What Emergent is

Emergent (emergent.sh) calls itself "an agentic vibecoding platform". You describe what you want in plain language, and in its words AI agents handle "writing code, running tests, and publishing your application". It builds web apps and mobile apps, with a database, user accounts, payments and AI features, and hosts them.

People searching Emergent AI usually want one of two answers: what does it generate, and can I put real users on it. This page takes both from Emergent's own help center, opened on 13 November 2026, and says where the documentation stops.

LayerWhat Emergent's docs listNote
Web front endReact, Next.js, Tailwind CSS, shadcn/uiRuns in the visitor's browser
MobileReact Native with Expo, built and submitted through Expo Application ServicesSame backend as the web app
Back endPython/FastAPI or Next.js API routes, REST APIs running on Emergent's serversThis is where access is decided
DatabaseMongoDB Atlas, shared cluster by default, dedicated database as a paid upgradeReached through the MONGO_URL platform key
Sign-inEmergent Auth, or Auth0, Clerk and other integrationsLogin pages hosted at auth.emergentagent.com
HostingEmergent's infrastructure (emergent.host, Cloudflare)A custom domain can be connected
AI featuresThe Universal LLM Key, one key for several model providersBilled to your Emergent credits
From the Emergent help center FAQ. It adds: the specific stack may vary based on your app's requirements.

That last sentence matters. You do not choose the stack from a menu, and two Emergent apps can differ. Before any check, look at your own project: is the backend a FastAPI app or a set of Next.js routes? The checks below work for both.

Where your data lives, and who can reach it

Emergent's FAQ says each app gets its own isolated database, encrypted at rest and in transit, and that data is processed and stored in the United States and India. Hosting in the EU only is not available on a self-serve basis. Your data is not used to train AI models, according to its data processing agreement.

Preview and production are separate. They use separate MongoDB databases. The first publish copies preview data to production, and after that Re-publish keeps the production database untouched. A second option, Replace, can swap the production database for the preview one: read the dialog before you confirm it.

The important design point is this one, from the database page: "the managed production cluster does not accept direct external connections". This differs from builders whose apps read the database straight from the browser with a public key. On Emergent a stranger cannot query MongoDB. Your data leaves through one door only, the API routes of your backend. Whether that door is locked depends on code the agent wrote.

Without login, all data in your app is visible to anyone who finds the link.
Keep it safe, Emergent help center

What Emergent's docs say about security

Credit where due. Several defaults described in the help center are good ones, and the Keep it safe page states the risks plainly.

  • Secrets. In preview they live in .env files, which the agent can see. In production they live in the Secrets tab, encrypted at rest. The .env file is excluded from GitHub pushes.
  • The agent's view. The docs say the agent sees your code and database structure. It does not see production secret values, nor database records unless you paste them.
  • Sign-in. Emergent Auth offers Google sign-in and email with password, and the FAQ also lists phone codes. The docs describe HTTP-only session cookies with the Secure and SameSite flags in production, hashed passwords, and rate limiting on the login and sign-up endpoints.
  • Files. Objects in the Emergent Object Store are private by default and served through signed URLs.
  • Breach notice. The data processing agreement commits to notifying you within 72 hours of becoming aware of a personal data breach.

Now the limits, also from the docs or from their silence.

  • No security scan is described. The automated tests the agents run are unit, integration and smoke tests: they check that features work. The pre-publish health check is a list you tick yourself. We found no page describing a scan of the generated app for missing access checks or exposed keys.
  • Route protection is promised without detail. The auth page says the agents "enforce route protection, and handle sessions". It does not say how, and it does not cover owner checks, such as only the author may edit a post.
  • No certification is named. The security page we read lists measures from the data processing agreement and says compliance information can be provided on written request. It does not name a SOC 2 or ISO report. Ask Emergent if your customers require one.
  • Secrets are visible to the team. Values are masked by default, and the docs say anyone with publish access can reveal and copy them: "Treat project access as secret access."
  • The chat is not private storage. "Anything you type in chat is sent to the AI provider." A key pasted there must be rotated.

Where an Emergent app can leak

Since the database is closed to the outside, the leaks of this stack are those of any API written quickly. None of them is specific to Emergent, and we do not claim any given Emergent app has them. They are the places to look.

WhereWhat goes wrongWhat a stranger gets
API route with no session checkThe page hides the button, the route still answersEvery record the route returns, with no account
Route with a session check and no owner checkIt looks a record up by its id and never compares the ownerAny signed-up user reads or edits other users' records
Sign-in built by hand on MongoDBThe login accepts a query object where it expects a password stringA session without the password
FastAPI's built-in docsFastAPI serves an interactive console at /docs and the schema at /openapi.json unless they are turned offThe full list of your routes and their fields
AI routeThe route calls a model with your Universal LLM Key and does not check the callerA free model, paid from your credits
Front-end codeA secret key written in a React component or a public variableThe key itself
Payment webhookThe route accepts an event without checking Stripe's signatureA paid order that nobody paid

The second row is the most common flaw we see in generated apps. It has a name, IDOR or broken access control, and it passes every functional test, because the app works for the user who is testing it.

How to check your own Emergent app

  1. 1

    List your routes

    Open the published app with the browser's Network tab and use every feature. Note each request to your backend. In the code view, open the backend folder and list the routes the agent created, including the ones no page calls.

  2. 2

    Call them signed out

    Run the commands below against your own app, with your own routes. A route that returns private data should answer 401.

  3. 3

    Use two test accounts

    Emergent's own checklist says to confirm that a test user cannot see another user's data. Create a record as account A, copy its address, and open it as account B. Try to edit it too.

  4. 4

    Search the front end for keys

    In the code view, search the front-end folder for sk_, sk-emergent-, MONGO_URL and SECRET. None of them belongs in code the browser downloads.

  5. 5

    Check the Secrets tab after publishing

    Open Preview, Manage, Secrets and confirm that production holds live values. A changed secret only takes effect after you re-publish.

bash
# On your own app only. Replace the address and the routes with yours.
APP=https://your-app.emergent.host

# 1. A private route, signed out. Expect 401.
curl -s -o /dev/null -w "%{http_code}\n" $APP/api/orders

# 2. FastAPI's console and schema. Expect 404 unless you publish them on purpose.
curl -s -o /dev/null -w "%{http_code}\n" $APP/docs
curl -s -o /dev/null -w "%{http_code}\n" $APP/openapi.json

# 3. An AI route, signed out. Expect 401.
curl -s -o /dev/null -w "%{http_code}\n" -X POST $APP/api/chat \
  -H "content-type: application/json" -d '{"message":"hello"}'
The paths are examples. If your backend is served under another prefix, use the one you saw in the Network tab.

The fixes, with a prompt for the agent

The fix for the first two rows of the table is one pattern: the route reads the user from the session, and the database query includes that user. Here it is for FastAPI with MongoDB. current_user stands for whatever function your app uses to read the session.

python
# Before: any caller gets any order
@app.get("/api/orders/{order_id}")
async def get_order(order_id: str):
    return await db.orders.find_one({"id": order_id}, {"_id": 0})

# After: signed-in callers get their own orders only
@app.get("/api/orders/{order_id}")
async def get_order(order_id: str, user=Depends(current_user)):
    order = await db.orders.find_one(
        {"id": order_id, "user_id": user["id"]}, {"_id": 0}
    )
    if not order:
        raise HTTPException(status_code=404)
    return order
The owner is part of the query, so a valid id that belongs to someone else returns 404.
text
Review every backend route. For each one, tell me whether it requires a signed-in
user and whether it limits results to records owned by that user.
Then:
1. Add the session check to every route that returns or changes private data.
2. Add the owner to every database query on user data (find, update, delete).
3. Type every login and sign-up field as a string, and reject other types.
4. Require a signed-in user and a per-user daily limit on every route that calls a model.
5. Verify the Stripe signature in the webhook route.
6. Turn off the FastAPI docs in production: docs_url=None, redoc_url=None, openapi_url=None.
Show me the list of routes with their protection when you are done.
Prompt for the Emergent agent. Re-publish, then run the checks again on the published app.

Where Keybrum fits, and where it does not

Keybrum is the automated pentest we build for web apps made with AI. It does not test Emergent's platform, its agents or its hosting. It has no attack written for Emergent in particular, and it does not test a mobile app binary: it tests the web app and the API behind it, which a mobile app also calls.

On that API it does the checks of this page at scale, for an owner who has proved ownership. It collects the routes your JavaScript calls and the operations of a public OpenAPI document, and calls them with no session. With your consent, one of its test accounts creates a marked record and the second tries to read and change it. It tries a sign-in with a query operator in place of the password, against its own test account. It reports a public Swagger console, AI routes that answer anyone, a Stripe webhook that accepts unsigned events, secret keys in the bundle and a served .env. Every finding comes with the request that worked and a fix prompt for your agent.

A one-time report costs €49 for one app. Plans start at €29 a month, excluding VAT, and attack again on every deploy. For the full list of what to verify before launch, see the vibe coding security checklist.

Questions

What is Emergent AI?

Emergent is an AI app builder at emergent.sh. You describe an app in plain language and its agents write the code, run tests and publish it. It builds web and mobile apps with a database, sign-in, payments and AI features, and hosts them on its own infrastructure.

What tech stack does Emergent use?

Its help center lists React, Next.js, Tailwind CSS and shadcn/ui for the front end, Python/FastAPI or Next.js API routes for the back end, MongoDB Atlas for the database and React Native with Expo for mobile. It adds that the stack may vary with your app's requirements.

Is Emergent AI safe?

The platform documents sound defaults: an isolated database per app that rejects outside connections, encrypted secrets, private file storage and separate preview and production environments. The app's own access rules are written by the agent and are not scanned for you, so test who each API route answers before you add real users.

Where does Emergent store my data?

According to its FAQ, data is processed and stored in the United States and India, in a MongoDB Atlas database provisioned for your project. EU-only hosting is not available on a self-serve basis. The data processing agreement says your data is not used to train AI models.

Can I export my code from Emergent?

On paid plans, Standard and above, you can push the source code to GitHub with Save to GitHub. There is no download button. Production data export is not self-serve: the docs point to the Database Manager or to support.

Does Emergent scan my app for security issues?

We found no automated security scan of generated apps in Emergent's help center as of November 2026. The agents run functional tests, and the pre-publish health check is a manual list. Emergent's Keep it safe page asks you to test login and access control yourself before sharing the app.

Sources

  1. 1.FAQs, Emergent help center
  2. 2.Keep it safe, Emergent help center
  3. 3.Database (MongoDB), Emergent help center
  4. 4.Emergent Auth (built-in), Emergent help center
  5. 5.The Universal LLM Key, Emergent help center
  6. 6.Security, breach & audit, Emergent help center
  7. 7.Pre-publish health check for web apps, Emergent help center
  8. 8.Metadata and Docs URLs, FastAPI

Your app is public. So are its mistakes.

Check what any attacker can already see in it, free, in ten seconds. The full attack, with proof and fixes: €49 once, or €29 a month on a plan.

or continue with Google or GitHub