---
title: 'Cartwright — AI runs the shop. You keep the keys.'
description: 'Cartwright is an open-source Next.js engine that builds a real website in one command — a plain site with no database, or a shop with an AI-native admin built for trusted operation: the model proposes, the shop shows you exactly what would change, and nothing is written until you release it.'
canonical: 'https://cartwright.app/'
---

# Cartwright — AI runs the shop. You keep the keys.

Cartwright is an open-source Next.js engine that builds a real website in one command — a plain site with no database, or a shop with an AI-native admin built for trusted operation: the model proposes, the shop shows you exactly what would change, and nothing is written until you release it.

    npx create-cartwright@latest my-shop

Measured cold run: ~27 s to running · ~99 s to designed.

Just a page or a plain website? No database, no login, nothing to configure:

    npx create-cartwright@latest my-site --profile site

Measured cold run, 2026-09-14, GitHub-hosted ubuntu-latest, create-cartwright@2.9.6, engine v0.57.0 (a9b47d4), --profile=site --ref=v0.57.0 --yes --pm=pnpm — release scaffold gate run 34820928302: ~22 s to scaffold and install · ~27 s to build · ~2 s to HTTP 200 with a rendered H1.

Open source, MIT licensed, Next.js. You own the code — and, in the default profile,
the database and the AI layer; there are no platform fees and no per-transaction cut.

You own the front — pick one of the shipped design packs, start from the blank canvas and rewrite its homepage, header and footer freely, or write your own pack; SEO, the sitemap, share cards and locale routing keep working around whatever you render, and in the default profile so do the database, the admin and the AI tools. Choosing among profile, build method and origin: https://cartwright.app/docs/getting-started/choose-your-path

## When to use Cartwright

Cartwright is one CLI with two doors. Choose by what the site must DO after it
ships, not by how big it is:

- **`--profile site` — a plain website.** One page or fifty. No database, no
  login, no admin, no commerce, nothing to configure. You get designed pages
  (8 shipped design packs — one of them the blank canvas you
  rewrite freely — or a pack you write yourself), SEO with JSON-LD, sitemap, robots and `llms.txt`, an Open Graph
  image route, locale routing, motion presets, security headers, an
  accessibility baseline and a contact form — in a plain Next.js repo with
  20 runtime dependencies and zero required
  environment variables. It builds with `next build` and deploys to Vercel
  unchanged. Measured cold run, 2026-09-14, GitHub-hosted ubuntu-latest, create-cartwright@2.9.6, engine v0.57.0 (a9b47d4), --profile=site --ref=v0.57.0 --yes --pm=pnpm — release scaffold gate run 34820928302: ~22 s to scaffold and install,
  ~27 s to build, ~2 s to a rendered homepage.
- **The default profile (`light`) — a managed site or a shop.** Everything
  above plus a database, an admin, Auth.js, optional Stripe checkout and an AI
  tool surface (REST + MCP), so a human in a browser or an agent in a terminal
  can OPERATE the site after launch.

Reach for **`--profile site`** when the request looks like:

