> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mythos.new/llms.txt
> Use this file to discover all available pages before exploring further.

# Integrations overview

> Mythos builds the frontend; you bring your own backend. Connect your own Supabase for data, auth, and storage; each project is a private Git repo.

Mythos builds the **frontend** — the React (Vite) or Next.js app, its components, and its UI. Anything
behind the UI — a database, user accounts, file storage, server secrets — comes from a backend **you
bring**. Today that backend is your own [Supabase](/integrations/supabase) project. Mythos keeps each
project in a [private Git repo](/integrations/github) and builds it commit by commit; connect your
GitHub account to **export to your own GitHub** anytime.

The mental model: Mythos owns the app shell and the AI edits; **you** own your data, your users, and
your code.

<Note>**Cost:** building a new project costs **3 credits**; an edit costs **2**. New accounts start
with **5 free credits**. Connecting a backend or a repo does not cost credits on its own. See
[Credits & pricing](/introduction/credits-and-usage).</Note>

## Why it works this way

* **Your data stays yours.** Mythos never runs your database or holds your users' auth tokens. If you
  stop using Mythos, your Supabase project and its data are untouched in your own account.
* **Real code, not a locked template.** The app the agent writes is a conventional React/Next.js
  project committed to Git — you can read it, edit it, and (after a one-time GitHub connect) export it
  to your own GitHub.
* **No backend lock-in.** Mythos captures no backend revenue and proxies no app traffic, so there is
  nothing to migrate off later.

## Two distinctions worth getting right

### Your Supabase vs ours

Mythos itself runs on Supabase for its own accounts and billing — but that is **Mythos's** Supabase,
and you never touch it. When this documentation says "connect Supabase," it means **your own**
Supabase project, which holds **your app's** database, users, and files.

|                      | Mythos's Supabase                 | Your Supabase                        |
| -------------------- | --------------------------------- | ------------------------------------ |
| Holds                | Mythos accounts, credits, billing | Your app's data, users, files        |
| You manage it        | No                                | Yes — it is in your Supabase account |
| Where you connect it | n/a                               | Workspace → Services → Cloud         |

### A Mythos-built site vs the workspace IDE

* A **Mythos-built site** is the app the agent generates — what your visitors see, and what you
  [publish](/publishing/publish) to a live URL.
* The **workspace IDE** is the editor inside Mythos where you chat with the agent, browse the file
  tree, and edit code by hand.

Editing in the IDE changes your project's code; publishing pushes a built copy of that code live.

## What you connect

<CardGroup cols={2}>
  <Card title="Supabase" icon="database" href="/integrations/supabase">
    Connect your own Supabase for a database, auth, and storage. Paste credentials or connect with OAuth.
  </Card>

  <Card title="GitHub" icon="github" href="/integrations/github">
    Each project is a private Git repo you can review and roll back — export it to your own GitHub.
  </Card>
</CardGroup>

Once Supabase is connected, you wire data in plain language — for example:

```prompt theme={null}
Connect Supabase, then add a contact form that saves to a leads table.
```

## What Mythos does not do

* It does **not** host a database for you. There is no "Mythos Cloud" backend — that was retired.
* It does **not** see your Supabase **service role key**. The agent is given only your project URL and
  the public anon key.
* It does **not** proxy your app's database traffic. Your app talks to your Supabase directly.
* It does **not** migrate your data between providers — switching backends means pointing at a new
  project.

## FAQ

<AccordionGroup>
  <Accordion title="Do I need a backend to use Mythos?">
    No. Mythos is frontend-first — landing pages, marketing sites, portfolios, and dashboards work
    with no backend at all. You only connect Supabase when you need data saved, user accounts, or file
    storage.
  </Accordion>

  <Accordion title="Which backends can I connect?">
    Supabase is the supported, fully wired backend. A few other provider names exist as reserved
    values in the database, but no connect flow writes them today — Supabase is the path that works.
  </Accordion>

  <Accordion title="Where does my app's code live?">
    Mythos keeps each project in a private Git repository it manages, one per project, and every build
    and edit is a commit. Connect your GitHub account to export a copy that is yours. See
    [GitHub](/integrations/github).
  </Accordion>

  <Accordion title="Is my Supabase the same as the one Mythos runs on?">
    No. Mythos runs on its own Supabase for accounts and billing; you never touch it. The Supabase you
    connect is your own project, holding your app's data.
  </Accordion>
</AccordionGroup>

## Related

* [Connect Supabase](/integrations/supabase) — the end-to-end connect flow and what the agent can see.
* [GitHub repos](/integrations/github) — how your code is stored and versioned.
* [Welcome to Mythos](/introduction/welcome) — the product overview.
* [Publishing your site](/publishing/publish) — take a built project live (the published build needs the committed `.env`).