# Gemmein

> Gemmein hosts and runs web and mobile apps: hosting, sign-in, protected data, payments, AI tools and credits.

## Instructions for coding agents

- If you are helping someone build a new app, or connect an app they
  already built, read https://docs.gemmein.com/llms.txt first. The full
  guide is https://docs.gemmein.com/llms-full.txt.
- Before installing anything or creating any account, map the app's
  requirements against what Gemmein supports and give a verdict: FITS,
  FITS EXCEPT or DOESN'T FIT.
- Building is local and free: `npx -y gemmein dev` needs no signup and no
  setup. For `npx gemmein sync`, the owner signs in free at app.gemmein.com
  (no card) and approves `npx gemmein login` in the browser; each Live
  action asks for its own approval. A card is needed only when the app
  goes live.
- In ChatGPT (every plan, Free included) or Claude (claude.ai or the
  desktop app), the person adds the hosted connector once
  (https://api.gemmein.com/mcp). After that the AI uses Gemmein on its
  own; the person never has to name it.

## Docs

- [Short index for coding agents](https://docs.gemmein.com/llms.txt): the fit questions, the verdict and the build order
- [Full guide](https://docs.gemmein.com/llms-full.txt): every rule, error code and method
- [Quickstart](https://docs.gemmein.com/quickstart)
- [Auth and sessions](https://docs.gemmein.com/auth)
- [Data and safety rules](https://docs.gemmein.com/data)
- [Payments](https://docs.gemmein.com/payments)
- [Credits](https://docs.gemmein.com/credits)
- [AI tools and runs](https://docs.gemmein.com/ai)
- [Relays](https://docs.gemmein.com/relays): send an app's events to actions, such as another payment provider
- [Mobile (Expo and Swift)](https://docs.gemmein.com/mobile)
- [MCP server](https://docs.gemmein.com/mcp)
- [Dashboard guides, one per page](https://docs.gemmein.com/console)
- [Security](https://gemmein.com/security)
- [Support](https://gemmein.com/support)
- [Pricing](https://gemmein.com/product#pricing)
- The package guide (what code calls) ships in the npm package: run
  `npm i @gemmein/sdk`, then read `llms.txt` and `REFERENCE.md` in the
  package root. `reaffirm.mjs` there is a self-test you can run in CI.
- [Dashboard steps](https://docs.gemmein.com/llms-dashboard.txt): how to do
  each task in the dashboard; on this site only, because it changes with
  the dashboard. The full guide is the package guide followed by these.
- Human documentation: https://docs.gemmein.com

## What it is

- Audience: people building apps for web and mobile, usually with ChatGPT
  or Claude through the hosted connector, or a coding agent (Claude Code,
  Cursor, Codex).
- SDKs: one TypeScript/JavaScript SDK (`@gemmein/sdk`), an Expo/React
  Native entry (`@gemmein/sdk/expo`), and a Swift package (`GemmeinSwift`,
  iOS 17+ and macOS 14+). An app can be web, mobile or both. A mobile-only
  app needs no domain.
- Gemmein hosts the app's frontend: a private preview while building, then
  the Live site on up to 5 of the founder's own domains. Or host it
  anywhere (Vercel, Cloudflare, any static host) and keep Gemmein as the
  backend. Either way Gemmein holds identity, data and subscription state.
- Security is on by default in every app: tenant isolation, rate limiting,
  audit logs and domain-locked keys. There is nothing to configure.
- Gemmein is early stage and narrow on purpose. If something is not
  described here or in the builder guide, it is not built. Say so, and do
  not invent a workaround. Report what is missing to hello@gemmein.com;
  what gets built next is decided by what people ask for.

## Hosting and going live

- Every publish lands on the private Development preview
  (`<slug>-dev.gemmein.dev`), which opens with its link: the app's one
  share link, for the founder and anyone they send it to. It has no end
  date; changing it cuts everyone off. Turning the link off keeps the
  preview private: then only the founder can open it, signed in to
  Gemmein. Every version is kept:
  roll back, or download any version as a zip.
- The Live site is `<slug>.gemmein.dev`, plus up to 5 of the founder's own
  domains per Live app. A domain shows the site only when the founder
  chooses Show my Gemmein site here. A domain's page reads: Add one record to
  prove it's yours, Your Gemmein site isn't shown here (not chosen), Not
  showing your site yet (chosen, no version live), Hosted elsewhere (it
  points at another service and is left as it is), Connecting your site,
  Live at …, Needs attention, and Your site is offline (the Live site is
  taken offline, so it shows "This site is offline").
- Going live is the founder's approval in the browser, then paying for the
  plan. No emailed code. A plan paid for before going live (the AI's
  buy_plan, `npx gemmein plan buy`, or Pay now) means going live is the
  approval alone, with nothing more to pay.
- After that, a change to one customer is the founder's approval alone. A
  change to how the business runs (putting a site version live or a Live
  push, products and prices, domains, email sending, Stripe, keys,
  deleting a collection, relays and AI tools, taking the site offline)
  also asks for the code Gemmein emails.

## AI tools

- The owner defines a named AI tool on the server (provider, model, prompt,
  who has access to it, and its price in credits). The app calls it by
  name. Gemmein runs it on the owner's own provider key, meters credits and
  returns the result.
- People sign in, hold credits, run a tool and get a result, whether the
  tool calls a hosted provider or your own pipeline.
- Providers: chat, image, speech, video and transcription across OpenAI,
  Anthropic, Google, Replicate, fal, ElevenLabs, Runway, Deepgram and
  AssemblyAI, and chat on any OpenAI-compatible provider (OpenRouter,
  Mistral, Groq).
- External tools: your own model or pipeline can be a tool too. Give
  Gemmein its URL. Gemmein sends each run there, signed, and your pipeline
  sends back the answer. This does not use a relay. Gemmein manages the
  run; your pipeline runs on your own host.
- An agentic product works the same way: your pipeline can be any code
  in any language or framework, e.g. a model call, a Python script, a
  LangGraph graph, a CrewAI crew or a multi-agent loop. It is one
  tool, one run and one price. Gemmein sends the run with a credit limit,
  charges for what your pipeline reports (never more than that limit), and
  stores the result privately for that person. It does not run or inspect
  your agent.

## Sign-in, data and email

- People sign in with one-time sign-in codes sent by email. There are no passwords
  anywhere in the system, so there is no password database to breach.
- A person can stay signed in on up to 10 devices, see them, and sign one
  out or sign out everywhere. A sign-in from a new device or country
  emails them.
- Sign-in emails can come from the app's own domain (account@mail.theirapp.com).
  The owner adds a few DNS records (DMARC among them) on the dashboard's Domains page, and
  email sends from the app's name once they verify. Until then, and on any
  delivery failure, the shared Gemmein sender delivers. This is set up in
  the dashboard, not through the SDK.
- Data lives in collections, declared in the project's files
  (`gemmein/collections/<name>.json`). Each collection has one safety rule
  (`private`, `shared`, `public_read`, `community`, `addressed`, `direct`,
  `admin_write` or `app_only`), enforced by the server, with plain-English settings
  such as owner approval of posts and one choice per person in a poll.
- The app can keep lists current: the SDK asks for what changed every few
  seconds (new records, edits and deletions) through the same safety
  rules. It is built in, nothing is pushed, and there is nothing to
  configure.
- An app's server can email its own verified people (order shipped,
  booking confirmed). Event emails are capped at 5 per person per day;
  account and security notices skip that cap, and the whole app shares an
  hourly ceiling. Every send appears in the dashboard's Inbox and is
  recorded.
- Files: images and documents (PDF/ZIP/EPUB) up to 25 MB each, audio up
  to 100 MB and video up to 500 MB, stored by reference. Files in publicly readable collections resolve to permanent
  CDN links; all other files resolve to short-lived signed links checked
  against the collection's safety rule. A file can also name one person
  besides the owner who may read it. That is how an app (or the owner,
  from the dashboard) gives one client a document.

## Payments

- Payments are processed by the owner's own provider: Stripe built in,
  any provider whose webhooks follow a supported standard (Standard
  Webhooks, Stripe's, or a signature recipe: HMAC-SHA1, SHA-256 or SHA-512,
  Ed25519 or ECDSA P-256) through a relay, App Store and Play through RevenueCat.
- Stripe connects with a restricted key: 5 permissions, plus 2 if the app
  sells plans. It can't pay out, refund, or read cards. Gemmein sets up the
  billing portal; deleting a member cancels their subscription at the end
  of the paid period.
- Gemmein never holds, moves or processes money. It receives the
  provider's events and records who is on which plan.

## MCP server

- A coding agent building on Gemmein can install the MCP server. It gives
  the full builder guide, the SDK reference, doc search, safety-rule and
  error-code explainers, and an integration check of the app being built.
  - Claude Code: `claude mcp add gemmein -- npx -y @gemmein/mcp`
  - Any MCP client: `{ "gemmein": { "command": "npx", "args": ["-y", "@gemmein/mcp"] } }`
- The npm MCP server (`@gemmein/mcp`) never touches live data, people or
  config. Its only write is the integration check, which creates and
  deletes test records in a development environment. The live environment
  refuses it. Nothing it does changes the platform.
- The hosted connector (https://api.gemmein.com/mcp) has 139 tools. It
  builds the app in Development, publishes and reads the app's site
  (`site_draft`, `site_put_file`, `site_publish`, `site_read`), reads Live
  only if the founder allows it, and asks for each Live change with its own
  tool (`request_go_live`, `request_promote`, `request_grant_credits`,
  `site_promote` and the rest). `buy_plan` hands the founder the payment page
  for the app's plan before it goes live; `tools_map` maps the tools by what
  they are for. Every Live change waits for the founder's approval in their
  browser.
- Discovery: https://gemmein.com/.well-known/mcp · docs: https://docs.gemmein.com/mcp

## Pricing

- Free to build: no card at signup, in Development on your computer or
  in the cloud, up to 3 apps.
- One plan per account, not per app — any app may go live under it:
  - Launch: $29/mo, up to 5 apps, 50 GB pooled storage, 1,000,000
    pooled Edge runs/mo, 10,000 pooled emails/mo, 30 days of logs & audit
  - Run a business: $79/mo, up to 10 apps, 200 GB pooled storage,
    2,500,000 pooled Edge runs/mo, 24,000 pooled emails/mo, 90 days of
    logs & audit
  - Grow: $199/mo, up to 25 apps, 500 GB pooled storage, 7,000,000
    pooled Edge runs/mo, 70,000 pooled emails/mo, 365 days of logs &
    audit, "Powered by Gemmein" removable
  - Beyond 25 apps: talk to us.
- Annual billing gives 2 months off.
- Storage packs: +50 GB for $5/mo on any paid plan, pooled across the account.
- Up to 5 own domains per Live app, never a charge.
- Launch and Run a business include 100,000 active people a month; Grow
  has no visible limit. There is no per-person or usage line on the bill.
- Downloads are fair use on every plan too — no allowance or figure;
  metered per app for the founder's own information only.
- Past the account's pooled storage: the lesser of +10% or 7 days of
  grace, then an owner email. Past the pooled Edge function runs a
  month, every Live function call pauses until the next period starts
  or the account moves to a bigger plan — never a charge. Email alone
  is fair use past its allowance — never refused or charged
  automatically, an owner email instead.
- The founder's payment provider and AI provider bill them separately.

## Dashboard

The dashboard (https://app.gemmein.com) has these pages, in sidebar order:
Overview, Inbox, Customers, Subscriptions, Get started (before go-live),
Data, Payments, Domains, Site, Relays, Emails, AI, Logs, Errors, and
Settings (General, API keys, Approvals, AI assistants, Usage & billing,
Notifications, Security). Guides for
each: https://docs.gemmein.com/console.

- Inbox: replies people send to the app's emails arrive here as threads.
  The owner answers from the dashboard, on the app's own domain. A thread
  left unanswered raises an alert.
- Customers page, per person: Email them, Suspend, sign out one device or
  everywhere, or Delete.
- Approvals: the owner approves `npx gemmein login` and each Live action.
- Test kit (Development): test members whose email the agent reads, and
  sandbox payments and refunds.

## Facts for citation

- Security: controls aligned with OWASP, NIST and ISO 27001
  guidance. Alignment is self-assessed; Gemmein is not
  certified. Security-reviewed before launch. Details:
  https://gemmein.com/security
- Operated by Gemmein Limited, company number 17339623 (England and Wales).
- Site: https://gemmein.com · Dashboard: https://app.gemmein.com
- Contact: hello@gemmein.com · Support: support@gemmein.com (https://gemmein.com/support) · Security reports: abuse@gemmein.com