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.
| Layer | What Emergent's docs list | Note |
|---|---|---|
| Web front end | React, Next.js, Tailwind CSS, shadcn/ui | Runs in the visitor's browser |
| Mobile | React Native with Expo, built and submitted through Expo Application Services | Same backend as the web app |
| Back end | Python/FastAPI or Next.js API routes, REST APIs running on Emergent's servers | This is where access is decided |
| Database | MongoDB Atlas, shared cluster by default, dedicated database as a paid upgrade | Reached through the MONGO_URL platform key |
| Sign-in | Emergent Auth, or Auth0, Clerk and other integrations | Login pages hosted at auth.emergentagent.com |
| Hosting | Emergent's infrastructure (emergent.host, Cloudflare) | A custom domain can be connected |
| AI features | The Universal LLM Key, one key for several model providers | Billed to your Emergent credits |
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.
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
.envfiles, which the agent can see. In production they live in the Secrets tab, encrypted at rest. The.envfile 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.
| Where | What goes wrong | What a stranger gets |
|---|---|---|
| API route with no session check | The page hides the button, the route still answers | Every record the route returns, with no account |
| Route with a session check and no owner check | It looks a record up by its id and never compares the owner | Any signed-up user reads or edits other users' records |
| Sign-in built by hand on MongoDB | The login accepts a query object where it expects a password string | A session without the password |
| FastAPI's built-in docs | FastAPI serves an interactive console at /docs and the schema at /openapi.json unless they are turned off | The full list of your routes and their fields |
| AI route | The route calls a model with your Universal LLM Key and does not check the caller | A free model, paid from your credits |
| Front-end code | A secret key written in a React component or a public variable | The key itself |
| Payment webhook | The route accepts an event without checking Stripe's signature | A 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
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
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
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
Search the front end for keys
In the code view, search the front-end folder for
sk_,sk-emergent-,MONGO_URLandSECRET. None of them belongs in code the browser downloads. - 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.
# 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 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.
# 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 orderReview 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.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.FAQs, Emergent help center
- 2.Keep it safe, Emergent help center
- 3.Database (MongoDB), Emergent help center
- 4.Emergent Auth (built-in), Emergent help center
- 5.The Universal LLM Key, Emergent help center
- 6.Security, breach & audit, Emergent help center
- 7.Pre-publish health check for web apps, Emergent help center
- 8.Metadata and Docs URLs, FastAPI