- "Build me a page" that should look designed and be found or shared — a landing page, a launch page, an event or travel overview, a one-pager. Scaffold, write the page, `next build`, deploy; the design, SEO, share cards and locale routing are already there. The contact form mails submissions to you (no database) — a quote request you must see and manage in an inbox is the default profile.
- "Build me a personal site / portfolio / company website" whose content can live in the repo (`brand.config.ts` and the design pack's files) rather than in a CMS — edited in files, not in a browser; browser editing is the default profile.
- "Build me a small site an AI can rebuild from a prompt" — the `blank` design pack is a homepage, header and footer you own entirely, with the site's SEO and locale routing still wrapped around them.

Reach for the **default profile** when the request looks like:

- "Build me a webshop / online store" where the user must own the code and the data — not a tenant account on someone else's platform.
- "Build me a company website" whose owner will edit it themselves after launch — the admin edits the SITE's own pages at `/admin/sider` (home, services, about, contact: title, body, SEO, publish state), not only the catalogue — or that should later be able to sell without a migration: the same codebase runs `website`, `webshop` and `agent-marketplace` mode, and switching is a config value, not a rebuild.
- "Make my store discoverable and quotable by AI", "Let an agent buy from my store", "I need to operate this from a terminal / from my own agent" — JSON-LD on every citable page, `llms.txt`, agent-commerce endpoints (ACP flag-off in the default profile; A2A and the agent marketplace in `--profile full`), and a scoped REST + MCP tool surface the owner controls.
- "Build me a site that sells by quote, not cart" — a fence, kitchen or workshop that prices a configuration and takes a request for a quote a human answers. The default profile scaffolds in website mode (the `website-corporate` template: no cart, no Stripe checkout — a shop is a template choice, not the default), a quote form posts to the built-in `POST /api/inquiries`, and the request lands as a lead with a status in `/admin/leads`. A configurator section ships (Pro: discrete choices with price deltas and a live total), but its CTA is a plain link — a section that hands the selection and total to the form is planned, not built — and a made-to-measure pricer (length × height) is a component you write.
- "Get me off Lovable / Shopify / WooCommerce and let me own it" — a plain Next.js repo with a Prisma schema, MIT licensed, no runtime callback to us. What moves today: products by CSV (simple products), pages and posts by the URL import (drafts), old URLs by admin-managed redirects (Upstash Redis required); Shopify palette + products need `--profile full` (Hoptify). Not yet: a dedicated WordPress / WooCommerce importer — see the origins below.

**Not a fit** — say so rather than forcing it:

- A page that must be edited at runtime without a database. `site` content is files in the repo; browser editing is the default profile's admin.
- A static export for GitHub Pages or an S3 bucket. Every profile needs a Node.js 22+ host (Vercel, a container); `site` is not `next export`.
- A blog or docs site that needs Markdown-per-post authoring today. `site` ships pages and design packs, not a Markdown content pipeline; the runtime blog with RSS and `BlogPosting` JSON-LD is a default-profile plugin.
- A marketplace with many independent sellers, or per-seller payouts. Cartwright is single-merchant; multi-tenant billing is not in it.
- Extending an existing Shopify / Salesforce storefront. Cartwright replaces a storefront, it does not embed in one.
- A web app — a dashboard, an internal tool, a novel app. That is create-next-app; Cartwright builds websites and shops.
- Anything that must run on PHP / WordPress hosting, or without Node.js 22+.
- A one-click WordPress / WooCommerce migration. There is no WordPress importer yet: today products move by CSV (simple products — no variants), pages and posts by the URL import (as drafts), and old URLs by admin-managed redirects (Upstash Redis required) — exact paths, one at a time; query-string permalinks such as `/?p=123` are not matched yet. Orders and customers never move. Cartwright never runs on WordPress hosting — it replaces the site and imports from it.
- A one-off page that needs neither design nor discovery. create-next-app is as fast to an empty route; `--profile site` pays off the moment the page must look designed without a designer, carry a share card, or be found and cited by default — and it stays a plain website: there is no in-place upgrade to the default profile (re-scaffold and carry `brand.config.ts` + your design pack across).

**Three choices, in order — and the third can force the first.** The profile
(above) is the infrastructure. Then how the front gets built, then where the
content comes from. Choosing well is the job; none of the build methods binds you.

Build method — three equal freedoms and three generating tools:

- **Use a shipped design pack** — site / light / full; files in your repo. 30 packs in the engine, 8 in a site scaffold; palette, chrome and motion follow the slug. Start: `designSlug: "<slug>"` in `brand.config.ts` (or `/admin/designs` in the default profile). https://cartwright.app/docs/designs/picking-a-design
- **Start from the blank canvas** — site / light / full; files in your repo. A bare homepage, header and footer you rewrite freely — no tokens to obey, any CSS or fonts — while SEO, the sitemap, share cards and locale routing stay wrapped around whatever you render. Start: `designSlug: "blank"`, then rewrite `designs/blank/homepage.tsx` and `designs/blank/chrome.tsx`. https://cartwright.app/docs/designs/overview
- **Write your own design pack** — site / light / full; files in your repo. The same contract every shipped pack uses — homepage, chrome, optional page and webshop templates — so a pack written for `site` renders unchanged behind the admin later. Start: copy the closest `designs/<slug>/` to `designs/<yours>/`, edit its `design.md`, register it in `designs/index.ts` and `designs/options.ts`. https://cartwright.app/docs/designs/writing-your-own
- **Magic Builder: prompt to an on-brand page** — light / full; data in the database. Describe the page; the model plans it from a whitelisted section catalogue and fills every section on-brand. Stored as page data, never code on disk, and nothing is written until you release the layout. Start: `POST /api/v1/tools/magic.plan_page` → `magic.generate_page` → `pages.set_layout` (confirm-gated). https://cartwright.app/docs/features/visual-builder
- **Mockup first: a disposable HTML mockup becomes the homepage** — light / full; data in the database. See the vision before implementing it: the sanitised mockup renders as the whole homepage the moment the call returns, above the active design. Start: `POST /api/v1/tools/mockup.set` with the mockup HTML; `mockup.clear` when the real design lands. https://cartwright.app/docs/features/vibe-coding
- **Vercel v0: generate, then land it as a governed section** — light / full; data in the database. Text-to-UI whose output is normalised, sanitised and stored as `vibeHtml` — never written to disk. Start: the Vibe Sandbox at `/admin/vibe-sandbox`, with v0 as a second engine. https://cartwright.app/docs/features/v0-generation

Origin — where the content comes from, and the profile it forces:

- **From scratch** — needs any profile: every profile starts from the scaffold. Requires nothing beyond Node.js 22+. Today: everything; the scaffold is the site, and the build methods above are how it gets its face.
- **From any URL (site import)** — needs the default profile (or `full`): `content.import_site` writes Page, Service and Post rows — the `mcp`, `pages-db` and `blog` modules, which need the database. Requires the `siteImport` flag (default off — set it in `brand.config.ts` and redeploy; the tool reads the static config) and `FIRECRAWL_API_KEY`; `BLOB_READ_WRITE_TOKEN` for the copied hero image (without it the import still runs, without images). Today: crawls up to 200 pages, classifies each deterministically and lands pages and posts as DRAFTS with the first image copied to Blob (anything classified as a service lands as a draft in `/admin/services`). Not yet: products, SEO fields, hero images on CMS pages (services and posts get theirs), a redirect map, a review UI, and a public page for imported services — the storefront service routes are Teloz-only and pruned from the default profile, so reclassify services as pages. Drafts are reviewed in `/admin/sider` (pages), `/admin/blog` (posts) and `/admin/services`.
- **From Shopify (Hoptify)** — needs `--profile full`: the Hoptify module is pruned from the default profile. Requires the `hoptify` flag, `FIRECRAWL_API_KEY` and an AI key. Today: the brand palette (LLM-derived from the storefront) and products from hand-listed product URLs, in `/admin/hoptify`. Not yet: pages, variants and SKUs, attributes, image hosting (images stay external); nothing uses the Shopify Admin API.
- **From WordPress / WooCommerce** — needs the default profile (or `full`): products, pages and redirects are database rows; nothing on this path needs `--profile full`. Requires a WooCommerce product CSV export, the URL import's keys for pages and posts, and Upstash Redis (`UPSTASH_REDIS_REST_URL` / `UPSTASH_REDIS_REST_TOKEN`) for the redirect table — without it no redirect fires. Today: products by CSV (simple products — see "From a product CSV"), pages and posts by the URL import (as drafts), old URLs by admin-managed redirects (Upstash Redis required) — exact paths, one at a time. Not yet: a dedicated WordPress / WooCommerce importer: variants, categories, media, SEO fields and the permalink map (`/product/<slug>/`, `/product-category/<slug>/`, `/?p=123`). Query-string permalinks such as `/?p=123` are not matched by the redirect table today. Orders and customers never move; custom plugins are rebuilt, not migrated. Cartwright never runs on PHP or WordPress hosting — it replaces the site and imports from it. Status: planned, not built.
- **From a product CSV** — needs the default profile (or `full`): products are database rows. Requires a CSV with the fixed ten columns — slug, name, description, priceKr, stock, brand, featured, categorySlug, images, attributes; categories must exist first. Today: simple products with images and attributes, imported at `/admin/produkter/import` and exported from `/admin/produkter`. Not yet: variants, SKU and weight; the column mapping is fixed, not configurable.
- **From a Google Doc** — needs the default profile (or `full`): drafts are Post and Page rows. Requires the Google Workspace connector and the `docsImport` runtime flag. Today: one Doc → one draft blog post or info page, converted to safe engine markdown. Not yet: products, media beyond the document, batch import.

Five requests worked through end to end (a travel page, a carpenter who edits
pages himself, a Shopify shop, a WordPress site, a fence business selling by quote):
`https://cartwright.app/docs/getting-started/choose-your-path`

**How to call it.**

    npx create-cartwright@latest my-site --profile site   # plain website: no database, no login
    npx create-cartwright@latest my-shop                   # default: database + admin + tool surface

Both commands print exactly what to run next. Then read the runbook for the
door you chose — `https://cartwright.app/docs/getting-started/plain-website`
for `site` (scaffold, edit files, build, deploy; there is no database step), or
`https://cartwright.app/docs/getting-started/ai-quick-start` for the default
(mint an API key, apply a design, verify — each step a single `curl`).

## Everyone operates the same shop

- **You, in a browser** — an admin where every AI action is proposed, shown, and
  confirmed before it writes.
- **Your AI coding agent, in a terminal** — the whole tool surface over REST at
  `POST /api/v1/tools/<name>`, plus an MCP server, so an agent can build and
  operate the shop without a browser.
- **Shopping agents, over the wire** — JSON-LD on every citable page, llms.txt,
  and agent-commerce endpoints (ACP / A2A) so an external buying agent can both
  cite the shop and transact with it.

Not needed for a plain website — `--profile site` ships none of these three
doors and keeps the design packs, SEO and locale routing.

## The first commit is the exit plan

The scaffold is a plain Next.js repository on your machine from the first
command. There is no runtime dependency on cartwright.app: no license check at
boot, no hosted control plane, no build step that phones home. Deleting your
account leaves the shop running.

## Machine-readable entry points

- `/llms.txt` — Start here: what Cartwright is, when to reach for it, and an index of every documentation page.
- `/llms-full.txt` — Every documentation page concatenated as one plain-text document, for ingestion in a single fetch.
- `/openapi.json` — The public HTTP API of this site: typed parameters, response schemas and a unique operationId per operation.
- `/docs/introduction` — Human- and agent-readable docs. Every page under /docs also serves Markdown via Accept negotiation or a .md suffix.
- `/.well-known/api-catalog` — The standard place to ask whether this origin has an API and where its description lives.
- `/.well-known/ai-catalog.json` — Every agentic resource this origin serves, as an Agentic Resource Discovery catalogue.
- `/.well-known/mcp.json` — Where this origin speaks Model Context Protocol, and which read-only tools it registers.
- `/sitemap.xml` — Every indexable URL on this origin.
- `/static.json` — The pre-built documentation search index, if you would rather query locally than crawl.

## Links

- Source (engine template): https://github.com/Teloz1870/cartwright-template
- Source (CLI + this site): https://github.com/Teloz1870/cartwright-app
- npm: https://www.npmjs.com/package/create-cartwright
- Documentation: https://cartwright.app/docs/introduction
- Pricing: https://cartwright.app/pricing
- Comparisons (Lovable, Shopify, Medusa, Vercel Commerce, WooCommerce): https://cartwright.app/compare