`:
```ts
import { CoDuckError } from '@coduck/sdk';
try {
await coduck.meta();
} catch (err) {
if (err instanceof CoDuckError) console.error(err.code, err.message);
}
```
---
## Auth
Source: https://coduck.ai/docs/raw/sdk/auth.md
# Auth
Email/password authentication for your deployed app. Sessions are stored in an httpOnly cookie and managed by server helpers; the client gets a small `useUser()` hook.
> **Deploy required.** Auth needs `CODUCK_AUTH_KEY`, which CoDuck only injects when the project is **deployed**. Sign-in will not work in the in-editor preview — deploy first.
## Server helpers
`@coduck/sdk/server` wraps the cookie + session handling for Next.js (App Router). Use it in route handlers and server actions.
```ts
import {
getSession,
signInWithPassword,
signUpWithPassword,
signOut,
} from '@coduck/sdk/server';
```
| Function | Returns | Notes |
|---|---|---|
| `getSession()` | `{ user } \| null` | Reads + verifies the session cookie |
| `signUpWithPassword(email, password, name?)` | `AuthSession` | Creates the user **and** sets the cookie |
| `signInWithPassword(email, password)` | `AuthSession` | Logs in **and** sets the cookie |
| `signOut()` | `void` | Clears the cookie + invalidates the refresh token |
### Sign in (server action)
```ts
'use server';
import { signInWithPassword } from '@coduck/sdk/server';
import { redirect } from 'next/navigation';
export async function login(formData: FormData) {
await signInWithPassword(
String(formData.get('email')),
String(formData.get('password')),
);
redirect('/dashboard');
}
```
### Protect a server component
```tsx
import { getSession } from '@coduck/sdk/server';
import { redirect } from 'next/navigation';
export default async function Dashboard() {
const session = await getSession();
if (!session) redirect('/login');
return Welcome, {session.user.email}
;
}
```
### The `/api/me` route
The client hook reads the session from your own app via `GET /api/me`. Expose it with the server helper so the browser never touches the cookie directly:
```ts
// app/api/me/route.ts
import { getSession } from '@coduck/sdk/server';
export async function GET() {
const session = await getSession();
return Response.json(session ?? { user: null });
}
```
## Client hook
`@coduck/sdk/client` gives you the current user in a client component. It fetches `/api/me` (above).
```tsx
'use client';
import { useUser } from '@coduck/sdk/client';
export function UserBadge() {
const { user, loading, refresh } = useUser(); // useUser('/api/me') by default
if (loading) return null;
if (!user) return Sign in;
return {user.email};
}
```
`useUser()` returns `{ user: AuthUser | null, loading: boolean, refresh: () => Promise }`.
## Low-level client
For full control over tokens (custom flows, non-cookie clients), `@coduck/sdk/auth` exposes the raw client:
```ts
import { auth } from '@coduck/sdk/auth';
const session = await auth.login({ email, password });
// → { user, accessToken, refreshToken, expiresIn }
const user = await auth.me(session.accessToken);
const renewed = await auth.refresh(session.refreshToken);
await auth.logout(session.accessToken);
```
| Method | Returns |
|---|---|
| `signup({ email, password, name? })` | `AuthSession` |
| `login({ email, password })` | `AuthSession` |
| `refresh(refreshToken)` | `AuthSession` |
| `verify(accessToken)` | `AuthUser` |
| `me(accessToken)` | `AuthUser` |
| `logout(accessToken)` | `void` |
## Types
```ts
interface AuthUser {
id: string;
email: string;
name?: string | null;
createdAt: string;
}
interface AuthSession {
user: AuthUser;
accessToken: string;
refreshToken: string;
expiresIn: number; // seconds until the access token expires
}
```
---
## Forms
Source: https://coduck.ai/docs/raw/sdk/forms.md
# Forms
Capture submissions from any form (contact, waitlist, feedback) without writing a backend. Submitting is browser-safe; reading requires the API key, so it runs on the server.
```ts
import { forms } from '@coduck/sdk/forms';
```
## Submit (browser-safe)
`submit()` is public — call it from a client component. It only needs `NEXT_PUBLIC_CODUCK_PROJECT_ID` (injected at deploy).
```tsx
'use client';
import { forms } from '@coduck/sdk/forms';
async function onSubmit(e: React.FormEvent) {
e.preventDefault();
const data = new FormData(e.currentTarget);
await forms.submit('contact', {
name: data.get('name'),
email: data.get('email'),
message: data.get('message'),
});
}
```
You can also import the bound helper directly:
```ts
import { submit } from '@coduck/sdk/forms';
await submit('waitlist', { email });
```
The `formName` is just a label you choose — submissions are grouped by it.
## Read submissions (server only)
`list()` and `markRead()` require `CODUCK_API_KEY`, so call them from a route handler or server component.
```ts
import { forms } from '@coduck/sdk/forms';
const recent = await forms.list({ formName: 'contact', limit: 50 });
await forms.markRead(recent[0].id);
```
| Method | Scope | Returns |
|---|---|---|
| `submit(formName, fields)` | browser-safe | `void` |
| `list({ formName?, limit? })` | server | `FormSubmission[]` |
| `markRead(id)` | server | `FormSubmission` |
Submissions also show up in your project's **Forms** tab in the cloud panel.
## Type
```ts
interface FormSubmission {
id: string;
projectId: string;
formName: string;
fields: Record;
// Daily-rotating anonymized hash of the submitter's IP — the raw IP is
// never stored. Same value = same visitor that day (spam triage).
submitterIpHash: string | null;
userAgent: string | null;
read: boolean;
createdAt: string;
}
```
---
## Storage
Source: https://coduck.ai/docs/raw/sdk/storage.md
# Storage
Per-project file storage for uploads, generated assets, exports — anything your app needs to keep. All methods require `CODUCK_API_KEY`, so use storage from the server.
```ts
import { storage } from '@coduck/sdk/storage';
```
## Upload
`file` can be a `Blob`, `Buffer`, or `Uint8Array`. Max **50 MB** per file. Names may contain letters, digits, and `+ . _ -`.
```ts
// e.g. inside a route handler
const form = await request.formData();
const file = form.get('file') as File;
const saved = await storage.upload(file.name, file);
// → { name, size, modifiedAt }
```
## List, link, delete
```ts
const files = await storage.list(); // StoredFile[]
const href = storage.url('logo.png'); // direct fetch URL (needs API key header)
await storage.delete('logo.png');
```
| Method | Returns |
|---|---|
| `list()` | `StoredFile[]` |
| `upload(name, file)` | `StoredFile` |
| `delete(name)` | `void` |
| `url(name)` | `string` |
> `url(name)` returns a direct link, but fetching it requires the API key in the `Authorization` header — so serve files through your own route rather than exposing the raw URL to the browser.
## Type
```ts
interface StoredFile {
name: string;
size: number; // bytes
modifiedAt: string;
}
```
---
## Analytics
Source: https://coduck.ai/docs/raw/sdk/analytics.md
# Analytics
Track custom events — signups, purchases, feature usage — alongside the pageview data CoDuck already collects for your project.
```ts
import { analytics } from '@coduck/sdk/analytics';
await analytics.track('signup_completed', { plan: 'pro' });
```
Or the bound helper:
```ts
import { track } from '@coduck/sdk/analytics';
await track('checkout_started', { cartValue: 49.0 });
```
| Method | Returns |
|---|---|
| `track(name, properties?)` | `void` |
`properties` is an optional `Record` of metadata for the event.
> Requires `CODUCK_API_KEY`, so call `track()` from the server (route handler or server action). **Pageviews are recorded automatically** — reach for `track()` only for the custom events that matter to your product.
---
## Install the CLI
Source: https://coduck.ai/docs/raw/cli/install.md
# Install the CLI
The CoDuck CLI ships on npm as **`@coduckai/cli`**. It's the same binary used by humans in their terminal and by AI agents calling into CoDuck from their host.
## Requirements
- **Node.js 20** or newer (we use modern fetch + native `Set` semantics)
- A POSIX shell (`bash` / `zsh` / `fish`) or PowerShell
- macOS, Linux, or Windows
## Global install (recommended)
```bash
npm install -g @coduckai/cli
```
Verify:
```bash
coduck --version
```
You should see a JSON line with the current version and the API base URL. If the `coduck` command isn't found, your `npm` global bin isn't on `$PATH` — see Troubleshooting below.
## After installing
Three commands to get going:
```bash
coduck login # browser opens, click Approve
coduck create-existing # in your project folder — creates a coduck.json
coduck chat # opens an interactive chat with the AI agent
```
That's it — you're now operating a CoDuck project from your terminal.
## One-off / no global install
```bash
npx @coduckai/cli@latest
```
Useful in CI or on someone else's machine. Slower per invocation because npm has to resolve the package each time.
## Updating
```bash
npm install -g @coduckai/cli@latest
```
The CLI **does not auto-update**. If you want to know what changed between versions, see the changelog on the [npm page](https://www.npmjs.com/package/@coduckai/cli).
## Uninstall
```bash
npm uninstall -g @coduckai/cli
rm -rf ~/.coduck
```
The second command removes your stored credentials and any `coduck.json`-cached state. (Your remote CoDuck account is untouched. To delete that, sign in to [coduck.ai](https://coduck.ai) and use account settings.)
## Output modes
The CLI behaves differently depending on whether its stdout is a terminal:
- **Interactive (TTY)** — pretty tables, colors, spinners, prompts
- **Piped (non-TTY)** — pure JSON, no colors, no prompts, exit codes carry the meaning
Force machine mode at any time with `--json`. Force "fail instead of prompting" with `--no-input`. Both can be combined for use inside agent loops.
```bash
coduck projects --json | jq '.[].id'
coduck deploy --no-input --json
```
## Troubleshooting
### `coduck: command not found`
Your npm global bin directory isn't on `$PATH`. Find it with:
```bash
npm config get prefix
```
The binary lives in `/bin`. Add that to your `$PATH` in your shell config (`~/.zshrc`, `~/.bashrc`, etc.).
### `Cannot find module ...node_modules\coduck-cli\...` on Windows
You have a stale shim from a previous attempted install of a different package name. Run these in Command Prompt:
```cmd
npm uninstall -g coduck-cli
npm uninstall -g @coduckai/cli
del "%APPDATA%\npm\coduck.cmd"
del "%APPDATA%\npm\coduck.ps1"
del "%APPDATA%\npm\coduck"
npm install -g @coduckai/cli@latest
```
The `del` commands may say "could not find" for some files — that's fine, keep going. Last command installs fresh.
### `EACCES: permission denied` during install
You're using a system Node where `npm install -g` needs sudo. Don't `sudo npm install` — instead, switch to a user-level Node manager:
- macOS / Linux: [nvm](https://github.com/nvm-sh/nvm) or [fnm](https://github.com/Schniz/fnm)
- Windows: [nvm-windows](https://github.com/coreybutler/nvm-windows)
Then re-run `npm install -g @coduckai/cli` without sudo.
### `EBADENGINE` or "unsupported engine"
Your Node version is below 20. Upgrade Node.
## What's installed
The package contains:
- `bin/coduck.js` — the entry point (calls into compiled JS)
- `dist/` — compiled TypeScript output (~30 KB)
- Runtime deps: `commander`, `chalk`, `@inquirer/prompts`, `cli-table3`, `ora`, `form-data`
No native modules, no postinstall scripts, no telemetry.
## Next
You're ready to [sign in](/docs/cli/auth).
---
## Authentication
Source: https://coduck.ai/docs/raw/cli/auth.md
# Authentication
The CLI uses **browser-based device authorization**. You never type your CoDuck password into your terminal. Approval happens on a CoDuck web page that you're already signed in to.
## Signing in
```bash
coduck login
```
What happens, step by step:
1. CLI prints a short confirmation code like `AB7K-9XQM` and opens your browser to `https://app.coduck.ai/cli?code=AB7K-9XQM`.
2. If you're not signed in to the web app, you're sent to `/login` first, then bounced back.
3. The page shows the device the CLI is asking for ("your hostname / your OS") and an Approve / Deny button.
4. You click **Approve**.
5. Within ~5 seconds, the CLI receives the token and writes it to `~/.coduck/credentials.json` (file mode `0600`).
That's it. From this point on, every CoDuck command works without prompting.
> [!NOTE]
> The CLI has no `--password` flag and never reads your password from stdin or an env var. If you're seeing a doc anywhere that mentions one, it's outdated.
## Token lifetime
| What | How long |
|---|---|
| Initial token | 90 days |
| Sliding extension on each use | +30 days, capped at 180 from issue |
| Hard maximum lifetime | 180 days from creation |
| Idle expiry | 90 days of no use |
In practice: if you use the CLI even occasionally, you'll never get logged out. If you stop using it for 90 days, your next call will 401 and you'll need to `coduck login` again.
## Managing tokens
Every device gets its own token. You can have many — one per laptop, one for CI, etc.
### List your tokens
```bash
coduck token list
```
Shows each token with its device name, last-used timestamp, last IP, and expiration.
### Revoke a single token
```bash
coduck token revoke
```
Takes effect within ~30 seconds (the API caches the revocation list for performance).
### Revoke every token on your account
```bash
coduck logout --all
```
Use this if you think a token might have been exposed. Your web session is untouched.
### Sign out from just this machine
```bash
coduck logout
```
Revokes only the current device's token and clears `~/.coduck/credentials.json`. Other devices keep working.
## Where your credentials live
```
~/.coduck/
└── credentials.json (mode 0600)
```
The file contains your token, the API URL, your user ID, and your email. **Don't share it.** Anyone with this file has full account access until the token expires or you revoke it.
If you accidentally print or share it, run `coduck logout --all` immediately and `coduck login` to issue a fresh token.
## Inspecting the current token
```bash
coduck token status # plan + credits, no token printed
coduck whoami # who you're signed in as
coduck token show --confirm # actually print the token (refuses without --confirm)
```
The `--confirm` requirement on `show` is intentional: by default it refuses to leak the token to stdout, where it could end up in shell history or someone else's screen.
## For CI / GitHub Actions
`npm login` doesn't work in CI. The token-based flow is what you want anyway:
1. Run `coduck login` once on your local machine.
2. `cat ~/.coduck/credentials.json` — copy the `token` field.
3. Add it to your CI secrets as `CODUCK_TOKEN`.
4. In CI:
```yaml
- run: npm install -g @coduckai/cli
- run: |
mkdir -p ~/.coduck
cat > ~/.coduck/credentials.json <
## Commands reference
Source: https://coduck.ai/docs/raw/cli/commands.md
# Commands reference
Every CoDuck CLI command, grouped by what it operates on. All commands honor `--json` (machine-readable output), `--no-input` (fail instead of prompting), and real exit codes (0 ok, 2 usage, 3 auth, 4 not found, 5 conflict, 6 network, 7 server — full table at the bottom).
For installation, see [Install the CLI](/docs/cli/install). For sign-in, see [Authentication](/docs/cli/auth).
## Chat with the agent
Send a prompt to a project's AI agent, stream the response. Designed for AI agents calling CoDuck programmatically — JSON-first, NDJSON streaming, no interactive prompts.
```bash
coduck chat "add a login page" # streams response, exits
coduck chat "add a login page" --json # NDJSON output for agents
coduck chat "add a login page" --project # override coduck.json
coduck chat --history # print recent messages
coduck chat --history --json # same, as JSON
```
`coduck ask "..."` is an alias for `coduck chat "..."`.
### NDJSON event types (what an agent sees with `--json`)
| event | what it means |
|---|---|
| `chunk` (type=`ttft`) | First token arrived; includes time-to-first-token in ms |
| `chunk` (type=`text` or `response`) | Streaming response text |
| `chunk` (type=`tool_call`) | Agent called a tool: `tool`, `path`, args |
| `chunk` (type=`code`) | Wrote/edited a file: `path`, `content` |
| `chunk` (type=`preview_url`) | Sandbox boot, ephemeral preview URL |
| `chunk` (type=`usage`) | Tokens used in this round |
| `chunk` (type=`complete`) | Generation finished server-side; cost, file list |
| `complete` | Final summary (mirror of last chunk) |
| `done` | CLI-side wrap-up event with totals |
| `paywall` | Insufficient credits; includes plan + upgrade hint |
| `error` | Failure; includes `message` |
## Projects
```bash
coduck projects # list your projects
coduck project # show one project's details
coduck create --name # create a new AI-scaffolded project
coduck create-existing # import the current directory as a project
coduck rename # rename a project
coduck delete --yes # delete a project (irreversible)
coduck pause # pause (stops billing, keeps state)
coduck resume # resume a paused project
```
## Files
```bash
coduck push # upload local files (→ your draft if you have one; see below)
coduck push --prod # push straight to live (upload + deploy)
coduck push --draft # force the draft target (dev environment)
coduck push --dry-run # show file count, total size, biggest dirs — no upload
coduck push --force # push even if the server has newer files
coduck pull # download project files locally
coduck files ls # list remote files
coduck files cat # print a remote file
```
`push` uploads the source dir from your [`coduck.json`](/docs/reference/coduck-json)
and delivers the config file itself (even from a subdirectory). Transient network
errors retry automatically.
**`push` is environment-aware.** If your project has a **draft**, `push` uploads your
files **and hot-reloads them into the running draft** (~1s via Turbopack; it auto-wakes
the draft if it's asleep) — your live site is untouched. `push --prod` pushes straight
to live (upload + deploy). No draft ⇒ `push` just uploads, and `deploy` publishes — as
before. Every run says where it landed (DRAFT vs LIVE). See **Drafts & preview** below.
## Deploy
```bash
coduck deploy # publish live (or update your draft — see below)
coduck deploy --live # force publish to your live site
coduck deploy --draft # update your draft (dev environment) instead
coduck deploy --size large # deploy on a bigger instance (small|medium|large)
coduck stop # stop the running container
coduck restart # restart with no config change
coduck status # current deployment status
coduck teardown --yes # destroy container + DB + vhost
coduck logs --follow # tail container logs
coduck logs --since 30m --grep error # filter by age + pattern
coduck logs-digest # summarized error/warn digest
```
`deploy` uses the commands + `instanceSize` from your
[`coduck.json`](/docs/reference/coduck-json); `--size` overrides the tier for one
deploy. A failed deploy reports the specific cause (out of memory, build failed,
wrong port, crashed after start).
**`deploy` is environment-aware** (see **Drafts & preview** below): if the
project has a draft, `deploy` **updates the draft** by default (your live site is
untouched — promote when ready); with no draft it publishes **live**, as always.
Override per run with `--live` / `--draft`, or set `"defaultEnv"` in `coduck.json`.
Every run prints its target (DRAFT vs LIVE).
## Drafts & preview (Plus/Studio)
A **draft** is a private dev environment (its own database) where you try changes
before they go live. Edits — including `coduck generate` — go to your source, which
the draft runs; your live site only changes when you publish.
```bash
coduck draft create # create the draft (its own dev database)
coduck wake # wake/pre-warm the draft so pushes hot-reload instantly
coduck push # upload + hot-reload into the draft (~1s; auto-wakes it)
coduck changes # preview a publish: per-file +/- diff + DB schema add/remove
coduck draft url --open # open your draft's private preview in the browser
coduck draft status # is the draft running / asleep?
coduck draft promote # publish the draft to your live site
coduck draft promote --confirm # …confirming a destructive DB change (drops); auto-backed-up first
coduck draft delete # remove the draft; live site untouched
```
**Viewing your draft.** A draft has **no public subdomain** — it's a private preview on
`preview.coduck.ai` behind a short-lived signed token (only you can open it).
`coduck draft url` prints that link (`--open` launches it); `coduck push` and
`coduck wake` also print it on success. The link is good for about an hour — re-run
`coduck draft url` for a fresh one.
**The fast loop:** with a warm draft (`coduck wake` once), each `coduck push`
hot-reloads your changes in about a second — same feel as a local dev server — while
your live site stays put. `coduck draft update` (aliases `deploy`, `wake`) does the
same refresh without an upload; it only cold-boots (~60–90s) when the draft is asleep.
`promote` (alias `publish`) ships the draft to live.
Drafts are a **Plus/Studio** feature — other plans get a clear message. Everything is
`--json`-friendly for agents; the typical headless loop is
`edit → coduck push → coduck changes → coduck draft promote`.
## Generation (AI agent)
```bash
coduck generate "add a login page" --wait # send a prompt to the agent
coduck jobs status # check a running generation
coduck jobs messages # conversation history
```
## Environment variables
```bash
coduck env list # list env vars (values masked)
coduck env list --reveal # show full values
coduck env get
coduck env set
coduck env unset
coduck env import .env # bulk import (skips reserved/invalid keys, imports the rest)
coduck env reserved # list the keys CoDuck manages (can't be set)
```
A set of keys are reserved (CoDuck injects them and rejects them on write):
`DATABASE_URL`, `DIRECT_URL`, `PORT`, `NODE_ENV`, and everything under `CODUCK_*` /
`NEXT_PUBLIC_CODUCK_*`. `coduck env reserved` prints the authoritative list; see the
[`coduck.json` reference](/docs/reference/coduck-json#reserved-environment-variables).
`coduck env import` skips reserved/invalid keys with a warning instead of aborting.
## Custom domains
```bash
coduck domains list
coduck domains add example.com
coduck domains verify example.com
coduck domains remove example.com
coduck domains transfer example.com
```
## Database
```bash
coduck db schema # full schema as JSON
coduck db tables # list tables
coduck db tables --table users # read rows from a table
coduck db users # auth users (if using @coduckai/sdk/auth)
```
Read-only by design. No raw connection URL is exposed.
## Backups
```bash
coduck backups list
coduck backups create
coduck backups download --out backup.sql.gz
coduck backups restore --yes
coduck backups delete
```
## Email
```bash
coduck email status
coduck email domains list
coduck email domains add example.com
coduck email domains dns # reprint DNS records
coduck email domains verify
coduck email send --from noreply@example.com --to user@example.com \
--subject "Welcome" --text "Thanks." --html "Thanks.
"
coduck email usage # quota
coduck email messages # recent messages
coduck email suppressions list
coduck email suppressions remove
coduck email unpause # resume after auto-pause
```
## Storage
```bash
coduck storage list
coduck storage upload
coduck storage get --out local.bin
coduck storage remove
```
## Stripe (BYOS payments)
```bash
coduck stripe connect # print OAuth URL
coduck stripe status
coduck stripe disconnect --yes
coduck stripe payments stats
coduck stripe payments transactions
coduck stripe payments revenue --days 30
coduck stripe payments health
```
## Activity, analytics, forms
```bash
coduck activity --limit 100
coduck analytics --days 30
coduck forms list
coduck forms read
coduck forms delete
```
## Account + tokens
```bash
coduck whoami
coduck token status # plan, credits
coduck token list # CLI tokens on your account
coduck token revoke
coduck token show --confirm # print the JWT (refuses without --confirm)
```
## Discovery
```bash
coduck --help # human-friendly help
coduck --help --json # machine-readable spec (use this to build an MCP wrapper)
coduck version
coduck doctor # diagnose auth + config + connectivity
```
## Global flags
| Flag | What it does |
|---|---|
| `--json` | Force JSON output regardless of TTY |
| `--no-input` | Fail with exit 2 instead of prompting |
| `--quiet` | Suppress non-essential output |
| `--project ` | Override the `coduck.json` projectId for this command |
## Exit codes
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | Generic error |
| 2 | Usage error (bad flag, missing input under `--no-input`) |
| 3 | Authentication error |
| 4 | Not found |
| 5 | Conflict (e.g. payment required / state conflict) |
| 6 | Network error |
| 7 | Server error (5xx) |
## Next
- [Install the CLI](/docs/cli/install)
- [Authentication](/docs/cli/auth)
---
## coduck.json reference
Source: https://coduck.ai/docs/raw/reference/coduck-json.md
# coduck.json reference
`coduck.json` is the source of truth for how CoDuck builds and runs your project.
`coduck create-existing` writes it; you can edit it by hand. It is **re-read on
every deploy** — change a command, `coduck push`, `coduck deploy`, and the new
command runs. (Earlier behavior baked config at create-time; that is no longer
the case.)
```jsonc
{
"projectId": "ff0c35e6-…", // set by create-existing; don't change
"name": "my-app",
"dir": "./", // source root to push + run (see "Monorepos")
"runtime": "node20", // node20 | node22 | static
"install": "npm ci", // optional — default: npm install --include=dev
"build": "npm run build", // optional — default: npm run build
"preStart": "npm run migrate", // optional — runs after build, before start
"start": "node server.js", // optional — default: npm start
"port": 3000, // informational; bind process.env.PORT (see below)
"instanceSize": "small", // small | medium | large
"defaultEnv": "live" // optional — 'draft' | 'live' target for `coduck deploy`
}
```
## How each field drives the deploy
A deploy runs these steps in order, in your container:
1. **install** — your `install`, else `npm install --include=dev --no-audit --no-fund`.
(Dev deps are installed by default because build tools like Tailwind/PostCSS
live there. If you override with `npm ci`, note `NODE_ENV=production` is set, so
add `--include=dev` yourself if your build needs dev deps.)
2. **prisma generate** — only if `prisma/schema.prisma` exists *and* declares
`model`s. Skipped otherwise.
3. **build** — your `build`, else `npm run build`.
4. **schema bootstrap** — if `prisma/schema.prisma` declares models *and* you have
**no** `preStart`, CoDuck runs `prisma db push`. If you set `preStart`, CoDuck
does **not** auto-push — you own schema setup (see [Database](/docs/database/overview)).
5. **preStart** — your `preStart` (e.g. `prisma migrate deploy`, `drizzle-kit push`,
`node scripts/migrate.js`). The right place for migrations.
6. **start** — your `start`, else `npm start`.
**Skip a step** by setting it to `""` (empty string). E.g. a static/no-build app:
`"build": ""`.
## Ports — bind `process.env.PORT`
CoDuck assigns the port and injects it as `PORT`. **Your app must listen on
`process.env.PORT`**, not a hardcoded value. The `port` field in `coduck.json` is
informational only — if your app hardcodes `3000` but CoDuck health-checks the
assigned port, the deploy fails with "responding on :3000 but health-checking
: — bind process.env.PORT".
## Instance size
`instanceSize` (or `coduck deploy --size`) selects container resources. The CLI
flag wins; otherwise `coduck.json` is used; default `small`.
| Size | Memory | CPU | Plan required |
|---|---|---|---|
| `small` | 1.5 GB | 1.0 | any paid plan |
| `medium` | 2.5 GB | 2.0 | Pro or Studio |
| `large` | 4 GB | 3.0 | Studio |
A request above your plan is clamped down (and the deploy tells you). The Node
build-heap ceiling auto-scales to ~80% of the tier, so heavy client builds
(three.js, remotion, recharts) that OOM on `small` usually succeed on `large`.
## Draft vs live (`defaultEnv`)
If your project has a **draft** (a private dev environment — Plus/Studio; see the
[CLI commands](/docs/cli/commands)), `defaultEnv` sets what `coduck deploy` targets:
| `defaultEnv` | `coduck deploy` |
|---|---|
| unset (default) | **mirror-state** — updates your draft if one exists, else publishes live |
| `"draft"` | always updates your draft (promote separately) |
| `"live"` | always publishes to your live site |
An explicit `coduck deploy --live` / `--draft` overrides the config for one run.
## Monorepos / subdirectory source
`dir` can point at a subdirectory (e.g. `"./web"`) while `coduck.json` stays at the
repo root. The CLI uploads the repo-root `coduck.json` (and root
`.gitignore`/`.coduckignore`) alongside the subtree so the server still sees your
config. **This requires `@coduckai/cli` ≥ 0.1.11** — older CLIs pushing a subdir
silently omitted `coduck.json`, so declared commands were ignored. Run
`coduck --version` and upgrade if needed.
One CoDuck project = one container. For a separate frontend + backend, wrap them
in a single `start` (e.g. `concurrently`) or create two projects.
## Reserved environment variables
CoDuck injects these into every container and **rejects them on write** (setting
them has no effect — platform values win). The live, authoritative list is
`coduck env reserved`.
| Key / pattern | What it is |
|---|---|
| `DATABASE_URL` | Pooled Postgres connection string (see [Database](/docs/database/overview)). |
| `DIRECT_URL` | Direct (non-pooled) Postgres URL for migrations/`prisma db push`. |
| `PORT` | The port to listen on. Bind `process.env.PORT`. |
| `NODE_ENV` | Set to `production` in the container. |
| `HOME` | Container home dir. |
| `CODUCK_*` | All CoDuck-managed keys (`CODUCK_API_KEY`, `CODUCK_AUTH_KEY`, `CODUCK_PROJECT_ID`, `CODUCK_API_URL`, `CODUCK_STORAGE_DIR`, …). |
| `NEXT_PUBLIC_CODUCK_*` | Browser-exposed CoDuck values (project id, auth/api URLs, subdomain). |
Stripe keys (`STRIPE_SECRET_KEY`, `STRIPE_PUBLISHABLE_KEY`,
`NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY`) are injected **only when you connect
Stripe** — until then you may set them yourself.
`coduck env import .env` skips reserved/invalid keys with a warning and imports
the rest, so a `.env` containing `DATABASE_URL` won't abort the whole import.
## Next
- [Deploying](/docs/projects/deploy) — the deploy lifecycle + failure messages.
- [Import an existing project](/docs/projects/create-existing)
- [Database](/docs/database/overview) — the managed Postgres starts empty.
---
## Runtime architecture
Source: https://coduck.ai/docs/raw/reference/runtime.md
# Runtime architecture
This page describes the runtime environment a deployed project actually runs
in: the container, the network, the database connection, the filesystem. Use
it when you're reasoning about what `process.env.DATABASE_URL` connects to,
what `localhost` means inside your container, or what sits between your app
and Postgres.
## Container model
Each deployed project runs in its **own Docker container on CoDuck's VPS**.
One project, one container. The base image is Node (Node 20 by default; pick
another via `runtime` in [`coduck.json`](/docs/reference/coduck-json)). Your
code is bind-mounted at `/app` as the working directory, and the container
runs as a non-root user (uid `1001`, the image's `coduck` user).
Container resource caps (CPU, memory) come from the instance size — see
[Deploying → Instance size](/docs/projects/deploy#instance-size-resources)
for the table.
## Networking
Containers run with Docker's `--network=host`. The consequences are worth
spelling out, because they're different from the bridged-network mental
model most "sandboxed hosting" platforms use:
- **`localhost` inside your container is the VPS's loopback.** A socket to
`127.0.0.1:6432` from your app code is the same kernel socket as a socket to
`127.0.0.1:6432` from the host process. There is no NAT, no
`docker-proxy`, no userspace TCP shim.
- **No `-p host:container` mapping.** Your app binds the `PORT` it was
assigned directly on the host. nginx upstreams to that port for
`.coduck.app` traffic (and any [custom domain](/docs/domains/custom-domains)).
- **External egress** (calls to public services — your own external API,
Stripe, OpenAI, etc.) goes out the host's interface normally. Nothing
intercepts it.
When something in this environment looks like "a local proxy" — it isn't.
The only thing between your app and `127.0.0.1:` is the kernel's
loopback interface.
## Database connectivity
Two database env vars are injected on every deploy. Both are reserved
(you can't override them via `coduck env set` — see
[Environment variables](/docs/projects/deploy#environment-variables)):
| Env var | Points at | What it's for |
|---|---|---|
| `DATABASE_URL` | `postgres://…@127.0.0.1:6432/?pgbouncer=true&connection_limit=1` | **Runtime queries — all stacks.** The host:port is **PgBouncer**, running on the VPS in transaction-pool mode with server-side prepared statements enabled (`max_prepared_statements = 100`). Prisma reads `?pgbouncer=true` to disable its client-side prepared-statement caching; other clients (`node-postgres`, `pg`, `drizzle-orm`, `knex`, `sequelize`) just send prepared statements normally — PgBouncer caches them per backend. `connection_limit=1` keeps Prisma clients to one server connection per request. |
| `DIRECT_URL` | `postgres://…@127.0.0.1:5433/` | **Schema operations only.** `prisma db push` and `prisma migrate deploy` need the schema engine to talk directly to Postgres (their connection pattern doesn't match what the pool expects), so CoDuck routes those to a direct pooler-bypass URL. `127.0.0.1:5433` is the project's Postgres cluster bound directly to loopback. You should not use this URL for runtime queries — use `DATABASE_URL`. |
> [!WARNING]
> **Don't `DROP SCHEMA public CASCADE` on your project DB.** PgBouncer authenticates
> incoming connections by calling a `public.user_lookup()` function in your DB; if
> you drop and recreate `public`, that function (and the schema-level `USAGE` grant
> to `pgbouncer_auth`) goes with it. `DATABASE_URL` will start returning
> `bouncer config error` on every query until support restores them. Use
> `prisma migrate` / `drizzle-kit drop` etc. instead, which target your own tables
> without nuking `public`.
Both `6432` and `5433` are loopback-only — neither is reachable from outside
the VPS. That's why there's [no raw external connection URL](/docs/database/overview#why-theres-no-raw-connection-url).
PgBouncer's transaction-pool mode means a single client connection to `:6432`
is served by any of N backend Postgres connections, transparently and
per-transaction. That's why your **client-side pool should stay small**
(≤ 10) — opening many client connections doesn't help when PgBouncer is
already pooling on the server side, and oversized client pools waste
PgBouncer slots. See [Connection pooling](/docs/database/overview#connection-pooling).
## Filesystem
- **Working directory:** `/app`, bind-mounted from CoDuck's project store on
the host. Reads and writes both work — your build can write `node_modules`,
`.next/`, etc. and they persist across redeploys of the same project.
- **User:** `uid 1001` (`coduck`, non-root). `HOME` is set to `/tmp` so npm's
cache/lockfile machinery has somewhere to write without trying to touch
`/root`.
- **Restart policy:** `on-failure` with 2 retries. If your app crashes 3
times in a row, the container stays stopped and the deploy reports it —
redeploy to restart.
## Common questions this page answers
- **What does `process.env.DATABASE_URL` connect to?** → PgBouncer on
`127.0.0.1:6432` (transaction-pool mode), on CoDuck's VPS loopback. Works for
all stacks — Prisma, drizzle-orm, node-postgres, knex, sequelize.
- **Why is `localhost:5433` in my env (`DIRECT_URL`)?** → That's the
pooler-bypass connection used by Prisma's schema engine at deploy time. It's
not the runtime path.
- **Is `localhost` inside my container the same as `localhost` on the
host?** → Yes — `--network=host`.
- **Is there a proxy between my app and Postgres?** → PgBouncer (a connection
pooler, not a proxy in the security sense) sits on the host on `:6432`. The
network hop between your container and PgBouncer is a direct loopback
socket — no shim or proxy in addition to PgBouncer itself.
## Next
- [Deploying](/docs/projects/deploy) — instance sizes, deploy lifecycle, failure modes.
- [Database overview](/docs/database/overview) — schema, migrations, backups.
- [`coduck.json` reference](/docs/reference/coduck-json) — the per-project deploy config.
---
## Changelog
Source: https://coduck.ai/docs/raw/changelog.md
# Changelog
What's new in CoDuck, newest first. **Platform** changes (hosting, deploy, the
API, the web app) are live on `coduck.ai` / `api.coduck.ai` as soon as they
land. **CLI** changes ship in an `@coduckai/cli` release — run
`npm i -g @coduckai/cli@latest` to get them, and `coduck --version` to check
what you have. **SDK** changes ship in an `@coduck/auth` release — run
`npm i @coduck/auth@latest` in your project to upgrade.
> **Agents:** if a deploy behaves differently than you expect, scan the Platform
> section first — behavior may have changed. The machine-readable copy of this
> page is at [`/docs/raw/changelog.md`](https://coduck.ai/docs/raw/changelog.md),
> and it's indexed in [`/llms.txt`](https://coduck.ai/llms.txt).
## Platform — 2026-07-04
- **Form submissions no longer store visitors' raw IP addresses.** Submissions
to your hosted forms now record a daily-rotating anonymized visitor ID
instead of an IP — the same visitor gets the same ID within a day, so you can
still spot spam bursts in the Forms tab (shown as `visitor `), but no raw
end-user IP sits at rest. Previously stored IPs were scrubbed.
**Heads-up for deployed apps:** the `submitterIp` field returned by
`@coduck/sdk/forms` `list()` is renamed `submitterIpHash` — a site generated
earlier that displays that field will show it blank until you regenerate it
(the raw value no longer exists to serve).
- **Old raw data now expires automatically.** Raw analytics pageviews and
individual error occurrences are kept for 90 days (your charts and error
groups keep their history — those are built from aggregates that stay),
generation replay logs for 90 days (cost and usage stats stay forever), and
email send records for a year. Less stale personal data at rest by default.
- **Environment variables got a defense-in-depth upgrade.** Each stored env
var's ciphertext is now cryptographically bound to its exact project and key
— a ciphertext can never be replayed into another slot — and every decrypted
read is audit-logged (key names only, never values). Nothing to do on your
end; existing variables keep working.
- **Invite and transfer emails always link to the real app.** A server
misconfiguration could previously produce team-invite or project-transfer
accept links pointing to `localhost`; those links are now guaranteed to point
at `app.coduck.ai`.
## Platform — 2026-07-03
- **Transfer a project to another account.** You can now hand a whole project —
the live site, its database, custom domains, settings, and chat history — to
another CoDuck account. In the project's Cloud panel, open **Settings →
Danger Zone → Transfer project**, enter the recipient's email, and they get a
link to review and accept (they can also decline, and you can cancel any time
before they act). The site keeps running through the whole handoff — nothing
restarts. A project with a live deployment needs the recipient to be on a
paid plan; if the project has a connected Stripe account, it moves with it,
so disconnect first if it shouldn't. Perfect for handing a finished build to
a client or moving work between your own accounts.
- **`www.` works on your custom domain.** Adding an apex domain like
`example.com` now covers `www.example.com` too — the SSL certificate includes
the www variant and www visitors are redirected to your apex, once the `www`
DNS record shown in the add-domain panel is in place. Domains added earlier
get an **Enable www** button (or run `coduck domains verify`) to switch it on.
- **Team activity is visible.** Invites, joins, role and spend-limit changes,
and team renames/deletes now show up in the project's Activity tab, so you
can see who did what on a shared project.
- **Opening a project is fast now.** The editor used to freeze for 30–90
seconds on open while your preview environment booted. It now loads in
about a second — your chat, files, and Cloud panel appear immediately, and
only the preview pane shows a brief "Starting…" while the environment spins
up in the background. Already-published projects show their live site
instantly, as before.
- **Teammates can now open and edit shared projects.** The full collaboration
release: invite someone to your team and — depending on their role — they can
open the project, follow logs and analytics, generate and edit alongside you,
and (for admins) publish and manage settings. **The team owner pays**: all
generation by teammates draws from the owner's credits, never the member's,
and owners can set a **monthly spend limit per member** from the Team tab.
Owners can also **delete a team** (Danger zone) — members lose access and the
project goes back to personal. This completes the rollout previewed in the
2026-07-02 entry below.
## Platform — 2026-07-02
- **Teams — invite people to your project.** Every project's Cloud panel now has
a **Team** tab: create a team, invite teammates by email, and manage who's on
the project with roles — Owner / Admin / Editor / Viewer, or **custom roles**
with exactly the permissions you pick. Invitees get an email with an accept
link: log in (or sign up) with the invited address and you're on the team.
Pending invites show right in the member list, with one-click resend or
cancel. Team seats are included with your plan (Pro 3 · Plus 10 · Studio 25).
*This release ships team setup and membership — teammates opening and editing
the project is rolling out next, so hold off on inviting collaborators who
need editor access today.*
## CLI 0.1.13
- **`coduck push` now updates your draft instantly.** If your project has a draft,
`push` uploads your files and hot-reloads them into the running draft in about a
second (it auto-wakes the draft if it's asleep) — your live site stays untouched.
Copy tweaks and code changes feel like a local dev server. Use `coduck push --prod`
to go straight to live, and the new `coduck wake` to pre-warm your draft so the first
push is instant too. Update with `npm i -g @coduckai/cli@latest`.
## CLI 0.1.12
- **Draft → publish, from the command line.** New `coduck draft` commands drive a
private draft (dev environment): `create`, `update` (build & run your current
code), `status`, `promote` (publish to live), and `delete`. And `coduck changes`
shows exactly what a publish will change — the per-file diff and any database
schema additions or removals — before you run it.
- **`coduck deploy` is draft-aware.** If your project has a draft, `deploy` updates
it by default (your live site is untouched — run `coduck draft promote` when
you're ready); with no draft it publishes live, as before. Control it per run with
`--live` / `--draft`, or set `"defaultEnv"` in `coduck.json`. Drafts are a
Plus/Studio feature. Update with `npm i -g @coduckai/cli@latest`.
## Platform — 2026-06-21
- **Dev environments are here (Plus & Studio).** Your project can now have a
private development environment — a test copy of your site with its own
database and its own live preview, completely separate from production. In the
editor, switch from "Production" to "Development", try changes against the dev
copy (its data never touches your live site), and publish when you're happy.
The dev preview is private — only you can open it, through a secure link in the
editor. Free and Pro projects are unaffected.
## Platform — 2026-05-26
- **Settings → Billing shows your plan + credit burn rate.** The top of
the billing panel now displays "Your plan: Pro / Plus / Studio" (or
"Free — not subscribed"), and the credits line shows "$5.00 / $20.00
this month" so you can see how much of your monthly allowance is
left. Top-up balance is shown separately because it doesn't have a
monthly cap and never expires.
- **The pricing page now knows what plan you're on.** When you're signed
in and subscribed, your plan card shows a "Current" badge and its
button is disabled with "Current plan" text. The other paid cards
relabel as "Upgrade to X" or "Downgrade to X" so the action you're
about to take is obvious before you click.
- **Pricing page layout cleanup.** Pro / Plus / Studio now sit in their
own three-column row as the self-serve options, with Enterprise
broken out as a slim "Contact sales" row beneath. Each of the three
main plan cards has more room to breathe, and Enterprise no longer
looks like a fourth equal-weight option.
- **Switching plans now actually works for existing subscribers.**
Previously, clicking any plan card on the pricing page or in Settings →
Billing while you were already subscribed silently failed (the request
came back as "Already subscribed"). The buttons now route you to the
Stripe customer portal — the right place to switch up or down, change
your card, or cancel — and the click goes through immediately.
- **Settings → Billing buttons now say "Upgrade ↑" or "Downgrade ↓"**
depending on whether the plan you're clicking is above or below your
current one. Previously they all said "Upgrade" regardless, so a
Studio user looking at the Plus card was told to "upgrade" to a
cheaper plan.
- **Settings → Billing no longer shows a "Free" plan card.** CoDuck's
hosting is paid-only — a free account can't deploy a project at all
— so listing Free as a "plan" next to Pro/Plus/Studio was misleading.
The billing page now shows just the three real plans you can
subscribe to. If you're not subscribed, no plan card is highlighted
as your current one (the Credits remaining panel above still shows
your true balance).
- **New Plus plan ($100/mo or $1,000/yr).** A middle tier between Pro and
Studio for builders shipping more than they thought. Plus gets $100 of
AI credits per month, Lake hosting (1 GB database), and a 15,000-emails-
per-month send limit — slotting cleanly between Pro (Pond / 100 MB / 5k
emails) and Studio (Ocean / 5 GB / 50k emails). Annual billing saves
$200/year (2 months free).
- **Pricing cards now list what you actually get.** Every plan card on the
pricing page and in Settings → Billing now shows credits, hosting tier
name, database size, monthly email-send cap, and key features — instead
of a one-line tagline. The numbers are the same values the platform
enforces, so what you see on the card is what you get.
- **Settings → Billing "Top up credits" section refreshed.** Clearer
heading and description so it's obvious that top-up credits stack on
top of your monthly subscription and are spent first. Each amount
button now shows the credit value ("$20 credits") rather than the
generic "one-time" caption. Plus subscribers can top up too, not just
Pro and Studio.
- **Billing page in Settings now lets you upgrade to Studio.** The Studio
plan ($200/mo — same product as Pro, 10× the runway) is now visible
alongside Free and Pro under Settings → Billing. Clicking **Upgrade →** on
either Pro or Studio goes straight to a Stripe Checkout for that plan.
- **Add Credits buttons in Settings → Billing fixed.** The top-up grid now
shows **$5 / $20 / $50 / $100** and each one works — previously the
buttons offered amounts CoDuck didn't accept, so clicks failed silently.
Studio subscribers can now top up too (it used to be Pro-only).
- **Out-of-credits modal: top-up buttons fixed.** When you run out of
credits mid-build, the four quick-top-up buttons inside the paywall
modal ($5 / $20 / $50 / $100) now correctly open Stripe Checkout — they
were previously hitting a route that didn't exist and 404'ing. The
"Subscribe to CoDuck Pro" button next to them was unaffected.
- **`DATABASE_URL` now works for every Postgres client, not just Prisma.**
Before today, apps using `node-postgres`, `pg`, `drizzle-orm`, `knex`, or
`sequelize` would hit `bouncer config error` when trying to query through
`DATABASE_URL` (the pooled path at `127.0.0.1:6432`) and had to fall back to
`DIRECT_URL` — which has no server-side pool, so bursty traffic could
exhaust it. PgBouncer is now configured with server-side prepared statements
enabled, so prepared-statement-using clients work on the pooled path
alongside Prisma. **Use `DATABASE_URL` for runtime queries regardless of
stack;** `DIRECT_URL` is only for `prisma db push` / `prisma migrate deploy`.
- **New runtime docs page:** [Runtime architecture](/docs/reference/runtime)
documents the container model, `--network=host` networking, exactly what
host:port `DATABASE_URL` and `DIRECT_URL` point at, and a `[!WARNING]`
about a footgun — **don't run `DROP SCHEMA public CASCADE` on your project
DB.** That command destroys the `public.user_lookup()` function PgBouncer
needs for connection auth (and the `USAGE` grant on the schema). If you've
already done it and you're seeing `bouncer config error`, contact support to
restore it.
## Platform — 2026-05-25
- **`coduck.json` is honored on every deploy.** Your `install`, `build`,
`preStart`, and `start` commands are re-read from `coduck.json` on each deploy
and run as declared — previously the container always ran a hardcoded
`npm install` → `npm run build` → `npm start`. Notes:
- `preStart` runs after build, before start — the right place for DB migrations
(e.g. `prisma migrate deploy`). Declaring it also disables CoDuck's automatic
`prisma db push`, so you own schema setup.
- Set any command to `""` to skip that step (e.g. `build: ""` for a no-build app).
- Monorepo note: this only takes effect once your CLI delivers `coduck.json` to
the server — see the CLI 0.1.11 entry. Older CLIs pushing a subdirectory did
not upload the repo-root `coduck.json`.
- **Specific deploy-failure messages.** A failed deploy now tells you the cause
instead of one generic "crashed before becoming healthy":
- out of memory → "retry on a bigger instance: `coduck deploy --size large`"
- build failed → fix the error and redeploy
- wrong port → "bind the port CoDuck assigns — use `process.env.PORT`"
- crashed after start → check `coduck logs`
- **Faster reinstalls for imported apps.** Projects with no `@coduck/*`
dependency now reuse the cached `node_modules` across deploys instead of a full
reinstall every time (the cache-bust only runs for projects that use the CoDuck
SDK).
- **Instance sizes.** `coduck deploy --size small|medium|large` (or
`instanceSize` in `coduck.json`) selects more build/runtime RAM + CPU;
medium/large require a Pro/Studio plan. The Node build-heap ceiling now uses the
container's full RAM, fixing out-of-memory builds for heavy client bundles
(three.js, remotion, recharts, …).
- **Reserved env keys.** The set of keys CoDuck manages (`DATABASE_URL`, `PORT`,
`NODE_ENV`, `CODUCK_*`, …) is complete and rejected clearly on write. List them
with `coduck env reserved`. The managed Postgres starts empty — reach it at
`DATABASE_URL`/`DIRECT_URL` and bootstrap your schema in `build` or `preStart`.
## CLI — Unreleased (0.1.11)
Merged; ships on the next `@coduckai/cli` publish.
- **Monorepo `coduck.json` delivery.** A subdirectory push (`dir: "./web"`) now
uploads the repo-root `coduck.json` to the server, so the platform's
deploy-config honoring (above) actually applies to monorepo layouts. Repo-root
`.gitignore`/`.coduckignore` are honored for subdir pushes too.
- **`coduck env import` no longer aborts on the first reserved key** — it skips
reserved/invalid keys with a warning and imports the rest. New `coduck env
reserved` lists managed keys.
- **`push` honors `.gitignore`** (plus sensible defaults: `node_modules`,
`.venv`, build output, caches). `push --dry-run` prints a size summary +
biggest dirs instead of a full file manifest.
- **Resilient push.** `push` auto-retries transient network errors; `deploy`
warns when your last push failed or local files changed since it.
- **Logs filters.** `coduck logs --since <30m|1h|…>` and `--grep `.
- **`coduck --version`** reads the installed package version correctly (no longer
under-reports).
## CLI 0.1.10
- `coduck deploy --size` and `coduck.json` `instanceSize` for instance-tier
selection.
## CLI 0.1.9
- Chunked `push` for large projects (no more 413s) and `.coduckignore` support.
## CLI 0.1.8
- `coduck db import ` — upload a SQL dump to the project database.
## CLI 0.1.7
- Real `coduck push` and `create-existing --push --deploy`; fixed `coduck logs`.
- Browser-based device login (`coduck login`) — the CLI never sees your password.
---
## CoDuck vs Base44
Source: https://coduck.ai/docs/raw/compare/base44.md
# CoDuck vs Base44
> Base44 shares CoDuck's batteries-included instinct — CoDuck goes further on ownership. Base44 (now part of Wix) bundles a backend and auth, but you're building inside a closed platform. CoDuck gives you real, exportable Next.js code, payments through your own Stripe account, email from your own domain, and a CLI your AI agents can drive.
Base44 is an AI app builder — acquired by Wix in 2025 — that turns plain-English prompts into hosted apps with a built-in database, auth, and integrations, aimed squarely at non-coders.
## Feature by feature (July 2026)
| Capability | CoDuck | Base44 |
|---|---|---|
| Email sending | ✅ Built in — To anyone, from your domain (5k/mo on Pro) | ⚠️ Partial / via 3rd party — Built-in SendEmail reaches registered app users only; external email via Resend integration |
| Payments | ✅ Built in — Your Stripe account via Stripe Connect — CoDuck takes no cut | ✅ Built in — Your Stripe account; plug-and-play sandbox, needs a paid tier with backend functions |
| Ops dashboard (logs / analytics / backups) | ✅ Built in — Logs, analytics, backups, forms inbox built in | ⚠️ Partial / via 3rd party — Built-in analytics + app logs; backups not documented |
| CLI / agent automation | ✅ Built in — @coduckai/cli covers everything the app does | ⚠️ Partial / via 3rd party — base44 CLI covers backend projects/functions, not the full builder |
| Database | ✅ Built in — Dedicated Postgres per project | ✅ Built in — Built-in entity database, hosted on Base44 |
| User auth | ✅ Built in — Built-in, pre-wired | ✅ Built in — Built-in login, roles and permissions |
| Hosting + SSL | ✅ Built in — Managed, included in every plan | ✅ Built in — Managed hosting included |
| Custom domains | ✅ Built in — All plans, SSL automatic | ✅ Built in — Paid plans only (as of mid-2026); free tier can't connect a domain |
| Full-stack app generation | ✅ Built in — Real Next.js codebase from a prompt | ✅ Built in — UI, data model, logic and hosting from a prompt |
| Code export / ownership | ✅ Built in — Full Next.js codebase, runs anywhere | ⚠️ Partial / via 3rd party — Frontend exports; backend stays on Base44 via its SDK |
| GitHub sync | ⚠️ Partial / via 3rd party — Import only — no two-way sync | ✅ Built in — Two-way sync on paid plans |
| Free tier / entry price | ❌ Not offered — Starts at Pro $20/mo (includes $20 usage credits) | ✅ Built in — Free: 25 message credits/mo, up to 5 apps; paid from $16/mo annual |
## Where CoDuck is stronger
- You own the whole stack: a standard Next.js codebase plus a dedicated Postgres database per project — export it and run it anywhere, no proprietary SDK in the middle
- Transactional email to any recipient, from your own domain, included (Base44's built-in email only reaches your app's registered users)
- Payments through your own Stripe account with no platform cut and no extra wiring
- One flat bill with predictable usage credits — no separate 'integration credits' that your users burn down as they use your app
- Agent-first CLI (@coduckai/cli) that can do everything the web app does — create, push, deploy, manage databases and domains from scripts or AI agents
- Ops built in: logs, analytics, backups and a forms inbox in one dashboard
## Where Base44 is stronger
- A real free tier — 25 message credits a month and up to 5 apps, enough to genuinely try the product before paying
- Cheaper entry point: paid plans start at $16/mo (annual) or $20/mo monthly
- Two-way GitHub sync on paid plans, so technical users can edit locally and stay in sync
- Extremely beginner-friendly all-in-one flow — database, auth, analytics and Stripe sandbox appear without any setup
- Wix's backing: acquired for a reported $80M in 2025, so it has resources and a large parent company behind it
## Choose Base44 if…
- You want to try building for free before spending anything — CoDuck has no free tier, Base44 does
- You want the lowest paid entry price ($16–20/mo vs CoDuck's $20 minimum with fewer bundled limits at that tier)
- Two-way GitHub sync matters to you — CoDuck only imports from GitHub today
- You're already in the Wix ecosystem or value a big-company parent over a small independent team
- You're building internal tools or prototypes where platform lock-in doesn't matter
## Choose CoDuck if…
- You want to own and export the entire app — frontend, backend and a real Postgres database — with no runtime dependency on the builder's servers
- Your app needs to email people who aren't registered users (receipts, outreach, notifications) from your own domain, without adding a third-party email service
- You're selling something and want payments in your own Stripe account with zero platform cut
- You (or your AI agent) want to automate builds and deploys from the command line
- You'd rather pay one flat monthly bill than track message credits and per-action integration credits
## Pricing
Base44 has a free tier (25 message credits and 100 integration credits per month, up to 5 apps) and, as of July 2026, four paid tiers from $16/mo (Starter, billed annually; $20 monthly) to $160/mo (Elite), metered in two currencies: message credits for AI builds and integration credits consumed as your users trigger actions like emails or file uploads — credits expire monthly and don't roll over. CoDuck has no free tier but a simpler model: Pro $20/mo, Plus $100/mo, Studio $200/mo, each bundling matching AI usage credits ($20/$100/$200) plus hosting, a Postgres database, custom domains and email on every plan — so a growing app's runtime activity doesn't eat your build budget.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Base44 to CoDuck
1. Export what you can from Base44 (ZIP or GitHub export on paid plans — note this covers the frontend; your data and backend logic live on Base44's platform)
2. Download your data from the Base44 dashboard (export your entities/records as CSV or JSON)
3. Create a CoDuck project and describe your app — or import your exported frontend from GitHub — and CoDuck rebuilds it as a real Next.js app with its own Postgres database
4. Import your data into the project's Postgres database and reconnect your Stripe account and email domain in the CoDuck dashboard
5. Point your custom domain at CoDuck (SSL is automatic) and retire the Base44 app once traffic is switched
## FAQ
### Is CoDuck better than Base44?
Neither is strictly better. Both generate full-stack apps with database, auth and hosting from a prompt. CoDuck is better if you want to own the code and data — it produces a standard Next.js app on a dedicated Postgres database you can fully export — plus email to any recipient and an agent-friendly CLI. Base44 is better if you want a free tier, a lower entry price, and two-way GitHub sync inside an all-in-one managed platform.
### Can I export my code from Base44?
Partially. On paid plans Base44 lets you export code via ZIP or GitHub, but the export covers the frontend — the database, auth and backend logic remain on Base44's servers, accessed through the Base44 SDK. CoDuck exports the complete app: a standard Next.js codebase plus your Postgres data, runnable anywhere.
### Does Base44 have a real database?
Yes — Base44 has a built-in entity database that its AI sets up for you, and it works well. The difference is where it lives: Base44's database is hosted inside its platform, while CoDuck provisions a dedicated Postgres database per project that you can query directly and take with you.
### Can Base44 send emails?
Yes, with a significant limit: Base44's built-in SendEmail only delivers to people who are registered users of your app. To email external recipients you need to add an integration like Resend. CoDuck includes transactional email to any address, sent from your own domain, on every plan (5,000/mo on Pro).
### Does Base44 have a free plan? Does CoDuck?
Base44 does: 25 message credits and 100 integration credits per month, with up to 5 apps (no custom domain). CoDuck does not have a free tier — plans start at Pro, $20/mo, which includes $20 of AI usage credits, hosting, a Postgres database, custom domains and email. If you want to experiment for free, Base44 wins this one.
### Can I use my own Stripe account with Base44 or CoDuck?
Both. Base44 has a plug-and-play Stripe integration with an instant test sandbox; going live means connecting your own Stripe account, and it requires a paid tier with backend functions. CoDuck wires payments to your own Stripe account via Stripe Connect on any plan, and CoDuck takes no cut of your revenue.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/base44*
---
## CoDuck vs Bolt
Source: https://coduck.ai/docs/raw/compare/bolt.md
# CoDuck vs Bolt
> Bolt gets you from prompt to prototype fast — CoDuck gets you from prompt to a running product. Bolt's in-browser build experience is genuinely slick and its free tier is great for tinkering, but the database is Supabase-backed and the after-launch story is thin. CoDuck includes Postgres, auth, email, your-own-Stripe payments, domains, and an ops dashboard with logs and backups — the parts a real product actually lives on.
Bolt (bolt.new) is StackBlitz's AI app builder that generates and runs full-stack web apps directly in the browser, with built-in databases, auth, hosting, and domains under Bolt Cloud.
## Feature by feature (July 2026)
| Capability | CoDuck | Bolt |
|---|---|---|
| Email sending | ✅ Built in — Transactional email from your domain, included (5k–50k/mo by plan) | ⚠️ Partial / via 3rd party — Via Resend integration — bring your own API key and verified domain |
| Payments | ✅ Built in — Your own Stripe account wired in via Stripe Connect — CoDuck takes no cut | ⚠️ Partial / via 3rd party — Guided Stripe setup with your API key (works with Bolt Database or Supabase) |
| Ops dashboard (logs, analytics, backups) | ✅ Built in — Logs, analytics, backups, forms inbox, activity — built in | ⚠️ Partial / via 3rd party — DB logs + user management; no unified analytics/backups view |
| CLI / agent automation | ✅ Built in — @coduckai/cli on npm — create, push, deploy, db, domains | ❌ Not offered — Browser-only; no official CLI as of mid-2026 |
| Database | ✅ Built in — Managed Postgres per project, created automatically | ⚠️ Partial / via 3rd party — Bolt Database (Supabase-backed), or connect your own Supabase |
| User auth | ✅ Built in — Built-in auth, pre-wired into generated apps | ✅ Built in — Bolt Database auth incl. Google SSO + email templates |
| Hosting + SSL | ✅ Built in — Managed hosting included on every plan | ✅ Built in — Bolt Hosting; request caps per plan (333K free / 1M Pro) |
| Custom domains | ✅ Built in — Included on all plans, SSL automatic | ✅ Built in — Pro ($25/mo) and up; buy or connect via Bolt Domains |
| Full-stack app generation | ✅ Built in — Real Next.js codebase, deployed live from one prompt | ✅ Built in — In-browser agent (Claude-powered), runs code instantly via WebContainers |
| Code export / ownership | ✅ Built in — Readable Next.js code, export anytime | ✅ Built in — ZIP download + push to GitHub |
| GitHub sync | ⚠️ Partial / via 3rd party — Import only — no two-way sync yet | ✅ Built in — Connect, push, and import repos |
| Free tier / entry price | ❌ Not offered — Paid from $20/mo, includes $20 AI credits + hosting | ✅ Built in — Free: 1M tokens/mo (300K/day), Bolt branding |
## Where CoDuck is stronger
- Everything is pre-wired on one bill: database, auth, email from your own domain, and payments through your own Stripe account work without connecting or paying for any third-party service
- Built-in ops dashboard — logs, analytics, backups, and a forms inbox — so a non-technical founder can actually run the app after launch
- Agent-first CLI (@coduckai/cli): everything the web app does is scriptable, so your own AI agents can create, push, and deploy projects
- Deploy-first by design: a prompt becomes a live URL with a real Postgres database in minutes, and custom domains are included on every plan
- Flat, predictable pricing — plans include usage credits, hosting, database, email, and domains, with no token math
## Where Bolt is stronger
- A genuinely usable free plan — 1M tokens a month with hosting and unlimited databases, no credit card required
- Now natively full-stack: Bolt Database (auth, edge functions, storage, user management) plus Bolt Hosting and Domains, no third-party backend required
- Instant in-browser dev environment (StackBlitz WebContainers) — code runs as it's generated, with no local setup
- Real GitHub integration: push projects to a repo and import existing ones
- Builds mobile apps via the Expo integration and imports designs from Figma — surfaces CoDuck doesn't cover
## Choose Bolt if…
- You want to experiment for free before spending anything — Bolt's free tier is real and CoDuck has none
- You're building a mobile app: Bolt's Expo integration ships iOS/Android apps, which CoDuck doesn't do
- Your workflow lives in GitHub — Bolt pushes to and imports from repos, while CoDuck only imports
- You already use Supabase or Resend and are comfortable wiring API keys between services
- You're designing in Figma and want to import those designs directly into generated UI
## Choose CoDuck if…
- You want email, payments, and a custom domain working on day one without creating Resend, Supabase, or hosting accounts on the side
- You're a non-technical founder who needs to operate the app after launch — logs, analytics, backups, and form submissions in one dashboard
- You (or your AI agents) want to automate builds and deploys from the terminal with a real CLI
- You'd rather pay one flat monthly price with credits included than track token consumption across iterations
- You're launching a revenue-generating site and want your own Stripe account wired in with no platform cut
## Pricing
The models differ more than the numbers. Bolt (as of July 2026) is token-based: a free plan with 1M tokens per month (300K/day cap), Pro at $25/mo with at least 10M tokens plus rollover and custom domains, and Teams at $30/member — heavy iteration consumes tokens, so costs track how much you prompt. CoDuck has no free tier but prices flat: Pro at $20/mo includes $20 of AI usage credits plus hosting, a Postgres database, custom domains, and 5k emails/mo, with Plus ($100) and Studio ($200) scaling credits, database size, and email volume. Bolt is cheaper to try; CoDuck is easier to predict once you're actually shipping.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Bolt to CoDuck
1. Export your project from Bolt: click the project title → Export → Download for a ZIP, or push it to GitHub first
2. Create a CoDuck project and bring the code in — import the GitHub repo, or push the exported files with `coduck push` from the CLI
3. Recreate your schema in CoDuck's per-project Postgres and migrate your data (export from Bolt Database or Supabase, import via `coduck db`)
4. Swap third-party wiring for built-ins: replace Supabase auth calls with CoDuck auth, Resend calls with CoDuck email, and reconnect your own Stripe account via CoDuck's Stripe Connect flow
5. Connect your custom domain in CoDuck (SSL is automatic) and update DNS to cut over
## FAQ
### Is CoDuck better than Bolt?
Neither is strictly better. Bolt is stronger for free experimentation, GitHub-centric workflows, and mobile apps via Expo. CoDuck is stronger for running a production app: email from your domain, payments via your own Stripe account, an ops dashboard, and a CLI come pre-wired on one flat bill. Pick based on whether you're exploring or launching.
### Does Bolt have a real database?
Yes. As of 2026, Bolt Database is built in — projects get databases automatically, with auth, edge functions, file storage, and user management — and Supabase remains an option. CoDuck also provisions a managed Postgres database per project natively.
### Can Bolt send emails from my app?
Yes, but through an integration: you connect a Resend account, add your API key, and verify your own domain with Resend to email real users. CoDuck sends transactional email from your domain out of the box (5,000–50,000 emails/mo depending on plan), with nothing extra to sign up for.
### Does CoDuck have a free plan like Bolt?
No. Bolt has a genuine free tier (1M tokens/month with hosting and Bolt branding). CoDuck starts at $20/mo, which includes $20 of AI credits, hosting, a Postgres database, custom domains, and email. If you want to tinker for free, Bolt wins; CoDuck is priced for people shipping something real.
### Can I export my code from Bolt or CoDuck?
Both. Bolt exports a ZIP of your full project and can push to GitHub. CoDuck generates a real Next.js codebase you can read and export anytime. Note the GitHub difference: Bolt supports push and import, while CoDuck currently supports import only — no two-way sync.
### Can I automate Bolt from the terminal or with an AI agent?
Not officially — Bolt is browser-based with no official CLI as of mid-2026 (community browser extensions exist). CoDuck ships @coduckai/cli on npm, which covers everything the web app does — create, push, deploy, database, and domain commands — so scripts and AI agents can drive it end to end.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/bolt*
---
## CoDuck vs Bubble
Source: https://coduck.ai/docs/raw/compare/bubble.md
# CoDuck vs Bubble
> Bubble is the no-code veteran; CoDuck is what the same idea looks like in the AI era. Bubble's visual editor is deep and battle-tested, but apps stay locked to its proprietary runtime — there's no real code to take with you. CoDuck builds actual Next.js you own, from a sentence, with the database, auth, email, and payments already running.
Bubble is a visual no-code platform from Bubble Group (New York, founded 2012) where you build web and mobile apps in a drag-and-drop editor — now with an AI App Generator that scaffolds pages, workflows, and a database from a prompt.
## Feature by feature (July 2026)
| Capability | CoDuck | Bubble |
|---|---|---|
| Email sending | ✅ Built in — From your domain, SES-backed, 5k+/mo included | ⚠️ Partial / via 3rd party — Shared SendGrid has deliverability limits; own SendGrid/Postmark recommended |
| Payments | ✅ Built in — Your own Stripe account via Connect; CoDuck takes no cut | ⚠️ Partial / via 3rd party — Official Stripe plugin; you configure it yourself |
| Ops dashboard (logs, analytics, backups) | ✅ Built in — Logs, analytics, backups, forms inbox built in | ⚠️ Partial / via 3rd party — Server logs/backups ~2 days on Starter, ~14 on Growth; analytics via plugins |
| CLI / agent automation | ✅ Built in — @coduckai/cli — create, push, deploy, db, domains | ❌ Not offered — Data/Workflow APIs exist; no CLI, editor isn't scriptable |
| Database | ✅ Built in — Real Postgres per project | ✅ Built in — Built-in proprietary DB; no direct SQL access |
| User auth | ✅ Built in — Built-in, pre-wired into generated apps | ✅ Built in — Built-in user system with login workflows |
| Hosting + SSL | ✅ Built in — Managed, included in every plan | ✅ Built in — Managed AWS hosting; SSL on paid plans |
| Custom domains | ✅ Built in — All plans, auto-SSL, www handled | ⚠️ Partial / via 3rd party — Paid plans only (Starter and up) |
| Full-stack app from a prompt | ✅ Built in — Writes a real Next.js codebase, deploys live in minutes | ✅ Built in — AI App Generator builds pages, workflows, DB in the visual editor |
| Code export / ownership | ✅ Built in — Real Next.js code, readable and exportable | ❌ Not offered — No source export; apps run only on Bubble's runtime |
| GitHub sync | ⚠️ Partial / via 3rd party — Import a repo; no two-way sync yet | ❌ Not offered — GitHub only for plugin dev; apps use Bubble's own version control |
| Free tier / entry price | ❌ Not offered — No free tier; Pro $20/mo all-in | ⚠️ Partial / via 3rd party — Free plan to build/learn, can't deploy live; live from $29/mo annual |
## Where CoDuck is stronger
- You own real Next.js code you can read, export, and take anywhere — no platform lock-in on the runtime
- Flat, predictable pricing: hosting, Postgres, auth, email, and custom domains in one $20/mo bill — no workload-unit math
- Payments run through your own Stripe account (Stripe Connect) with CoDuck taking no cut
- Transactional email from your own domain is built in, not a plugin you wire to SendGrid
- Agent-first CLI (@coduckai/cli): everything the app does is scriptable, so AI assistants can build and deploy for you
## Where Bubble is stronger
- Mature, battle-tested platform (since 2012) with a huge community, template marketplace, and thousands of plugins
- Genuinely visual: non-technical builders can inspect and change any page, workflow, or database field without ever seeing code
- Free plan lets you build and learn the full editor before paying anything
- Handles complex internal logic — multi-step workflows, permissions, recurring jobs — entirely in the visual editor
- Built-in version control with branches (Growth+) and one-click savepoints/restore designed for non-developers
## Choose Bubble if…
- You want to build and modify everything visually and never look at code — Bubble's editor is the most mature in no-code
- You need a free tier to learn and prototype before spending anything
- Your app is heavy on complex internal workflows (admin tools, marketplaces, multi-role permissions) that Bubble's workflow engine models well
- You value a large ecosystem: templates, plugins, certified agencies, and a decade of community answers
- You're building native mobile apps — Bubble ships dedicated mobile plans with native iOS/Android output
## Choose CoDuck if…
- You want to own and export the actual source code — Bubble apps cannot leave Bubble without a rebuild
- You'd rather describe the app in plain English and iterate by chat than assemble it screen-by-screen
- You want one flat bill instead of estimating workload units — Bubble overages bill per extra 1,000 WUs
- You (or your AI assistant) want to automate builds and deploys from the command line
- You care about real-web performance and SEO — a generated Next.js site is standard, crawlable web tech
## Pricing
Bubble prices by capacity: a free plan lets you build and learn but can't deploy a live app, and going live starts at $29/mo billed annually ($32 monthly) for the Starter web plan with a custom domain and 175,000 workload units — Bubble's usage metric that every page load, workflow, and database operation consumes, with overages billed per extra 1,000 units (Growth is $119/mo annual, Team $349/mo, and mobile plans cost more, as of July 2026). CoDuck has no free tier but prices flat: Pro is $20/mo including hosting, a real Postgres database, auth, custom domains, 5k emails, and $20 of AI generation credits, with Plus ($100) and Studio ($200) scaling those limits — so a successful Bubble app's bill grows with traffic, while a CoDuck bill mainly grows with how much AI generation you use.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Bubble to CoDuck
1. Export your data from Bubble: download each data type as CSV from the App Data tab (or pull it via Bubble's Data API) — note that app logic and pages can't be exported, only data
2. Describe your app to CoDuck in a prompt — pages, user roles, and core flows; CoDuck generates a real Next.js app with Postgres, auth, and hosting already wired
3. Import your CSV data into the project's Postgres database (via the built-in DB tools or `coduck db` from the CLI)
4. Rebuild integrations the native way: connect your own Stripe account for payments and verify your domain for built-in email — both are first-party, not plugins
5. Point your custom domain at CoDuck (SSL is automatic), test the live app, then cancel your Bubble subscription
## FAQ
### Is CoDuck better than Bubble?
Neither is strictly better. Bubble is better if you want a mature visual editor, a free plan, and a huge plugin ecosystem, and you're fine with your app living permanently on Bubble. CoDuck is better if you want to describe your app in plain English, get real Next.js code you can export, and pay one flat monthly bill instead of usage-based workload units.
### Can you export code from Bubble?
No. Bubble does not allow source-code export — you own your data, design, and content, but the app runs only on Bubble's runtime. Leaving Bubble means rebuilding the app elsewhere. CoDuck generates a standard Next.js codebase you can read and export.
### Does Bubble have a real database?
Bubble has a capable built-in database, but it's proprietary — you manage it through Bubble's editor and APIs, not direct SQL. CoDuck provisions a real Postgres database per project that you can query and export directly.
### Is Bubble free to use?
Bubble has a genuinely useful free plan for learning and prototyping (about 50,000 workload units/month as of mid-2026), but it can't deploy a live app or use a custom domain — going live starts at $29/mo billed annually. CoDuck has no free tier; its Pro plan is $20/mo with hosting, database, email, and custom domains included.
### Can Bubble send transactional email and take payments?
Yes, with setup. Bubble's default email goes through a shared SendGrid service with known deliverability limits, so most production apps connect their own SendGrid or Postmark account; payments use Bubble's official Stripe plugin that you configure. CoDuck ships both pre-wired: email from your own domain (SES-backed) and payments through your own Stripe account, with CoDuck taking no cut.
### Which is cheaper, CoDuck or Bubble?
For a live app, CoDuck's $20/mo Pro plan undercuts Bubble's $29–32/mo Starter, and CoDuck's flat pricing doesn't grow with traffic the way Bubble's workload units do. But Bubble's free plan is cheaper for pure prototyping, and heavy AI generation on CoDuck consumes usage credits — so a build-heavy month on CoDuck can cost more than a quiet month on Bubble.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/bubble*
---
## CoDuck vs Durable
Source: https://coduck.ai/docs/raw/compare/durable.md
# CoDuck vs Durable
> Durable wins the 30-second website race; CoDuck wins everything after. For an instant local-business page, Durable is genuinely quick — but it stops at brochure sites and light tools. CoDuck builds real applications with a database, logins, and payments, then keeps them running with logs, backups, and analytics built in.
Durable is an AI website builder from Durable Technologies that generates a small-business website in about 30 seconds and bundles it with a CRM, invoicing, and AI marketing tools.
## Feature by feature (July 2026)
| Capability | CoDuck | Durable |
|---|---|---|
| Email sending | ✅ Built in — Transactional email from your domain (5k–50k/mo) | ⚠️ Partial / via 3rd party — CRM auto-replies and AI marketing; no transactional email API |
| Payments | ✅ Built in — Your own Stripe account wired in; CoDuck takes no cut | ⚠️ Partial / via 3rd party — Stripe-backed invoicing (cards, ACH, Apple Pay); no in-app checkout you control |
| Ops dashboard (logs/analytics/backups) | ✅ Built in — Logs, analytics, backups, forms inbox built in | ⚠️ Partial / via 3rd party — Visitor analytics + CRM inbox; no app logs or backups (closed platform) |
| CLI / agent automation | ✅ Built in — @coduckai/cli: create, push, deploy, db, domains | ❌ Not offered — Web dashboard only; no CLI or public API |
| Database | ✅ Built in — Postgres per project, managed | ❌ Not offered — Built-in CRM for contacts, not an app database |
| User auth (accounts on YOUR site) | ✅ Built in — Built-in signup/login for your users | ❌ Not offered — No visitor accounts or login on published sites |
| Hosting + SSL | ✅ Built in — Managed hosting, SSL included | ✅ Built in — Cloudflare hosting, SSL, unlimited traffic |
| Custom domains | ✅ Built in — Included on all plans | ✅ Built in — Paid plans; Launch includes a free domain (up to $20 value) |
| Full-stack app generation | ✅ Built in — Prompt → real Next.js codebase with backend logic | ❌ Not offered — Section-based marketing sites; no custom app logic |
| Code export / ownership | ✅ Built in — Real Next.js code, readable and exportable | ❌ Not offered — Proprietary platform; site code cannot be exported |
| GitHub sync | ⚠️ Partial / via 3rd party — GitHub import only; no two-way sync yet | ❌ Not offered — No GitHub integration |
| Free tier / entry price | ❌ Not offered — No free tier; Pro starts at $20/mo all-in | ✅ Built in — Free plan on a durable.site subdomain; paid from ~$22/mo |
## Where CoDuck is stronger
- Builds real applications, not just pages: database, user accounts, forms, dashboards, and custom logic from a prompt
- Everything pre-wired on one bill — Postgres, auth, email from your domain, your-own-Stripe payments, domains, SSL
- You own the output: readable Next.js code you can export and take anywhere
- Agent-first CLI (@coduckai/cli) — everything the app does is scriptable, unusual in this category
- Ops included: logs, analytics, backups, and a forms inbox without wiring third-party tools
## Where Durable is stronger
- Genuinely fast: generates a publishable small-business site in under a minute, no technical knowledge required
- Real free plan — publish on a durable.site subdomain with hosting, SSL, and unlimited traffic at $0
- Bundled business tools beyond the website: CRM, Stripe-backed invoicing, AI marketing and blog generation
- Zero maintenance burden — no code means nothing to break, update, or debug
- Launch plan includes a free custom domain (up to $20 value) and priority live chat support
## Choose Durable if…
- You need a simple marketing site for a local or service business and want it live today with zero learning curve
- You want to start free and only pay once the business justifies it
- The bundled CRM, invoicing, and AI marketing tools cover most of what you need to run the business
- You never want to think about code, updates, or hosting details — a closed platform is a feature for you
## Choose CoDuck if…
- Your idea needs users to sign up, log in, or store data — that's an app, and Durable can't build one
- You want customers to pay inside your product through your own Stripe account, not just receive invoices
- You want to own and export the actual code instead of renting a site locked to one platform
- You (or your AI agent) want to automate builds and deploys from the command line
- You're an indie builder shipping a product, not a brochure
## Pricing
The models differ as much as the products. As of July 2026, Durable offers a free plan (published on a durable.site subdomain), a Launch plan around $22/month, and a Grow plan around $49/month, with roughly 15% off annual billing — pricing is per-site/per-business and covers hosting plus its CRM and marketing tools. CoDuck has no free tier: Pro is $20/month with $20 of AI usage credits, a 100MB database, and 5k emails/month; Plus is $100/month and Studio $200/month with larger credits and limits. Every CoDuck plan includes hosting, database, custom domains, and email on one bill, with AI generation billed from usage credits. If cost floor matters most, Durable wins; if you'd otherwise pay separately for a database, auth, and email provider, CoDuck's flat bill usually comes out simpler.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Durable to CoDuck
1. Inventory what your Durable site actually does — pages, contact forms, booking links, invoicing — and note what you wish it did (logins, orders, dashboards). Durable's code can't be exported, so this list is your migration artifact.
2. Describe the site and the new functionality to CoDuck in one prompt; it generates a real Next.js app with a database and deploys a live preview URL in minutes.
3. Recreate your forms and lead capture — CoDuck's forms inbox and per-project Postgres replace Durable's CRM for capturing and storing leads.
4. Connect your custom domain in CoDuck (SSL is automatic) and update DNS from Durable; keep the Durable site live until the new one is verified.
5. If you used Durable's invoicing, connect your own Stripe account in CoDuck to take payments directly in your app — CoDuck takes no cut.
## FAQ
### Is CoDuck better than Durable?
For building actual software — apps with user accounts, a database, and payments — yes, because Durable doesn't do those things at all. For a simple small-business marketing site with the least possible effort and a free starting point, Durable is the better fit.
### Can Durable build a real app with a database and user logins?
No. Durable generates section-based marketing websites and bundles a CRM and invoicing for the business owner, but published sites have no app database, no visitor accounts, and no custom backend logic. CoDuck creates a Postgres database and built-in user auth for every project.
### Can I export my website code from Durable?
No — Durable is a proprietary closed platform and you cannot export your site's source code. CoDuck generates a real Next.js codebase that you can read and export at any time.
### Does Durable have a free plan? Does CoDuck?
Durable has a genuine free plan: you can publish on a durable.site subdomain with hosting and SSL at no cost, as of July 2026. CoDuck has no free tier — plans start at Pro, $20/month, which includes hosting, a database, custom domains, email, and $20 of AI usage credits.
### Can I take payments with Durable or CoDuck?
Durable lets you send Stripe-backed invoices and get paid by card, ACH, or Apple Pay — good for service businesses. CoDuck wires your own Stripe account into the app itself, so you can build real checkout flows and subscriptions, and CoDuck takes no cut of your revenue.
### Should I switch from Durable to CoDuck?
Switch when you outgrow a brochure site — when you need customers to log in, store data, or pay inside your product. If Durable's site plus CRM and invoicing still covers your business, there's no reason to move; CoDuck costs more and does more.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/durable*
---
## CoDuck vs Framer
Source: https://coduck.ai/docs/raw/compare/framer.md
# CoDuck vs Framer
> Framer makes marketing sites gorgeous; CoDuck makes working software. For scroll-perfect brand sites, Framer earns its reputation — but there's no real database or user accounts behind it. CoDuck ships the whole app: logins, Postgres, payments, email, hosting, and an ops dashboard, live on your domain.
Framer is a design-first website builder from Framer B.V. that pairs a professional visual canvas with AI features (Wireframer, Workshop) to ship polished marketing sites fast on its own hosting.
## Feature by feature (July 2026)
| Capability | CoDuck | Framer |
|---|---|---|
| Email sending | ✅ Built in — Transactional email from your domain | ❌ Not offered — Form-notification emails to you only |
| Payments | ✅ Built in — Your own Stripe account, CoDuck takes no cut | ⚠️ Partial / via 3rd party — Stripe Payment Links or plugins (Frameshop, Checkout Page) |
| Ops dashboard (logs/analytics/backups) | ✅ Built in — Logs, analytics, backups, forms inbox built in | ⚠️ Partial / via 3rd party — Analytics + forms inbox; no server logs or DB backups |
| CLI / agent automation | ✅ Built in — @coduckai/cli — everything scriptable | ⚠️ Partial / via 3rd party — Claude Code/Codex via MCP for design edits (2026) |
| Database | ✅ Built in — Postgres per project, managed | ⚠️ Partial / via 3rd party — CMS collections for content; not a SQL app database |
| User auth (signup/login) | ✅ Built in — Built-in accounts, no setup | ❌ Not offered — Via paid plugins: Outseta, Memberstack, Thenty |
| Hosting + SSL | ✅ Built in — Managed, included in every plan | ✅ Built in — Fast global CDN hosting, a Framer strength |
| Custom domains | ✅ Built in — Included; apex + www handled | ✅ Built in — Free custom domain on paid plans ($10/mo+) |
| Full-stack app generation | ✅ Built in — Prompt → real Next.js app with API routes | ❌ Not offered — Websites, not apps — no backend code runs on Framer |
| Code export / ownership | ✅ Built in — Real Next.js code, export anytime | ❌ Not offered — No HTML/React export; sites can't be self-hosted |
| GitHub sync | ⚠️ Partial / via 3rd party — Import only; no two-way sync yet | ❌ Not offered — No repo integration for sites |
| Free tier / entry price | ❌ Not offered — Starts at Pro, $20/mo all-in | ✅ Built in — Free plan on framer subdomain; Basic $10/mo |
## Where CoDuck is stronger
- Builds real software, not just pages: working Next.js apps with server logic from a single prompt
- Everything an app needs is pre-wired on one bill — Postgres database, user auth, transactional email, payments via your own Stripe, domains, hosting
- You own the code: readable Next.js you can export and run anywhere, no lock-in
- Agent-first CLI (@coduckai/cli) — create, push, deploy, manage databases and domains from scripts or AI agents
- One flat subscription with usage credits instead of a plugin stack (auth plugin + checkout plugin + email tool) bolted onto a site builder
## Where Framer is stronger
- Best-in-class visual design control — pixel-level layout, scroll effects, and animations that AI code generators rarely match
- Genuine free tier, and a cheap $10/mo entry point for a live site on your own domain
- Mature AI design tooling: Wireframer for page structure, Workshop for AI-generated components, plus 2026 support for external agents like Claude Code
- Fast, reliable managed hosting with global CDN, staging environments, and built-in SEO and analytics
- Huge template and plugin marketplace, so a polished marketing site can go live in an afternoon
## Choose Framer if…
- You're building a marketing site, portfolio, or blog — content people view, not software they log into
- Design fidelity is the point: you want precise control over layout, typography, and animation
- You want to start free or spend $10/mo, and a framer subdomain or simple site is enough
- A designer (or design-minded founder) is doing the work and wants a visual canvas, not a codebase
- You're happy pairing Framer with tools like Outseta or Checkout Page for the occasional gated page or payment
## Choose CoDuck if…
- Your product needs accounts, a database, or payments — a SaaS, marketplace, booking tool, or member app
- You want one bill and zero wiring instead of assembling auth, checkout, and email plugins
- Owning and exporting your code matters — Framer sites can't leave Framer
- You (or your AI agent) want to automate builds and deploys from the command line
- You'd rather describe the product in plain English than arrange it on a canvas
## Pricing
Framer prices like a website host: a real free plan on a framer subdomain, then Basic at $10/mo and Pro at $30/mo (billed annually; monthly billing is higher) with limits on pages, CMS items, and bandwidth, plus $20/mo per extra editor and paid add-ons — as of July 2026. The catch is that app features cost extra elsewhere: memberships via Outseta or Memberstack and checkout via plugins each add their own subscriptions. CoDuck has no free tier — plans start at Pro, $20/mo — but that price includes the database, auth, email, payments wiring, hosting, and custom domains, with usage-based credits covering AI generation. For a brochure site Framer is cheaper; for a working app CoDuck's flat bill usually undercuts a Framer-plus-plugins stack.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Framer to CoDuck
1. Describe your app to CoDuck in plain English — or import your existing site so it can rebuild the design as real Next.js code (Framer offers no export, so content and structure come over by import, not download)
2. Move your content: paste or import your Framer CMS collections; CoDuck stores them in your project's own Postgres database
3. Let CoDuck wire the app parts Framer needed plugins for — user accounts, transactional email, and payments through your own Stripe account
4. Point your custom domain at CoDuck; SSL and www redirects are handled automatically
5. Keep iterating by chat, visual design mode, or the CLI — and export your code whenever you want it
## FAQ
### Is CoDuck better than Framer?
For different jobs. Framer is better for designed marketing sites — portfolios, landing pages, blogs — with superior visual control and a free tier. CoDuck is better when you need a working app: it generates a real Next.js codebase with a Postgres database, user auth, email, and Stripe payments, deployed live. Sites → Framer; software → CoDuck.
### Can Framer build a real app with a database and user logins?
Not natively. Framer has CMS collections for content and a Fetch feature for pulling external API data, but no app database and no built-in user authentication — logins and gated content require third-party plugins like Outseta, Memberstack, or Thenty, each with its own subscription. CoDuck ships a Postgres database and built-in auth with every project.
### Can I export my code from Framer?
No. Framer's own help center states sites can't be exported as HTML or self-hosted — your site lives on Framer's hosting. CoDuck generates standard Next.js code you can read, export, and run anywhere.
### How do payments work in Framer vs CoDuck?
Framer has no native checkout; as of 2026 you use Stripe Payment Links or plugins like Frameshop or Checkout Page. CoDuck wires payments into your app through your own Stripe account via Stripe Connect — CoDuck takes no cut of your revenue.
### Is Framer cheaper than CoDuck?
For a simple site, yes: Framer has a free plan and paid plans from $10/mo (annual) as of July 2026, versus CoDuck's $20/mo entry with no free tier. But once you add membership and checkout plugins to make a Framer site behave like an app, the combined cost often exceeds CoDuck's flat plan, which includes database, auth, email, and payments.
### Does Framer work with AI agents like Claude Code?
Yes — since 2026 Framer supports external agents (Claude Code, Codex, Cursor) via MCP, mainly for design and canvas edits. CoDuck is agent-first end to end: its npm CLI can create projects, push code, run deploys, and manage databases and domains, so an agent can operate the whole platform.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/framer*
---
## CoDuck vs Hostinger Horizons
Source: https://coduck.ai/docs/raw/compare/hostinger-horizons.md
# CoDuck vs Hostinger Horizons
> Horizons bolts AI onto hosting; CoDuck was built AI-first. Hostinger's bundle is a solid budget entry into AI app building, but email, payments, and day-two operations mean juggling separate Hostinger products. CoDuck includes the entire stack in every plan — and a CLI your AI agents can drive end to end.
Hostinger Horizons is an AI web-app builder from Hostinger, the web-hosting company, that turns chat prompts into React web apps with hosting, domains, and an integrated backend bundled into Hostinger's plans.
## Feature by feature (July 2026)
| Capability | CoDuck | Hostinger Horizons |
|---|---|---|
| Email sending | ✅ Built in — From your domain, 5k–50k emails/mo | ⚠️ Partial / via 3rd party — Up to 500 automated emails/day/project; custom-domain sending not documented |
| Payments | ✅ Built in — Your own Stripe via Connect, CoDuck takes no cut | ⚠️ Partial / via 3rd party — Bring your own Stripe keys; AI wires the checkout |
| Ops dashboard (logs/analytics/backups) | ✅ Built in — Logs, analytics, backups, forms inbox built in | ⚠️ Partial / via 3rd party — Traffic analytics + version history; no app logs or DB backup tooling documented |
| CLI / agent automation | ✅ Built in — @coduckai/cli — full API coverage, scriptable | ❌ Not offered — Web app only, no CLI or API |
| Database | ✅ Built in — Postgres per project, 100MB–5GB by plan | ⚠️ Partial / via 3rd party — Integrated backend data storage (beta), 5GB/project; older projects via Supabase; no direct SQL access |
| User authentication | ✅ Built in — Built-in auth, pre-wired | ✅ Built in — Email/password, OTP, Google/Apple SSO (integrated backend, beta) |
| Hosting + SSL | ✅ Built in — Managed hosting, all plans | ✅ Built in — Hostinger hosting bundled, auto SSL |
| Custom domains | ✅ Built in — Included on all plans, www auto-covered | ✅ Built in — Supported; free domain 1st year on Starter+ |
| Full-stack app generation | ✅ Built in — Real Next.js codebase from a prompt | ✅ Built in — React + Vite app with integrated backend |
| Code export / ownership | ✅ Built in — Export your Next.js code on every plan | ⚠️ Partial / via 3rd party — ZIP export (React+Vite) on Hobbyist $39.99+/mo only; can't re-import |
| GitHub sync | ⚠️ Partial / via 3rd party — GitHub import only, no two-way sync | ❌ Not offered — No GitHub import or sync |
| Free tier / entry price | ❌ Not offered — No free tier; Pro $20/mo | ✅ Built in — Free plan (5 AI credits); paid from $6.99/mo billed annually |
## Where CoDuck is stronger
- You own a real Next.js codebase and can export it on every plan — Horizons gates ZIP export behind its $39.99/mo Hobbyist tier and exports can't be re-imported
- A real Postgres database per project that you can query and grow, versus a beta managed data store with no documented SQL access
- Transactional email from your own domain at real volume (5,000–50,000/mo by plan) versus 500 automated emails per day
- Payments through your own Stripe account wired in via Stripe Connect — CoDuck takes no cut of your revenue
- Agent-first CLI (@coduckai/cli): everything the app does is scriptable, so your own AI agents and CI can create, push, and deploy projects
- Built-in ops dashboard: application logs, analytics, backups, and a forms inbox in one place
## Where Hostinger Horizons is stronger
- Cheapest entry point in the category: paid plans from $6.99/mo (billed annually) plus a genuinely free plan with 5 AI credits to try before paying anything
- Bundles Hostinger's ecosystem perks — hosting, a free domain for the first year (Starter and up), and email mailboxes — into one purchase
- New integrated backend (beta, launched Feb 2026) covers data storage, logins with Google/Apple SSO, file uploads, and notification emails without connecting third-party services
- Generous multi-site allowances: up to 25 websites on Starter ($13.99/mo) and 50 on higher tiers, good for people running many small projects
- Backed by Hostinger's scale: 24/7 support, mature hosting infrastructure, and a 30-day money-back guarantee
## Choose Hostinger Horizons if…
- Your budget is under $10/month or you want to try an AI builder for free before committing
- You're building simple sites or lightweight apps in volume — Horizons' 25–50 website allowances beat CoDuck's per-project pricing for portfolios of small sites
- You're already in the Hostinger ecosystem and want the bundled free domain and email mailboxes
- You're fully non-technical and never plan to read or export the code — Horizons' no-code framing is comfortable there
- You want the safety net of a large, established company with 24/7 support and a 30-day money-back guarantee
## Choose CoDuck if…
- You're building a real product — SaaS, marketplace, member site — that needs a proper Postgres database you can inspect and grow
- You want to own your code from day one: CoDuck exports real Next.js on every plan, not just the top tiers
- You need transactional email from your own domain at volume (receipts, magic links, notifications)
- You want to charge customers through your own Stripe account without the platform taking a cut
- You or your AI agents want to automate builds and deploys from the terminal with a CLI
## Pricing
Hostinger Horizons is priced on AI credits: as of July 2026, a free plan gives you 5 credits to try it, then paid plans run from Explorer at $6.99/mo (30 credits, 1 website) through Starter at $13.99/mo (70 credits, 25 websites) to Hobbyist at $39.99/mo (200 credits, plus the code editor and export) and Hustler at $59.99/mo (400 credits) — all billed annually, with monthly billing costing more and unused credits expiring each cycle. Hosting is bundled, and Starter and up include a free domain for the first year. CoDuck has no free tier: Pro is $20/mo with $20 of AI usage credits, Plus $100/mo, Studio $200/mo — every plan includes hosting, a Postgres database, custom domains, email sending, and full code export, so the higher floor buys capabilities Horizons gates to its upper tiers or doesn't offer.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Hostinger Horizons to CoDuck
1. Export your project from Horizons as a ZIP (requires the Hobbyist plan or higher) — or gather your original prompts and content if you're on a lower tier, since export isn't available there
2. Create a CoDuck project: import your existing site or describe the app in a prompt, and CoDuck generates a Next.js codebase with a Postgres database already attached
3. Recreate your data model and move your data — if you were on Horizons' Supabase integration, export from Supabase and import into your CoDuck project's Postgres
4. Reconnect your Stripe account (CoDuck wires it via Stripe Connect) and verify your sending domain for transactional email
5. Point your custom domain to CoDuck — SSL and www redirects are handled automatically — then retire the Horizons project
## FAQ
### Is CoDuck better than Hostinger Horizons?
It depends on what you're building. Hostinger Horizons is cheaper (from $6.99/mo billed annually, with a free plan) and fine for simple apps and sites, especially if you want Hostinger's bundled domain and mailboxes. CoDuck ($20/mo minimum) is stronger for real products: it gives you a per-project Postgres database, transactional email from your own domain, your own Stripe account wired in, a CLI for automation, and full code export on every plan.
### Does Hostinger Horizons have a real database?
As of 2026, yes — with caveats. New Horizons projects use an integrated backend (in beta since February 2026) that stores data, handles logins, and offers up to 5GB per project. Older projects connect to Supabase instead. There's no documented direct SQL access to the integrated store. CoDuck provisions a real Postgres database per project that you can query directly.
### Can I export my code from Hostinger Horizons?
Only on the Hobbyist plan ($39.99/mo) or higher, and only as a ZIP of a React + Vite project. Hostinger's docs note exported code can't be re-imported, and there's no GitHub sync. CoDuck lets you export your full Next.js codebase on every plan, including the cheapest.
### Does Hostinger Horizons have a free plan? Does CoDuck?
Horizons has a free plan with 5 AI credits — enough to explore, not to build anything substantial. CoDuck has no free tier; the entry plan is Pro at $20/mo, which includes $20 of AI usage credits plus hosting, a Postgres database, custom domains, and email sending.
### Can Hostinger Horizons send emails and take payments?
Yes, within limits. Its integrated backend can send up to 500 automated emails per day per project (custom-domain sending isn't documented), and payments work by providing your own Stripe keys, which the AI then wires into checkout. CoDuck sends 5,000–50,000 emails per month from your own domain depending on plan, and connects your Stripe account via Stripe Connect without taking a cut.
### Which should I use to build a SaaS product?
For a SaaS you plan to run long-term, CoDuck is the safer bet: real Postgres, auth, your-domain email, your own Stripe billing, application logs and backups, and exportable Next.js code mean you're never locked in. Horizons can prototype a SaaS cheaply, but its beta backend, 500-email/day cap, and export restrictions become friction once you have paying users.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/hostinger-horizons*
---
## CoDuck vs Lovable
Source: https://coduck.ai/docs/raw/compare/lovable.md
# CoDuck vs Lovable
> CoDuck ships everything Lovable makes you assemble. Lovable is bigger, has a free tier, and syncs two-way with GitHub — real advantages — but its backend runs on Supabase and email means bringing your own Resend account. With CoDuck the database, auth, email from your domain, and payments through your own Stripe are already wired in, on one flat bill. If you want the shortest path from prompt to a running business, that's CoDuck.
Lovable (lovable.dev) is an AI full-stack app builder from Stockholm-based Lovable that turns prompts into React apps with a Supabase-backed cloud backend.
## Feature by feature (July 2026)
| Capability | CoDuck | Lovable |
|---|---|---|
| Email sending | ✅ Built in — From your domain, included (5k–50k/mo by plan) | ⚠️ Partial / via 3rd party — Via your own Resend account + API key |
| Payments | ✅ Built in — Your Stripe account pre-wired (Connect), no cut taken | ⚠️ Partial / via 3rd party — Chat-driven Stripe setup with your API key + edge functions |
| Ops dashboard (logs, analytics, backups) | ✅ Built in — Logs, analytics, backups, forms inbox built in | ⚠️ Partial / via 3rd party — Cloud dashboard for backend; deeper ops live in Supabase tooling |
| CLI / agent automation | ✅ Built in — @coduckai/cli — everything scriptable | ❌ Not offered — No official CLI or agent API as of mid-2026 |
| Database | ✅ Built in — Managed Postgres per project, included | ⚠️ Partial / via 3rd party — Lovable Cloud — managed Supabase under the hood |
| User auth | ✅ Built in — Built-in, nothing to wire up | ⚠️ Partial / via 3rd party — Supabase Auth via Lovable Cloud |
| Hosting + SSL | ✅ Built in — Managed, included in every plan | ✅ Built in — Lovable Cloud, yourapp.lovable.app |
| Custom domains | ✅ Built in — Included, apex + www with SSL | ✅ Built in — Included on paid plans |
| Full-stack app generation | ✅ Built in — Prompt → real Next.js app, live in minutes | ✅ Built in — Prompt → Vite + React app on Lovable Cloud |
| Code export / ownership | ✅ Built in — Real Next.js code, export anytime | ✅ Built in — GitHub export or ZIP download (paid plans) |
| GitHub sync | ⚠️ Partial / via 3rd party — Import only — no two-way sync yet | ✅ Built in — True two-way sync, branch + PR workflow |
| Free tier / entry price | ❌ Not offered — Starts at Pro $20/mo, all batteries included | ✅ Built in — Free plan (5 daily credits); Pro $25/mo |
## Where CoDuck is stronger
- Everything on one bill: Postgres, auth, hosting, custom domains, and transactional email from your own domain are included — no Supabase, Resend, or hosting accounts to create or pay for separately.
- Payments through your own Stripe account, pre-wired via Stripe Connect — CoDuck takes no cut of your revenue.
- A built-in ops dashboard for the app you shipped: logs, analytics, backups, a forms inbox, and activity in one place.
- Agent-first CLI (@coduckai/cli on npm): everything the web app does — create, push, deploy, database, domains — is scriptable by you or your AI agent.
- You own real, readable Next.js code and can export it at any time.
## Where Lovable is stronger
- A genuinely usable free tier — 5 build credits a day plus monthly Cloud credits, no credit card required, so you can prototype before spending anything.
- True two-way GitHub sync: push to GitHub, work locally in your IDE, review changes in pull requests, and sync back — the best developer-collaboration story in this category.
- Lovable Cloud auto-provisions a full Supabase-backed backend (database, auth, storage, edge functions) the moment your app needs one — no manual setup.
- A massive community, template library, and tutorial ecosystem, backed by a well-funded company that ships new features fast.
- Chat-driven integrations: Stripe checkout, Resend email, and visual edits can all be set up by describing what you want.
## Choose Lovable if…
- You want to try before you buy — Lovable's free tier lets you build real prototypes at $0; CoDuck has no free tier.
- You work with developers (or are one) and want a GitHub-centric workflow: Lovable's two-way sync and PR-based collaboration beat CoDuck's import-only GitHub support.
- You already know and like the Supabase ecosystem, or want your backend on infrastructure you can also access directly.
- You value ecosystem maturity: Lovable has far more templates, tutorials, community answers, and integration guides, and a large funded team behind it.
- You want in-browser visual editing with a big library of examples to remix.
## Choose CoDuck if…
- You're non-technical and never want to touch a third-party dashboard: email, payments, database, and domains work out of the box instead of via Resend/Stripe/Supabase setup steps.
- You want predictable costs: one flat plan that includes hosting, database, domains, and email — no second usage-based layer for your shipped app's backend.
- You (or your AI agent) want to automate: CoDuck's CLI covers the whole platform; Lovable has no CLI.
- You need transactional email from your own domain included in the plan rather than bring-your-own-Resend.
- You want to run the app after launch from one place — logs, analytics, backups, and form submissions in a built-in ops dashboard.
## Pricing
The models differ more than the price tags. As of July 2026, Lovable offers a free plan (5 daily build credits plus monthly Cloud credits), Pro at $25/mo for 100 monthly credits, and Business at $50/mo — but hosting a live app adds a second, usage-based layer of Cloud and AI charges on top of the subscription, a pricing surprise Lovable users commonly report. CoDuck has no free tier — an honest gap — but its plans are flat and all-inclusive: Pro $20/mo (with $20 of AI usage credits, 100MB database, 5k emails), Plus $100/mo, and Studio $200/mo, with hosting, Postgres, custom domains, and email sending included in every plan rather than billed separately.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Lovable to CoDuck
1. Export your code from Lovable (GitHub sync or 'Download codebase' on paid plans) so you own a complete copy of your app.
2. Recreate the app on CoDuck: Lovable builds Vite + React while CoDuck builds Next.js, so rather than porting files, describe your app (pages, features, data model) to CoDuck — or use its site import — and let it rebuild natively.
3. Move your data: export your tables from Supabase (CSV or pg_dump) and import them into your CoDuck project's built-in Postgres.
4. Reconnect services in CoDuck's settings: auth, email from your domain, and your Stripe account are built in — no Resend or edge-function setup to redo.
5. Point your custom domain at CoDuck (SSL and www are handled automatically), verify everything on the live URL, then cancel your Lovable subscription.
## FAQ
### Is CoDuck better than Lovable?
Neither is universally better. Lovable is more mature, has a free tier, and offers two-way GitHub sync. CoDuck bundles more into one bill — database, auth, email from your domain, your-own-Stripe payments, domains, and an ops dashboard are all pre-wired — and adds a CLI for automation. Non-technical founders who want zero third-party setup tend to prefer CoDuck; builders who want to start free or collaborate via GitHub tend to prefer Lovable.
### Can Lovable build a real app with a database?
Yes. Lovable is a genuine full-stack builder: Lovable Cloud auto-provisions a Supabase-backed backend with a real Postgres database, authentication, storage, and edge functions. You can also connect your own Supabase project.
### Does Lovable have a free tier? Does CoDuck?
Lovable does — 5 build credits per day plus monthly Cloud credits, no credit card required. CoDuck does not; its cheapest plan is Pro at $20/mo, which includes hosting, a Postgres database, custom domains, and email sending.
### Can I send emails from an app built with Lovable or CoDuck?
With Lovable you connect your own Resend account and API key, and you need to verify your domain in Resend to email real users. With CoDuck, transactional email from your own domain is built into every plan (5,000–50,000 emails/month depending on tier) with nothing extra to sign up for.
### How do payments work in Lovable vs CoDuck?
Both use your own Stripe account, so neither takes a cut of your revenue. In Lovable you add your Stripe secret key in chat and it generates checkout and webhook edge functions on Supabase. In CoDuck, Stripe is pre-wired via Stripe Connect — you connect your account and payments work without generated glue code to maintain.
### Can I export my code and leave either platform?
Yes, both. Lovable lets you sync to GitHub or download your codebase on paid plans (Vite + React with Supabase config). CoDuck gives you a real Next.js codebase you can export anytime. Lovable is stronger on ongoing GitHub collaboration (two-way sync); CoDuck currently supports GitHub import only.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/lovable*
---
## CoDuck vs Replit
Source: https://coduck.ai/docs/raw/compare/replit.md
# CoDuck vs Replit
> Replit is the closest thing to CoDuck — and the far more complex one. Both build and run real full-stack apps natively, and Replit adds a full cloud IDE, a free tier, and GitHub sync. CoDuck's bet is simplicity: one flat bill that already includes email, your-own-Stripe payments, domains, and an ops dashboard — no IDE, no compute meters. Developers who want an editor will like Replit; founders who want a finished product will ship faster on CoDuck.
Replit is a browser-based cloud IDE with an autonomous AI agent (Replit Agent 3) that builds, tests, and deploys full-stack apps, made by Replit Inc., a well-funded company based in Foster City, California.
## Feature by feature (July 2026)
| Capability | CoDuck | Replit |
|---|---|---|
| Email sending | ✅ Built in — From your domain (SES); 5k–50k/mo included | ⚠️ Partial / via 3rd party — Test sends built in; production via Resend/Mailgun connector |
| Payments | ✅ Built in — Your Stripe account via Connect; CoDuck takes no cut | ✅ Built in — Stripe connector; sandbox → your live account |
| Ops dashboard (logs/analytics/backups) | ✅ Built in — Logs, analytics, backups, forms inbox in one place | ✅ Built in — Logs (7-day retention), analytics, monitoring; DB rollbacks 28d on Pro |
| CLI / agent automation | ✅ Built in — @coduckai/cli: create, push, deploy, db, domains | ⚠️ Partial / via 3rd party — In-browser shell; no official local CLI to drive the Agent |
| Database | ✅ Built in — Postgres per project, included in plan | ✅ Built in — Managed Postgres (Neon-backed), dev/prod split |
| User auth | ✅ Built in — Built-in auth; your users, your app | ✅ Built in — Replit Auth; end users sign in via Replit accounts |
| Hosting + SSL | ✅ Built in — Managed hosting, auto SSL, all plans | ✅ Built in — Autoscale/Static/Reserved VM; compute billed from credits |
| Custom domains | ✅ Built in — Included on every plan, auto SSL + www | ✅ Built in — On deployments, DNS-validated SSL |
| Full-stack app generation | ✅ Built in — Prompt → real Next.js codebase, deployed live | ✅ Built in — Agent 3 builds, tests in-browser, deploys |
| Code export / ownership | ✅ Built in — Real Next.js code, readable and exportable | ✅ Built in — Download zip or bulk export; you own the code |
| GitHub sync | ⚠️ Partial / via 3rd party — Import from GitHub; no two-way sync yet | ✅ Built in — Git pane with two-way auto-sync |
| Free tier / entry price | ❌ Not offered — Starts at Pro $20/mo, credits included | ✅ Built in — Free Starter: daily Agent credits, publish 1 app |
## Where CoDuck is stronger
- One flat bill that already includes hosting, a Postgres database, custom domains, and email — no compute or deployment charges eating your credits.
- Transactional email from your own domain is built in (5k–50k emails/mo by plan) — on Replit, production email means wiring up a Resend or Mailgun account.
- Payments run through your own Stripe account via Stripe Connect, and CoDuck takes no cut of your revenue.
- Your app's users sign in to your app — not through a third-party account system like Replit Auth's Replit-account login.
- An agent-first CLI (@coduckai/cli) covers everything the app does — create, push, deploy, db, domains — so Claude Code or any local agent can run your whole project.
- No IDE to learn: it's a chat, a visual design mode, and a live URL — built for non-developers shipping real products.
## Where Replit is stronger
- A genuinely free Starter tier — daily Agent credits and one published app, so you can try real builds for $0.
- A full cloud IDE around the agent: shell, file tree, secrets, multiplayer editing — you can drop to code any time without leaving the browser.
- Agent 3 is highly autonomous: it browser-tests its own work and can run long tasks (200+ minutes) with minimal supervision.
- First-class GitHub integration with two-way auto-sync, plus 30+ one-click connectors (Stripe, Slack, Linear, and more).
- Mature platform from a well-funded company: separate dev/prod databases, point-in-time restore, app monitoring, enterprise plans with SSO.
## Choose Replit if…
- You want to try before paying — Replit's free Starter tier lets you build and publish one app with daily Agent credits; CoDuck has no free tier.
- You (or a teammate) will actually write code: Replit's full cloud IDE, shell, and multiplayer editing beat a chat-plus-export workflow for hands-on development.
- GitHub is central to your workflow — Replit's two-way auto-sync keeps a repo current; CoDuck only imports from GitHub today.
- You need enterprise features now: SSO/SAML, single-tenant environments, static outbound IPs, and a large funded team behind the platform.
- You want breadth beyond web apps — scheduled jobs, automations, 30+ connectors, and multiple deployment types (autoscale, reserved VM, static) in one workspace.
## Choose CoDuck if…
- You're a non-technical founder who wants a product live on a real domain, not a development environment to learn.
- You want one predictable bill: CoDuck's plans include hosting, database, domains, and email, while Replit bills Agent work and deployment compute against usage credits.
- Your app needs to email users from your own domain out of the box — no Resend/Mailgun account to set up.
- You're charging customers: your own Stripe account is pre-wired via Connect and CoDuck takes no cut.
- You automate with AI agents: the CoDuck CLI lets Claude Code or scripts create, push, and deploy projects end to end from a terminal.
## Pricing
Both platforms use usage credits for AI work, but the bills are shaped differently. As of July 2026, Replit offers a free Starter tier (daily Agent credits, one published app), Core at $25/mo with $25 of credits, and Pro at $100/mo with $100 of credits — but Agent effort and deployment compute both draw from those credits, so an active month can cost noticeably more than the sticker price. CoDuck has no free tier: Pro is $20/mo with $20 of generation credits, Plus $100/mo with $100, and Studio $200/mo with $200 — and hosting, Postgres, custom domains, and email are included flat rather than metered, so the sticker price is much closer to what you actually pay.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Replit to CoDuck
1. Export your code from Replit: use "Download as zip" in the project menu, or push the repo to GitHub from Replit's Git pane.
2. Import it into CoDuck via GitHub import, or run `coduck create` + `coduck push` from the CLI with your exported code.
3. Migrate your data: dump your Replit Postgres with pg_dump and restore it into your CoDuck project's database (`coduck db`).
4. Reconnect services: link your Stripe account via CoDuck's Stripe Connect flow and verify your sending domain for built-in email (replacing any Resend/Mailgun setup).
5. Point your custom domain at CoDuck, confirm SSL is issued, then deploy and retire the Replit deployment.
## FAQ
### Is CoDuck better than Replit?
It depends on who you are. Replit is better if you want a free tier, a full cloud IDE, and GitHub two-way sync. CoDuck is better if you're a non-technical founder who wants a finished product on your own domain with database, auth, email, and Stripe payments pre-wired under one flat bill. Both are genuinely full-stack — the difference is IDE-plus-credits versus batteries-included simplicity.
### Does Replit have a free plan?
Yes. As of July 2026, Replit's Starter plan is free and includes daily Agent credits and the ability to publish one app. CoDuck has no free tier — plans start at $20/mo — so Replit is the cheaper way to experiment before committing.
### Can Replit apps send email?
Partially. Replit apps can send test emails out of the box (powered by Resend), but sending production email from your own domain requires connecting a Resend or Mailgun account. CoDuck includes transactional email from your own domain natively — 5,000 to 50,000 emails per month depending on plan.
### Do I own my code on Replit and CoDuck?
Yes, on both. Replit lets you download a zip, bulk-export your account, or sync two-way with GitHub. CoDuck generates a real Next.js codebase you can read and export, though it only imports from GitHub today — there's no two-way sync yet.
### Can Replit deploy a real database and take payments?
Yes. Replit provisions a managed Postgres database (Neon-backed, with separate dev/prod databases and point-in-time restore) and its Stripe connector lets you test in a sandbox and go live on your own Stripe account. CoDuck matches this with a Postgres database per project and Stripe Connect using your own account — CoDuck takes no cut.
### How do I move an app from Replit to CoDuck?
Export your code from Replit (Download as zip, or push to GitHub), import it into CoDuck via GitHub import or the CoDuck CLI, migrate your Postgres data with pg_dump/restore, reconnect Stripe and your email domain, then point your custom domain at CoDuck. Most apps move in an afternoon.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/replit*
---
## CoDuck vs Squarespace
Source: https://coduck.ai/docs/raw/compare/squarespace.md
# CoDuck vs Squarespace
> Squarespace is for polished brochure sites; CoDuck is for software. Its templates and simple commerce are lovely, but there's no custom app logic, no real database, and no code ownership. CoDuck builds actual web apps — accounts, data, payments — from one prompt, and runs them for you.
Squarespace is a template-based website builder from Squarespace, Inc. that pairs designer templates with Blueprint AI guided setup, managed hosting, and built-in ecommerce for content sites, portfolios, and online stores.
## Feature by feature (July 2026)
| Capability | CoDuck | Squarespace |
|---|---|---|
| Email sending | ✅ Built in — transactional email from your domain, included | ⚠️ Partial / via 3rd party — Email Campaigns is a paid add-on (~$5–48/mo); marketing-focused |
| Payments | ✅ Built in — your own Stripe account via Connect — CoDuck takes no cut | ✅ Built in — Squarespace Payments/Stripe/PayPal; 7%→0% fee on digital goods by plan |
| Ops dashboard (logs / analytics / backups) | ✅ Built in — logs, analytics, backups, forms inbox built in | ⚠️ Partial / via 3rd party — good analytics + forms; no app logs or one-click backups |
| CLI / agent automation | ✅ Built in — @coduckai/cli — everything scriptable | ❌ Not offered — legacy dev platform is 7.0-template-only; no general CLI |
| Database | ✅ Built in — Postgres per project, included | ❌ Not offered — CMS content only — no queryable app database |
| User auth / accounts | ✅ Built in — built-in auth for your app's users | ⚠️ Partial / via 3rd party — Member Sites gate content; not custom app auth |
| Hosting + SSL | ✅ Built in — managed hosting, SSL included | ✅ Built in — fully managed hosting + SSL on all plans |
| Custom domains | ✅ Built in — connect your domain, SSL auto | ✅ Built in — free domain first year on annual plans |
| Full-stack app generation | ✅ Built in — prompt → real Next.js app, live in minutes | ❌ Not offered — Blueprint AI designs template sites, not apps with custom logic |
| Code export / ownership | ✅ Built in — real Next.js code, export anytime | ❌ Not offered — XML content export only; designs, CSS, products don't export |
| GitHub sync | ⚠️ Partial / via 3rd party — import from GitHub; no two-way sync yet | ❌ Not offered — Git deploy only on legacy 7.0 developer templates |
| Free tier / entry price | ❌ Not offered — Pro $20/mo, includes $20 AI credits + hosting + DB | ⚠️ Partial / via 3rd party — no free plan; 14-day trial; Basic from $16/mo annual |
## Where CoDuck is stronger
- Builds real applications, not just pages — describe it and CoDuck writes an actual Next.js codebase with a Postgres database, user auth, and custom logic, deployed live in minutes
- You own the code: read it, edit it, export it, and leave whenever you want — there is no Squarespace-equivalent lock-in
- Payments run through your own Stripe account via Stripe Connect, so CoDuck takes 0% of your revenue — versus up to 7% on Squarespace digital-goods sales
- Transactional email from your own domain is included on every plan (5k–50k emails/mo), not a separate add-on subscription
- Agent-first CLI (@coduckai/cli): everything the app does is scriptable — create, push, deploy, database, domains — which no template site builder offers
## Where Squarespace is stronger
- Design quality is best-in-class — award-winning templates plus Blueprint AI guided setup produce a genuinely beautiful site in 5–10 minutes, no design skill required
- Mature, all-in-one ecommerce: product catalogs, inventory, shipping, taxes, Squarespace Payments with Apple Pay/Afterpay/Klarna, and 0% store transaction fees on Core and above
- Built-in monetization for creators — Member Sites, Courses, paid newsletters, and gated content work out of the box on every plan
- Lower entry price for a simple site: Basic starts at $16/mo (annual) with hosting, SSL, and a free first-year domain included
- Twenty years of polish and a huge ecosystem — extensive help docs, templates, integrations, and hired-help marketplace mean you're rarely stuck
## Choose Squarespace if…
- You want a marketing site, portfolio, blog, or restaurant/services site — Squarespace's templates and editor are simply better for pure content sites
- You're selling physical products and want mature ecommerce (inventory, shipping labels, taxes, POS) without touching code
- You monetize content — courses, memberships, paid newsletters — and want that machinery pre-built rather than custom
- You never want to think about code, even to glance at it; Squarespace's visual editor covers 100% of what you'll do
- You want the lowest entry price for a simple annual-billed site ($16/mo Basic vs CoDuck's $20/mo Pro)
## Choose CoDuck if…
- Your idea needs a database and logged-in users — a SaaS tool, marketplace, booking system, dashboard, or community app — which Squarespace fundamentally cannot build
- You want to keep 100% of your revenue: payments go through your own Stripe account with no platform transaction fee
- You want to own and export real code instead of renting a template you can never take with you
- You (or your AI agent) want to automate everything from the command line — deploys, database, domains — via the CoDuck CLI
- You want one flat bill that already includes database, auth, transactional email, hosting, and custom domains, instead of stacking add-ons
## Pricing
Squarespace (as of July 2026) runs four plans billed annually: Basic $16/mo, Core $23/mo, Plus $39/mo, and Advanced $99/mo, with no free plan but a 14-day trial and a free first-year domain on annual billing. Watch the per-sale fees — 2% on store sales at Basic and 7%/5%/1%/0% on digital goods and memberships depending on tier — plus Email Campaigns as a separate ~$5–48/mo add-on. CoDuck has no free tier either: Pro is $20/mo with $20 of AI generation credits, a 100MB Postgres database, 5k emails/mo, hosting, and custom domains all included; Plus ($100/mo) and Studio ($200/mo) scale credits, database, and email up. The structural difference: Squarespace's price grows with add-ons and transaction fees, CoDuck's grows with how much AI generation you use — and CoDuck never takes a cut of your sales.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Squarespace to CoDuck
1. Export what Squarespace lets you: download your content as XML (pages, blog posts, text) and save your images manually — note that products, custom CSS, and design don't export
2. Describe your site or app to CoDuck in a prompt — include your pages, brand, and any app features (accounts, database, payments) Squarespace couldn't do; or use site import to bring over your existing design
3. Iterate in chat and the visual design mode until it matches (or beats) your old site, and paste in your exported content
4. Wire up the batteries: connect your own Stripe account for payments, verify your domain for transactional email, and set up auth if your app has users
5. Point your custom domain at CoDuck (SSL is automatic), confirm the live site, then cancel your Squarespace subscription before renewal
## FAQ
### Is CoDuck better than Squarespace?
For web applications, yes — CoDuck builds real Next.js apps with a database, user auth, and custom logic, which Squarespace can't do at all. For pure content sites, portfolios, and template-based stores, Squarespace is the more polished tool. They're genuinely different categories: app builder vs site builder.
### Can Squarespace build a web app with a database and user logins?
No. Squarespace has no user-accessible database and no custom application logic. Its Member Sites feature can gate content behind a login and take subscription payments, but you can't build a SaaS tool, marketplace, or custom dashboard on it. CoDuck creates a real Postgres database and built-in auth for every project.
### Can I export my website code from Squarespace?
Not really. Squarespace exports some content (pages, blog posts, text) as an XML file, but your design, custom CSS, products, and many block types don't export, and images often come out as links back to Squarespace. CoDuck projects are real Next.js codebases you can read and export in full at any time.
### How much does Squarespace cost compared to CoDuck?
As of July 2026, Squarespace runs $16–$99/mo billed annually (Basic/Core/Plus/Advanced) with a 14-day trial, plus transaction fees up to 7% on digital goods on lower tiers and a separate ~$5–48/mo email add-on. CoDuck starts at $20/mo Pro, which includes $20 of AI credits, a Postgres database, transactional email, hosting, and custom domains — and takes no cut of your sales.
### Does Squarespace take a cut of my sales?
On its lower tiers, yes: as of mid-2026, store sales carry a 2% fee on Basic, and digital goods/memberships carry 7% (Basic), 5% (Core), 1% (Plus), and 0% (Advanced). CoDuck wires payments through your own Stripe account via Stripe Connect and takes 0% on every plan — you pay only Stripe's standard processing fees.
### Is Squarespace's Blueprint AI the same kind of AI builder as CoDuck?
No. Blueprint AI is a guided setup wizard that assembles a template site — layout, copy, and images — from your answers in about 5–10 minutes, and it's good at that. CoDuck's AI writes an actual codebase: it generates a Next.js application with a database and deploys it live, then you iterate by chatting. One decorates a template; the other programs an app.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/squarespace*
---
## CoDuck vs v0
Source: https://coduck.ai/docs/raw/compare/v0.md
# CoDuck vs v0
> v0 designs beautiful frontends; CoDuck ships whole products. As a UI generator, v0 is arguably the best in the category — but the database, auth, email, and payments are left as your problem. CoDuck builds and runs the entire thing: a real Next.js app with Postgres, logins, email from your domain, and your own Stripe, live on your domain in minutes.
v0 (app.v0.dev) is Vercel's AI builder that generates Next.js apps from prompts — best known for polished UI generation, now expanded into full-stack apps that deploy to Vercel.
## Feature by feature (July 2026)
| Capability | CoDuck | v0 |
|---|---|---|
| Email sending | ✅ Built in — From your domain, SES-backed, included | ⚠️ Partial / via 3rd party — Via Resend integration; your own Resend account + domain |
| Payments | ✅ Built in — Your Stripe account wired in via Connect; CoDuck takes no cut | ⚠️ Partial / via 3rd party — Stripe integration provisions API keys; you assemble the flow |
| Ops dashboard (logs/analytics/backups) | ✅ Built in — Logs, analytics, backups, forms inbox in one place | ⚠️ Partial / via 3rd party — Vercel dashboard for logs; DB backups depend on your provider |
| CLI / agent automation | ✅ Built in — @coduckai/cli covers everything: create, deploy, db, domains | ⚠️ Partial / via 3rd party — v0 Platform API + v0-sdk (beta); hosting ops via Vercel CLI |
| Database | ✅ Built in — Postgres per project, included in plan | ⚠️ Partial / via 3rd party — Via integrations: Supabase, Neon, Upstash (separate accounts) |
| User auth | ✅ Built in — Built-in auth, no setup | ⚠️ Partial / via 3rd party — Generates auth code; typically backed by Supabase Auth or similar |
| Hosting + SSL | ✅ Built in — Managed hosting, live URL in minutes | ✅ Built in — Deploys to Vercel with a vercel.app URL |
| Custom domains | ✅ Built in — All plans, auto SSL, www covered | ✅ Built in — Added from v0 interface, auto SSL |
| Full-stack app generation | ✅ Built in — Prompt to live Next.js app with backend included | ✅ Built in — As of 2026: API routes, server actions, sandbox runtime |
| Code export / ownership | ✅ Built in — Real Next.js code, export anytime | ✅ Built in — ZIP download or shadcn CLI into your codebase |
| GitHub sync | ⚠️ Partial / via 3rd party — Import only — no two-way sync yet | ✅ Built in — Bi-directional sync, branches and PRs from chat |
| Free tier / entry price | ❌ Not offered — Starts at Pro $20/mo with $20 usage credits | ✅ Built in — Free plan with $5 monthly credits |
## Where CoDuck is stronger
- Everything is included and managed: Postgres, auth, email from your domain, payments, hosting, domains — one bill, nothing to wire up
- Payments run through your own Stripe account via Stripe Connect and CoDuck takes no cut of your revenue
- Ops built in: logs, analytics, backups, forms inbox, and activity in one dashboard instead of spread across Vercel + Supabase + Resend
- Agent-first CLI (@coduckai/cli) that can script the entire lifecycle — create, push, deploy, database, domains
- Flat, predictable pricing where the plan includes hosting, database, email, and custom domains
## Where v0 is stronger
- Best-in-class UI generation — v0's design output on Next.js/shadcn/Tailwind is widely considered the strongest of any AI builder
- Genuine free tier ($5 in monthly credits) so you can try it with no card
- Native bi-directional GitHub sync with branches and PRs opened straight from chat (added in 2026)
- Deep Vercel ecosystem: deploys to Vercel's first-class hosting, and generated code drops into existing codebases via the shadcn CLI
- Platform API and v0-sdk let developers build their own tools and agents on top of v0's generation engine
## Choose v0 if…
- You care most about UI quality — for landing pages, marketing sites, and design exploration, v0's output is hard to beat
- You want to try before paying: v0's free tier gives you $5 of credits monthly with no card
- You (or your team) work in GitHub and want real two-way sync, branches, and PRs — CoDuck only imports
- You're already on Vercel and want your AI-generated app living in that ecosystem with its hosting and integrations
- You're a developer who wants generated components dropped into an existing codebase via the shadcn CLI, not a whole managed platform
## Choose CoDuck if…
- You're a non-technical founder who wants a complete working product — database, logins, email, payments — without creating accounts at Supabase, Resend, and Stripe and wiring them together
- You want one flat bill instead of v0 credits plus potential Vercel, Supabase, and Resend charges as you grow
- You want to charge customers through your own Stripe account with the integration pre-wired and no platform cut
- You want day-2 operations (logs, analytics, backups, form submissions) in one dashboard, not scattered across vendors
- You or your AI agent want to run the whole thing from a CLI — create, deploy, manage the database, and point domains with scriptable commands
## Pricing
v0's pricing (as of July 2026) is per-user with token-based credits: a Free plan with $5 of monthly credits, Plus at $30/user/month and Business at $100/user/month (each including $30 of monthly credits plus $2 daily on login), and custom Enterprise contracts — heavier generation burns credits faster, and backend services like Supabase or Resend can add their own bills at scale. CoDuck has no free tier but its flat plans bundle everything: Pro $20/mo ($20 AI credits, 100MB database, 5k emails), Plus $100/mo ($100 credits, 1GB DB, 15k emails), and Studio $200/mo ($200 credits, 5GB DB, 50k emails) — hosting, Postgres, custom domains, and email are all included, so the sticker price is closer to your total cost.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from v0 to CoDuck
1. Export your project from v0: use Download ZIP from the project menu (or push it to GitHub first).
2. Create a CoDuck project and import your Next.js code — via GitHub import or `coduck create` + `coduck push` with the CLI.
3. Replace external services with built-ins: CoDuck's Postgres instead of Supabase/Neon, built-in auth instead of Supabase Auth, platform email instead of Resend — or keep your existing env vars temporarily and migrate piece by piece.
4. Deploy with one command or click; your app is live on a coduck.app URL, then point your custom domain (SSL is automatic).
5. Keep iterating by chat or CLI — and export your code anytime, it stays yours.
## FAQ
### Is CoDuck better than v0?
Neither is better across the board. v0 generates the most polished UI of any AI builder and now handles full-stack apps in the Vercel ecosystem, with a free tier and real GitHub sync. CoDuck is better when you want the backend handled for you: database, auth, email, and payments come pre-wired and managed on one flat bill, with an ops dashboard and a CLI that covers everything. Design-first or developer workflows favor v0; complete-product-with-no-wiring favors CoDuck.
### Can v0 build a real app with a database?
Yes — as of 2026 v0 builds full-stack Next.js apps with API routes and server actions, and connects to databases like Supabase, Neon, and Upstash through Vercel's integration marketplace. The key difference is that v0 doesn't provide the database itself: you create and manage accounts with those providers. CoDuck provisions a Postgres database per project as part of the platform.
### Does v0 have a free plan?
Yes. v0's free plan includes $5 of monthly usage credits, deploys to Vercel, and GitHub sync — no credit card required. CoDuck has no free tier; the entry plan is Pro at $20/mo, which includes $20 of AI credits plus hosting, a database, email sending, and custom domains.
### Can I send emails and take payments with v0?
Yes, via integrations: email typically through Resend (your own Resend account and verified domain) and payments through Vercel's Stripe integration, which provisions your API keys while v0 generates the checkout code. With CoDuck both are built in — transactional email from your domain is included in every plan, and your own Stripe account is wired in via Stripe Connect with no platform cut.
### Can I export my code from v0 or CoDuck?
Both. v0 lets you download a ZIP of the full Next.js project, add components to an existing codebase via the shadcn CLI, or sync bi-directionally with GitHub. CoDuck gives you a real Next.js codebase you can read and export anytime — though it currently only imports from GitHub, with no two-way sync.
### Which is cheaper, CoDuck or v0?
For trying things out, v0 — its free tier costs nothing. For running a real product, compare total cost: v0 at $30/user/mo plus whatever your database (Supabase/Neon), email (Resend), and Vercel usage add up to, versus CoDuck's flat $20–$200/mo that already includes hosting, Postgres, email, and domains. As of mid-2026, a solo founder running one production app is often cheaper on CoDuck; a developer only generating UI is cheaper on v0.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/v0*
---
## CoDuck vs Webflow
Source: https://coduck.ai/docs/raw/compare/webflow.md
# CoDuck vs Webflow
> Webflow is a professional designer's CMS; CoDuck is a founder's app builder. Webflow's visual control and CMS are unmatched for content sites, but anything app-shaped means stitching on outside services. CoDuck builds real applications from a prompt and includes the full stack — database, auth, email, payments — in one bill.
Webflow is a professional visual website builder and CMS from Webflow, Inc., used by designers and marketing teams to build custom, code-free marketing sites with managed hosting.
## Feature by feature (July 2026)
| Capability | CoDuck | Webflow |
|---|---|---|
| Email sending | ✅ Built in — transactional email from your domain, 5k–50k/mo included | ⚠️ Partial / via 3rd party — form notifications only; transactional via Postmark/Brevo apps |
| Payments | ✅ Built in — your own Stripe via Connect — CoDuck takes no cut | ⚠️ Partial / via 3rd party — Ecommerce plans from $29/mo; 2% fee on Standard tier; store checkout, not app billing |
| Ops dashboard (logs/analytics/backups) | ✅ Built in — logs, analytics, backups, forms inbox built in | ⚠️ Partial / via 3rd party — backups/versioning native; Analyze analytics from $9/mo add-on; no server logs |
| CLI / agent automation | ✅ Built in — @coduckai/cli covers everything: create, push, deploy, db, domains | ⚠️ Partial / via 3rd party — @webflow/webflow-cli is developer-focused: DevLink, CMS, Cloud deploys |
| Database | ✅ Built in — real Postgres per project | ⚠️ Partial / via 3rd party — CMS collections for content; Cloud D1/KV storage in beta |
| User auth (logins) | ✅ Built in — built-in user accounts | ❌ Not offered — User Accounts sunset Jan 2026; needs Memberstack/Outseta |
| Hosting + SSL | ✅ Built in — managed, included in every plan | ✅ Built in — fast managed hosting on all paid site plans |
| Custom domains | ✅ Built in — included on all plans | ✅ Built in — on paid site plans ($15+/mo) |
| Full-stack app generation | ✅ Built in — prompt → working Next.js app, deployed live | ⚠️ Partial / via 3rd party — visual site builder; Webflow Cloud hosts developer-built Next.js/Astro apps |
| Code export / ownership | ✅ Built in — full Next.js codebase, readable and exportable | ⚠️ Partial / via 3rd party — static HTML/CSS/JS only; CMS content, forms, search and ecommerce don't export |
| GitHub sync | ⚠️ Partial / via 3rd party — import from GitHub; no two-way sync | ⚠️ Partial / via 3rd party — Webflow Cloud deploys apps from GitHub; the visual site itself has no repo sync |
| Free tier / entry price | ❌ Not offered — starts at Pro $20/mo with $20 AI credits included | ✅ Built in — free Starter plan; paid sites from $15/mo |
## Where CoDuck is stronger
- Builds a real application, not just a website: prompt → working Next.js code + Postgres database + live URL in minutes
- Batteries pre-wired on one flat bill: user auth, transactional email from your domain, payments through your own Stripe account (no platform cut), domains, SSL, and an ops dashboard
- Native user accounts — relevant since Webflow sunset its own User Accounts feature in January 2026
- You own the code: read and export the full Next.js codebase, including all app logic — not a static snapshot
- Agent-first CLI (@coduckai/cli): everything the app does is scriptable, so your AI tools can create, push, and deploy projects for you
## Where Webflow is stronger
- Best-in-class visual design control — pixel-perfect layouts, interactions, and animations without writing code
- Mature, powerful CMS: the Premium plan ($25/mo annual) includes up to 20,000 CMS items and 40 collections, ideal for blogs, listings, and content sites
- Free Starter plan and a cheap $15/mo entry point — you can design and prototype before paying anything
- Huge ecosystem: thousands of templates, a large designer community, and an app marketplace (Memberstack, Postmark, Zapier, and more)
- Enterprise-grade marketing stack: built-in Analyze analytics, Optimize A/B testing, localization, and a Team plan for larger orgs
## Choose Webflow if…
- You're building a marketing site, portfolio, or landing pages where visual polish and design control matter more than app logic
- You have a designer (or design taste) and want hand-crafted layouts, animations, and interactions rather than AI-generated ones
- You run a content-heavy site — blog, directory, publication — where Webflow's 20,000-item CMS and editor workflows shine
- You want to start free and grow gradually: Webflow's Starter plan costs $0 and paid hosting starts at $15/mo
- You're a marketing team that needs localization, A/B testing (Optimize), and collaborative editing at enterprise scale
## Choose CoDuck if…
- You're building an app, not a brochure: anything with user logins, dashboards, saved data, or business logic
- You need auth, database, email, and payments working today without stitching together Memberstack, Postmark, Zapier, and Stripe apps
- You want one predictable flat bill instead of a base plan plus per-feature add-ons
- You (or your AI agent) work from the terminal — CoDuck's CLI can script the entire platform
- You want to own and export the complete working codebase, including the backend
## Pricing
Webflow's May 2026 pricing has a free Starter plan, Basic at $15/mo, and Premium at $25/mo (billed annually; $39 monthly), with a $2,500/mo Team tier — but real-world costs stack up through add-ons: Ecommerce from $29/mo (2% transaction fee on the Standard tier), Analyze analytics from $9/mo, Optimize A/B testing from $299/mo, and workspace seats at $15–39 per person. CoDuck has no free tier but its plans are all-inclusive: Pro $20/mo, Plus $100/mo, and Studio $200/mo, each bundling matching AI usage credits, hosting, a Postgres database, custom domains, auth, and email — there are no add-ons, seat fees, or transaction cuts. As of July 2026, a Webflow site needing analytics and a store typically costs more per month than CoDuck Pro; a plain marketing site costs less on Webflow.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Webflow to CoDuck
1. Export what you can from Webflow: your static code (HTML/CSS/JS, paid workspace required) and your CMS content as CSV — note that forms, search, and ecommerce logic won't come with it
2. Create a CoDuck project and either import your exported site or describe it in a prompt — CoDuck rebuilds it as a real Next.js codebase
3. Move your content into the project's Postgres database by pasting your CSV exports into the chat, or load them via `coduck db` from the CLI
4. Turn on the built-in pieces Webflow needed third parties for: user auth, transactional email from your domain, and payments via your own Stripe account
5. Point your custom domain at CoDuck (SSL is automatic), verify everything on the live URL, then cancel your Webflow site plan and add-ons
## FAQ
### Is CoDuck better than Webflow?
For different jobs. Webflow is better for designed marketing websites and CMS content sites — it gives far more visual control. CoDuck is better when you need a working application: it generates real Next.js code with a Postgres database, user login, email, and Stripe payments built in, which Webflow either doesn't do or requires third-party add-ons for.
### Can Webflow build a real web app with a database and login?
Only partially. Webflow's CMS stores content, not application data, and Webflow sunset its native User Accounts (Memberships) feature on January 29, 2026 — logins now require third-party tools like Memberstack or Outseta. Webflow Cloud can host developer-built Next.js/Astro apps, but you have to write that code yourself. CoDuck generates the app, database, and auth from a prompt.
### Can you export your code from Webflow?
Yes, but only the static parts. Webflow exports HTML, CSS, JS, and assets on paid workspace plans — CMS content appears empty, forms stop submitting, site search breaks, and ecommerce doesn't function outside Webflow. CoDuck exports the complete working Next.js codebase including backend logic.
### What happened to Webflow Memberships / User Accounts?
Webflow discontinued the feature. New sites couldn't enable it after January 31, 2025, and it stopped working on all sites on January 29, 2026. Webflow points affected customers to Memberstack and Outseta. If your project needs user accounts, that's now a paid third-party subscription on Webflow — on CoDuck it's built in.
### Does Webflow have a free plan? Does CoDuck?
Webflow has a free Starter plan for building and prototyping, with paid hosting from $15/mo (Basic) and $25/mo annual (Premium). CoDuck has no free tier — plans start at Pro, $20/mo, which includes $20 of AI generation credits plus hosting, database, auth, email, and custom domains with nothing extra to buy.
### How do I move from Webflow to CoDuck?
Export your static code and CMS CSVs from Webflow, then create a CoDuck project and either import the site or describe it in a prompt. CoDuck rebuilds it as a real Next.js app; you then load your content into its Postgres database, enable auth/email/Stripe as needed, and point your domain. Most simple sites move in an afternoon.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/webflow*
---
## CoDuck vs Wix
Source: https://coduck.ai/docs/raw/compare/wix.md
# CoDuck vs Wix
> Wix helps you make a website; CoDuck hands you a running product. Wix's editor and ecosystem are mature and cheap to start, but real app functionality lives behind add-ons and app-market subscriptions. CoDuck's plans include the database, user accounts, email, payments, and hosting outright — and the code is genuinely yours to export.
Wix is a mainstream drag-and-drop website builder from Wix.com Ltd., with AI site generation (Wix Harmony), a built-in CMS, e-commerce, and a large app market, aimed at businesses that want a polished website without code.
## Feature by feature (July 2026)
| Capability | CoDuck | Wix |
|---|---|---|
| Transactional email from your domain | ✅ Built in — SES-backed, 5k–50k emails/mo by plan | ⚠️ Partial / via 3rd party — Triggered/automation emails share the marketing quota |
| Payments | ✅ Built in — Your own Stripe account via Stripe Connect — CoDuck takes no cut | ✅ Built in — Wix Payments (2.9% + $0.30); requires Core plan or higher |
| Ops dashboard (logs, analytics, backups) | ✅ Built in — Logs, analytics, backups, forms inbox in one place | ⚠️ Partial / via 3rd party — Analytics + Site History built in; app/code logs need external tooling |
| CLI / agent automation | ✅ Built in — @coduckai/cli — create, push, deploy, db, domains | ⚠️ Partial / via 3rd party — Wix CLI covers Velo site code, not full account ops |
| Database | ✅ Built in — Dedicated Postgres per project | ⚠️ Partial / via 3rd party — CMS collections (10 GB on most plans), not a raw SQL database you control |
| User auth / logins | ✅ Built in — Built-in user accounts, no setup | ✅ Built in — Members Area for member login pages |
| Hosting + SSL | ✅ Built in — Managed, included on every plan | ✅ Built in — Managed hosting and SSL included |
| Custom domains | ✅ Built in — All plans, auto-SSL, www covered | ✅ Built in — Paid plans only; free domain for year 1 on annual billing |
| Full-stack app generation from a prompt | ✅ Built in — Real Next.js codebase, deployed live in minutes | ⚠️ Partial / via 3rd party — AI (Harmony/Aria) builds websites; app logic needs Velo code on Wix's runtime |
| Code export / ownership | ✅ Built in — Readable Next.js code, export anytime | ❌ Not offered — No official export; sites only run on Wix's proprietary engine |
| GitHub sync | ⚠️ Partial / via 3rd party — Import from GitHub; no two-way sync yet | ⚠️ Partial / via 3rd party — Git integration syncs Velo code only — design stays in Wix's editor |
| Free tier | ❌ Not offered — Starts at Pro $20/mo, everything included | ✅ Built in — Free forever plan with Wix ads + wixsite.com subdomain |
## Where CoDuck is stronger
- Generates a real, readable Next.js codebase — not a proprietary page format — and deploys it live in minutes.
- Batteries included and managed: Postgres database, user auth, transactional email from your domain, and Stripe payments pre-wired on one flat bill.
- Payments run through your own Stripe account via Stripe Connect — CoDuck takes no cut of your revenue.
- Agent-first CLI (@coduckai/cli): everything the app does is scriptable, so your AI tools can create, push, and deploy projects for you.
- Full code export: you can take your app and run it anywhere, so you're never locked in.
## Where Wix is stronger
- A genuine free-forever plan, so you can publish a site (with Wix ads on a wixsite.com subdomain) without paying anything.
- Mature, mainstream platform: hundreds of templates, a large app market, and years of polish behind the drag-and-drop editor.
- Strong AI tooling in 2026 — Wix Harmony's Aria agent builds and refines sites conversationally, alongside 20+ AI features for content, images, and marketing.
- A complete e-commerce suite (stores, bookings, restaurants, events) with Wix Payments handling checkout end to end.
- Built-in marketing stack: SEO tools, email campaigns, analytics, and Site History backups without installing anything.
## Choose Wix if…
- You want a classic business website, portfolio, or blog — Wix's templates and drag-and-drop editor are built precisely for that.
- You need to start completely free and are fine with Wix ads on a subdomain until you upgrade.
- You're running a store, bookings, or restaurant ordering — Wix's e-commerce suite handles these out of the box.
- You want pixel-level visual control over a marketing site without touching any code.
- You value a large, established company with extensive support docs, an app market, and years of platform stability.
## Choose CoDuck if…
- You're building an actual web app — dashboards, user accounts, custom logic, data models — not a brochure site.
- You want to own the code: read it, export it, and move hosts if you ever outgrow the platform.
- You want payments through your own Stripe account with no platform cut.
- You (or your AI agent) want to automate everything from the terminal with a real CLI.
- You want one predictable flat bill that already includes database, auth, email, domains, and hosting.
## Pricing
Wix has a free-forever plan (Wix ads, wixsite.com subdomain), with premium plans as of July 2026 at Light $17/mo, Core $29/mo, Business $39/mo, and Business Elite $159/mo on annual billing — note that accepting payments requires at least the Core plan, and Wix Payments charges standard processing fees of 2.9% + $0.30. CoDuck has no free tier: Pro is $20/mo (with $20 of AI usage credits, 100MB database, 5k emails/mo), Plus $100/mo, and Studio $200/mo — but every plan already includes hosting, a Postgres database, auth, custom domains, and email, so the sticker price is closer to the all-in price than Wix's, where apps and upgrades add up.
CoDuck plans: Pro $20/mo, Plus $100/mo, Studio $200/mo — every plan includes hosting, a per-project Postgres database, custom domains, and email sending. Full details: https://coduck.ai/pricing
## Switching from Wix to CoDuck
1. Export what Wix lets you export: store products, contacts, and orders as CSV, plus your blog via the XML export — Wix has no full-site or code export.
2. Point CoDuck at your live Wix site with the import-a-site feature (or just describe what you want) and let it generate a real Next.js version.
3. Load your content and data into your project's Postgres database, and re-create forms, logins, and payments with CoDuck's built-in auth, email, and Stripe Connect.
4. Connect your custom domain in CoDuck (SSL is automatic) and verify everything on your live URL.
5. Cancel your Wix premium plan once traffic is flowing to the new site — and keep your Wix account until the domain transfer/DNS switch is fully confirmed.
## FAQ
### Is CoDuck better than Wix?
For custom web apps, yes: CoDuck generates a real Next.js codebase with a Postgres database, auth, email, and Stripe payments built in, and you can export the code. For a classic business website or online store, Wix is often the better choice — it's more mature, has a free tier, and its drag-and-drop editor gives finer visual control.
### Can Wix build a real web app with a database?
Partially. Wix has CMS collections (a managed content database) and Velo for custom code, so simple apps are possible. But it's not a raw SQL database you control, the site only runs on Wix's proprietary engine, and there's no way to export a working codebase. CoDuck gives each project its own Postgres database and real, exportable Next.js code.
### Can I export my website code from Wix?
No. Wix has no official code or HTML export — sites are rendered by Wix's proprietary engine and can't run elsewhere. Its Git integration syncs Velo code only, not the site itself. CoDuck projects are standard Next.js codebases you can export and host anywhere.
### Does Wix have a free plan? Does CoDuck?
Wix has a free-forever plan with Wix ads on a wixsite.com subdomain; custom domains and payments require paid plans (payments need Core, $29/mo). CoDuck has no free tier — plans start at Pro $20/mo, which includes hosting, database, auth, email, and custom domains.
### Does Wix take a cut of my payments?
Wix Payments charges standard processing fees (2.9% + $0.30 as of 2026, plus surcharges on international cards) and requires at least the Core plan. CoDuck wires payments through your own Stripe account via Stripe Connect, so you pay only Stripe's fees — CoDuck takes no cut.
### Which should a startup founder use, Wix or CoDuck?
If your product IS the website (a local business, portfolio, or store), Wix gets you there cheaply and reliably. If your product is software — users log in, data lives in a database, you'll iterate on features — CoDuck builds that as real code you own, with the infrastructure already wired up.
---
*Competitor details verified against public sources in July 2026. Full interactive comparison: https://coduck.ai/compare/wix*
---