Fetcha v0.1.0 — public preview: monorepo (web, api, core, db, providers, routing, email, sdk) · 6b215c2 · fetcha

added .env.example +34 −0

++# ---- Core ----
++NODE_ENV=development
++DATABASE_URL=postgres://localhost:5432/fetcha
++REDIS_URL=redis://127.0.0.1:6379
++AUTH_SECRET=change-me-32-bytes-minimum
++# Public URL of the web app (marketing + dashboard) and the API
++WEB_URL=http://localhost:8220
++API_URL=http://127.0.0.1:8221
++NEXT_PUBLIC_SITE_URL=http://localhost:8220
++NEXT_PUBLIC_API_URL=http://localhost:8220
++API_PORT=8221
++WEB_PORT=8220
++# Shared secret between the web app and the API (playground, internal calls)
++INTERNAL_SERVICE_TOKEN=change-me
++
++# ---- Email (Resend) ----
++RESEND_API_KEY=
++EMAIL_FROM="Fetcha <hello@fetcha.co>"
++EMAIL_FROM_TRANSACTIONAL="Fetcha <notifications@fetcha.co>"
++
++# ---- Billing (Stripe, optional in V1) ----
++STRIPE_SECRET_KEY=
++STRIPE_WEBHOOK_SECRET=
++
++# ---- Upstream providers (never exposed to customers) ----
++DECODO_USERNAME=
++DECODO_PASSWORD=
++OXYLABS_USERNAME=
++OXYLABS_PASSWORD=
++SOAX_USERNAME=
++SOAX_PASSWORD=
++
++# ---- Admin ----
++ADMIN_EMAILS=you@example.com

added .github/workflows/ci.yml +43 −0

++name: CI
++on:
++  push:
++    branches: [main]
++  pull_request:
++jobs:
++  verify:
++    runs-on: ubuntu-latest
++    services:
++      postgres:
++        image: postgres:17-alpine
++        env: { POSTGRES_USER: fetcha, POSTGRES_PASSWORD: fetcha, POSTGRES_DB: fetcha }
++        ports: ["5432:5432"]
++        options: --health-cmd pg_isready --health-interval 5s --health-timeout 5s --health-retries 10
++      redis:
++        image: redis:7-alpine
++        ports: ["6379:6379"]
++    env:
++      DATABASE_URL: postgres://fetcha:fetcha@localhost:5432/fetcha
++      REDIS_URL: redis://localhost:6379
++      AUTH_SECRET: ci-secret-0123456789abcdef0123456789abcdef
++      INTERNAL_SERVICE_TOKEN: ci-internal
++      NEXT_PUBLIC_SITE_URL: http://localhost:8220
++      NEXT_TELEMETRY_DISABLED: "1"
++    steps:
++      - uses: actions/checkout@v4
++      - uses: pnpm/action-setup@v4
++        with: { version: 11 }
++      - uses: actions/setup-node@v4
++        with: { node-version: 22, cache: pnpm }
++      - run: pnpm install --frozen-lockfile
++      - name: Lint
++        run: pnpm --filter @fetcha/web lint
++      - name: Typecheck
++        run: pnpm typecheck
++      - name: Migrate
++        run: pnpm db:migrate && pnpm db:seed
++      - name: Unit tests
++        run: pnpm test
++      - name: Security audit (high+)
++        run: pnpm audit --audit-level high || true
++      - name: Build
++        run: pnpm build

added .gitignore +17 −0

++node_modules/
++.next/
++dist/
++*.tsbuildinfo
++.env
++.env.*
++!.env.example
++logs/
++tmp/
++coverage/
++.DS_Store
++.turbo/
++.claude/
++qa/
++deploy/fetcha.mld.json
++apps/web/next-env.d.ts
++qa/node_modules/

added CLAUDE.md +30 −0

++# Fetcha — repository guide
++
++Fetcha (www.fetcha.co) is "Intelligent Web Access Infrastructure": one API (`POST /v1/fetch`) that routes web requests
++across upstream proxy networks (Oxylabs, Decodo, SOAX — never exposed to customers) with smart routing, retries,
++sticky sessions, usage metering and a full dashboard.
++
++## Layout
++- `apps/web` — Next.js 16 (marketing site, docs, auth, customer dashboard, admin). Port 8220. Proxies `/v1/*` to the API.
++- `apps/api` — Fastify API service (public `/v1/*`, `/health`, `/ready`, internal `/internal/*` for the dashboard). Port 8221.
++- `packages/core` — zod schemas, error codes, ids/api-key hashing, SSRF policy, geo model, plan limits.
++- `packages/db` — Drizzle schema + migrations (`drizzle/`), `pnpm db:generate|migrate|seed`.
++- `packages/providers` — `ProxyProvider` interface + adapters (oxylabs, decodo, soax, direct). Provider code lives ONLY here.
++- `packages/routing` — circuit breaker, routing score, `FetchExecutor` (attempt loop, block detection, escalation).
++- `packages/email` — Resend abstraction + React Email templates. `packages/sdk` (JS), `sdk-python/` (Python).
++- `docs/AGENT-BRIEF.md` — product/engineering rules used when generating UI.
++
++## Rules
++- Never expose provider names, credentials or provider error text to customers. Public debug output uses aliases (network-a/b/c).
++- Every external URL goes through `assertUrlAllowed()` (SSRF) — including redirects.
++- Business logic in server actions / `apps/api` / packages, not in React components.
++- API keys: shown once, SHA-256 stored. Request IDs `req_…` on every response (`X-Fetcha-Request-ID`).
++- Not implemented yet (say so, don't fake): browser mode, `/v1/extract`, Stripe checkout, teams, webhook delivery, OAuth, 2FA.
++
++## Dev
++`cp .env.example .env` (fill provider creds + RESEND_API_KEY), `createdb fetcha`, `pnpm db:migrate && pnpm db:seed`,
++`pnpm dev:api` + `pnpm dev:web`. Tests: `pnpm test`. Dev seed: `cd scripts && npx tsx dev-seed.ts you@example.com` prints an API key.
++
++## Deploy (MacLustr)
++Deployed by `mld` (gateway M1M32) on M3U96a: web 8220 + api 8221, Postgres 17 `fetcha` + Redis local, ngrok `www.fetcha.co`.
++Manifest: `deploy/fetcha.mld.json` → `M1M32:~/dispatch/apps/fetcha.json`. See `deploy/README.md`.

added README.md +41 −0

++<p align="center"><img src="apps/web/public/icon.svg" width="56" alt="Fetcha" /></p>
++<h1 align="center">Fetcha</h1>
++<p align="center"><strong>Intelligent Web Access Infrastructure</strong><br/>One API. Multiple proxy networks. Reliable web access.</p>
++
++```bash
++curl https://www.fetcha.co/v1/fetch -X POST \
++  -H "Authorization: Bearer $FETCHA_API_KEY" \
++  -H "Content-Type: application/json" \
++  -d '{"url": "https://example.com", "country": "CA"}'
++```
++
++Fetcha takes a URL and figures out how to access it: which network class, which geography, whether a sticky session is
++needed, when to retry and how to escalate — behind a single, provider-agnostic API with request IDs, usage metering,
++a Playground and full request logs.
++
++## Monorepo
++| Path | What |
++|---|---|
++| `apps/web` | Next.js 16 — marketing site, docs, auth (Better Auth), dashboard, admin |
++| `apps/api` | Fastify — public `/v1/*` API, health, internal endpoints for the dashboard |
++| `packages/core` | Schemas, errors, SSRF policy, plans, ids |
++| `packages/db` | Drizzle ORM schema + migrations (PostgreSQL) |
++| `packages/providers` | Provider adapters (interchangeable, isolated) |
++| `packages/routing` | Routing score, circuit breakers, execution engine |
++| `packages/email` | Resend abstraction + React Email templates |
++| `packages/sdk`, `sdk-python` | Official SDKs (JS/TS, Python) |
++
++## Quick start (local)
++```bash
++pnpm install
++cp .env.example .env            # fill DATABASE_URL, REDIS_URL, AUTH_SECRET, RESEND_API_KEY, provider credentials
++createdb fetcha && pnpm db:migrate && pnpm db:seed
++pnpm dev:api &                  # http://127.0.0.1:8221
++pnpm dev:web                    # http://localhost:8220
++```
++Tests: `pnpm test` · Typecheck: `pnpm typecheck` · Build: `pnpm build`.
++
++## Status (v0.1.0 — public preview)
++Live: Fetch API, auto routing (residential network class), sticky sessions, Playground, request logs, usage metering,
++API keys, projects, admin console, docs, SDK source. Coming: managed browser, structured extraction, Stripe checkout,
++teams, webhooks. See `/changelog`.

added apps/api/package.json +31 −0

++{
++  "name": "@fetcha/api",
++  "version": "0.1.0",
++  "private": true,
++  "type": "module",
++  "scripts": {
++    "dev": "tsx watch src/server.ts",
++    "start": "tsx src/server.ts",
++    "typecheck": "tsc -p tsconfig.json --noEmit",
++    "test": "vitest run --passWithNoTests"
++  },
++  "dependencies": {
++    "@fastify/cors": "^11.0.0",
++    "@fetcha/core": "workspace:*",
++    "@fetcha/db": "workspace:*",
++    "@fetcha/email": "workspace:*",
++    "@fetcha/providers": "workspace:*",
++    "@fetcha/routing": "workspace:*",
++    "fastify": "^5.4.0",
++    "ioredis": "^5.6.0",
++    "pino": "^9.7.0",
++    "pino-pretty": "^13.0.0",
++    "tsx": "^4.20.0",
++    "zod": "^4.0.0"
++  },
++  "devDependencies": {
++    "@types/node": "^24.0.0",
++    "typescript": "^5.9.3",
++    "vitest": "^3.2.0"
++  }
++}

added apps/api/src/auth.ts +194 −0

++import { FetchaError, hashApiKey, parseApiKeyMode, safeEqual, type ApiKeyScope, type Plan } from "@fetcha/core";
++import { apiKeys, db, eq, organizations, projects, sql, users } from "@fetcha/db";
++import { config } from "./config";
++import { getKV } from "./redis";
++
++export interface ApiPrincipal {
++  keyId: string | null;
++  keyName: string | null;
++  mode: "live" | "test";
++  scopes: ApiKeyScope[];
++  organizationId: string;
++  organizationName: string;
++  plan: Plan;
++  providerVisibility: boolean;
++  suspended: boolean;
++  orgSoftLimitUsd: number | null;
++  orgHardLimitUsd: number | null;
++  projectId: string;
++  projectName: string;
++  projectLogLevel: "none" | "metadata" | "headers" | "full";
++  projectSoftLimitUsd: number | null;
++  projectHardLimitUsd: number | null;
++  projectMonthlyRequestLimit: number | null;
++  ownerEmail: string;
++  ownerVerified: boolean;
++  /** Playground / dashboard calls (service token) — bypass email verification for limited use. */
++  internal: boolean;
++}
++
++const CACHE_TTL_SEC = 30;
++
++async function loadPrincipalByKeyHash(hash: string): Promise<ApiPrincipal | null> {
++  const [row] = await db
++    .select({
++      keyId: apiKeys.id,
++      keyName: apiKeys.name,
++      mode: apiKeys.mode,
++      scopes: apiKeys.scopes,
++      expiresAt: apiKeys.expiresAt,
++      revokedAt: apiKeys.revokedAt,
++      organizationId: organizations.id,
++      organizationName: organizations.name,
++      plan: organizations.plan,
++      providerVisibility: organizations.providerVisibility,
++      suspended: organizations.suspended,
++      orgSoft: organizations.softLimitUsd,
++      orgHard: organizations.hardLimitUsd,
++      projectId: projects.id,
++      projectName: projects.name,
++      logLevel: projects.logLevel,
++      projSoft: projects.softLimitUsd,
++      projHard: projects.hardLimitUsd,
++      projMonthly: projects.monthlyRequestLimit,
++      archivedAt: projects.archivedAt,
++      ownerEmail: users.email,
++      ownerVerified: users.emailVerified,
++      ownerBanned: users.banned,
++    })
++    .from(apiKeys)
++    .innerJoin(projects, eq(apiKeys.projectId, projects.id))
++    .innerJoin(organizations, eq(apiKeys.organizationId, organizations.id))
++    .innerJoin(users, eq(organizations.ownerUserId, users.id))
++    .where(eq(apiKeys.keyHash, hash))
++    .limit(1);
++  if (!row) return null;
++  if (row.revokedAt) throw new FetchaError("INVALID_API_KEY", "This API key was revoked.");
++  if (row.expiresAt && row.expiresAt.getTime() < Date.now()) throw new FetchaError("INVALID_API_KEY", "This API key has expired.");
++  if (row.archivedAt) throw new FetchaError("FORBIDDEN", "This project is archived.");
++  if (row.ownerBanned) throw new FetchaError("FORBIDDEN", "This account is suspended.");
++  return {
++    keyId: row.keyId,
++    keyName: row.keyName,
++    mode: row.mode as "live" | "test",
++    scopes: (row.scopes ?? []) as ApiKeyScope[],
++    organizationId: row.organizationId,
++    organizationName: row.organizationName,
++    plan: row.plan as Plan,
++    providerVisibility: row.providerVisibility,
++    suspended: row.suspended,
++    orgSoftLimitUsd: row.orgSoft,
++    orgHardLimitUsd: row.orgHard,
++    projectId: row.projectId,
++    projectName: row.projectName,
++    projectLogLevel: row.logLevel as ApiPrincipal["projectLogLevel"],
++    projectSoftLimitUsd: row.projSoft,
++    projectHardLimitUsd: row.projHard,
++    projectMonthlyRequestLimit: row.projMonthly,
++    ownerEmail: row.ownerEmail,
++    ownerVerified: row.ownerVerified,
++    internal: false,
++  };
++}
++
++export async function authenticateApiKey(authorization: string | undefined, xApiKey?: string): Promise<ApiPrincipal> {
++  let token = xApiKey?.trim();
++  if (!token && authorization) {
++    const m = authorization.match(/^Bearer\s+(.+)$/i);
++    token = m?.[1]?.trim();
++  }
++  if (!token) throw new FetchaError("INVALID_API_KEY", "Missing API key. Send `Authorization: Bearer fch_live_…`.");
++  if (!parseApiKeyMode(token) || token.length < 20 || token.length > 128) throw new FetchaError("INVALID_API_KEY", "Malformed API key.");
++  const hash = hashApiKey(token);
++  const kv = getKV();
++  const cacheKey = `fch:key:${hash}`;
++  const cached = await kv.get(cacheKey).catch(() => null);
++  let principal: ApiPrincipal | null = null;
++  if (cached) {
++    if (cached === "invalid") throw new FetchaError("INVALID_API_KEY");
++    principal = JSON.parse(cached) as ApiPrincipal;
++  } else {
++    principal = await loadPrincipalByKeyHash(hash);
++    await kv.set(cacheKey, principal ? JSON.stringify(principal) : "invalid", CACHE_TTL_SEC).catch(() => {});
++  }
++  if (!principal) throw new FetchaError("INVALID_API_KEY");
++  if (principal.suspended) throw new FetchaError("FORBIDDEN", "This organization is suspended. Contact support@fetcha.co.");
++  if (!principal.ownerVerified) throw new FetchaError("EMAIL_NOT_VERIFIED");
++  // Fire-and-forget last-used update, throttled by the cache TTL.
++  const luKey = `fch:key:lu:${principal.keyId}`;
++  if (!(await kv.get(luKey).catch(() => "1"))) {
++    await kv.set(luKey, "1", 60).catch(() => {});
++    db.update(apiKeys).set({ lastUsedAt: new Date() }).where(eq(apiKeys.id, principal.keyId!)).catch(() => {});
++  }
++  return principal;
++}
++
++export function requireScope(p: ApiPrincipal, scope: ApiKeyScope): void {
++  if (p.internal) return;
++  if (!p.scopes.includes(scope)) throw new FetchaError("FORBIDDEN", `This API key lacks the "${scope}" scope.`);
++}
++
++/** Internal service authentication (dashboard → API). */
++export function assertInternalToken(header: string | undefined): void {
++  const token = header?.replace(/^Bearer\s+/i, "").trim();
++  if (!config.internalToken || !token || !safeEqual(token, config.internalToken)) {
++    throw new FetchaError("FORBIDDEN", "Invalid internal service token.");
++  }
++}
++
++/** Build a principal for a project on behalf of the dashboard (playground). */
++export async function principalForProject(projectId: string, userId: string): Promise<ApiPrincipal> {
++  const [row] = await db
++    .select({
++      organizationId: organizations.id,
++      organizationName: organizations.name,
++      plan: organizations.plan,
++      providerVisibility: organizations.providerVisibility,
++      suspended: organizations.suspended,
++      orgSoft: organizations.softLimitUsd,
++      orgHard: organizations.hardLimitUsd,
++      projectId: projects.id,
++      projectName: projects.name,
++      logLevel: projects.logLevel,
++      projSoft: projects.softLimitUsd,
++      projHard: projects.hardLimitUsd,
++      projMonthly: projects.monthlyRequestLimit,
++      ownerEmail: users.email,
++      ownerVerified: users.emailVerified,
++      isMember: sql<boolean>`exists (select 1 from organization_members m where m.organization_id = ${organizations.id} and m.user_id = ${userId})`,
++    })
++    .from(projects)
++    .innerJoin(organizations, eq(projects.organizationId, organizations.id))
++    .innerJoin(users, eq(organizations.ownerUserId, users.id))
++    .where(eq(projects.id, projectId))
++    .limit(1);
++  if (!row) throw new FetchaError("NOT_FOUND", "Project not found.");
++  if (!row.isMember) throw new FetchaError("FORBIDDEN");
++  if (row.suspended) throw new FetchaError("FORBIDDEN", "This organization is suspended.");
++  return {
++    keyId: null,
++    keyName: null,
++    mode: "live",
++    scopes: ["fetch:execute", "sessions:write", "usage:read"],
++    organizationId: row.organizationId,
++    organizationName: row.organizationName,
++    plan: row.plan as Plan,
++    providerVisibility: row.providerVisibility,
++    suspended: row.suspended,
++    orgSoftLimitUsd: row.orgSoft,
++    orgHardLimitUsd: row.orgHard,
++    projectId: row.projectId,
++    projectName: row.projectName,
++    projectLogLevel: row.logLevel as ApiPrincipal["projectLogLevel"],
++    projectSoftLimitUsd: row.projSoft,
++    projectHardLimitUsd: row.projHard,
++    projectMonthlyRequestLimit: row.projMonthly,
++    ownerEmail: row.ownerEmail,
++    ownerVerified: row.ownerVerified,
++    internal: true,
++  };
++}
++
++export async function invalidateKeyCache(keyHash: string): Promise<void> {
++  await getKV().del(`fch:key:${keyHash}`).catch(() => {});
++}

added apps/api/src/config.ts +24 −0

++export const config = {
++  env: process.env.NODE_ENV ?? "development",
++  port: Number(process.env.API_PORT ?? 8221),
++  host: process.env.API_HOST ?? "127.0.0.1",
++  webUrl: (process.env.WEB_URL ?? process.env.NEXT_PUBLIC_SITE_URL ?? "http://localhost:8220").replace(/\/$/, ""),
++  redisUrl: process.env.REDIS_URL ?? "",
++  internalToken: process.env.INTERNAL_SERVICE_TOKEN ?? "",
++  logLevel: process.env.LOG_LEVEL ?? "info",
++  /** Store response bodies for playground inspection (never for API by default). */
++  storeBodies: process.env.FETCHA_STORE_BODIES === "1",
++  healthProbeIntervalMs: Number(process.env.HEALTH_PROBE_INTERVAL_MS ?? 5 * 60_000),
++  maxResponseBytesDefault: Number(process.env.MAX_RESPONSE_BYTES ?? 20_000_000),
++  /** Multiplier over upstream cost used for customer pricing when a plan has no explicit unit price. */
++  defaultMargin: Number(process.env.FETCHA_DEFAULT_MARGIN ?? 2.5),
++  version: process.env.FETCHA_VERSION ?? "0.1.0",
++} as const;
++
++export function assertProductionConfig(): void {
++  if (config.env !== "production") return;
++  const missing: string[] = [];
++  if (!process.env.DATABASE_URL) missing.push("DATABASE_URL");
++  if (!config.internalToken || config.internalToken === "change-me") missing.push("INTERNAL_SERVICE_TOKEN");
++  if (missing.length) throw new Error(`Missing required production configuration: ${missing.join(", ")}`);
++}

added apps/api/src/limits.ts +98 −0

++import { FetchaError, PLAN_LIMITS } from "@fetcha/core";
++import { db, sql, usageEvents } from "@fetcha/db";
++import type { ApiPrincipal } from "./auth";
++import { getKV } from "./redis";
++
++const CONCURRENCY_TTL_SEC = 150; // safety net if a release is lost
++
++/** Reserve a concurrency slot for the organization. Returns a release function. */
++export async function acquireConcurrency(p: ApiPrincipal): Promise<() => Promise<void>> {
++  const kv = getKV();
++  const limit = PLAN_LIMITS[p.plan].concurrency;
++  const key = `fch:conc:${p.organizationId}`;
++  const n = await kv.incrWithTtl(key, CONCURRENCY_TTL_SEC);
++  if (n > limit) {
++    await kv.decr(key);
++    throw new FetchaError("CONCURRENCY_LIMIT", `Your plan allows ${limit} concurrent requests.`, { details: { limit } });
++  }
++  let released = false;
++  return async () => {
++    if (released) return;
++    released = true;
++    await kv.decr(key).catch(() => {});
++  };
++}
++
++/** Sliding-window rate limits: per key (burst), per organization (sustained), per IP (anonymous abuse). */
++export async function checkRateLimits(p: ApiPrincipal, ip: string | null): Promise<void> {
++  const kv = getKV();
++  const limits = PLAN_LIMITS[p.plan];
++  const perMinute = Math.max(60, limits.concurrency * 60); // generous: concurrency is the real cap
++  const checks: Array<Promise<{ allowed: boolean; retryAfterMs: number }>> = [
++    kv.slidingWindow(`fch:rl:org:${p.organizationId}`, 60_000, perMinute),
++  ];
++  if (p.keyId) checks.push(kv.slidingWindow(`fch:rl:key:${p.keyId}`, 1_000, Math.max(10, limits.concurrency * 2)));
++  if (ip) checks.push(kv.slidingWindow(`fch:rl:ip:${ip}`, 1_000, 200));
++  const results = await Promise.all(checks);
++  const blocked = results.find((r) => !r.allowed);
++  if (blocked) throw new FetchaError("RATE_LIMITED", undefined, { details: { retry_after_ms: blocked.retryAfterMs } });
++}
++
++export interface MonthlyUsage {
++  requests: number;
++  spendUsd: number;
++  projectRequests: number;
++  projectSpendUsd: number;
++}
++
++export async function monthlyUsage(p: ApiPrincipal): Promise<MonthlyUsage> {
++  const kv = getKV();
++  const cacheKey = `fch:usage:${p.organizationId}:${p.projectId}`;
++  const cached = await kv.get(cacheKey).catch(() => null);
++  if (cached) return JSON.parse(cached) as MonthlyUsage;
++  const start = new Date();
++  start.setUTCDate(1);
++  start.setUTCHours(0, 0, 0, 0);
++  const [org] = await db
++    .select({
++      requests: sql<number>`coalesce(sum(case when ${usageEvents.metric} = 'request' then ${usageEvents.quantity} else 0 end), 0)::float`,
++      spend: sql<number>`coalesce(sum(${usageEvents.costUsd}), 0)::float`,
++    })
++    .from(usageEvents)
++    .where(sql`${usageEvents.organizationId} = ${p.organizationId} and ${usageEvents.createdAt} >= ${start}`);
++  const [proj] = await db
++    .select({
++      requests: sql<number>`coalesce(sum(case when ${usageEvents.metric} = 'request' then ${usageEvents.quantity} else 0 end), 0)::float`,
++      spend: sql<number>`coalesce(sum(${usageEvents.costUsd}), 0)::float`,
++    })
++    .from(usageEvents)
++    .where(sql`${usageEvents.projectId} = ${p.projectId} and ${usageEvents.createdAt} >= ${start}`);
++  const usage: MonthlyUsage = { requests: Number(org?.requests ?? 0), spendUsd: Number(org?.spend ?? 0), projectRequests: Number(proj?.requests ?? 0), projectSpendUsd: Number(proj?.spend ?? 0) };
++  await kv.set(cacheKey, JSON.stringify(usage), 20).catch(() => {});
++  return usage;
++}
++
++/** Enforce plan quota and hard spending limits. Soft limits are handled by the alerting job. */
++export async function checkMonthlyLimits(p: ApiPrincipal): Promise<MonthlyUsage> {
++  const usage = await monthlyUsage(p);
++  const limits = PLAN_LIMITS[p.plan];
++  if (usage.requests >= limits.monthly_requests) {
++    throw new FetchaError("USAGE_LIMIT_REACHED", `Monthly request quota of ${limits.monthly_requests.toLocaleString("en-US")} reached for the ${limits.label} plan.`, {
++      details: { limit: limits.monthly_requests, used: usage.requests },
++    });
++  }
++  if (p.projectMonthlyRequestLimit && usage.projectRequests >= p.projectMonthlyRequestLimit) {
++    throw new FetchaError("USAGE_LIMIT_REACHED", "Project monthly request limit reached.", { details: { limit: p.projectMonthlyRequestLimit, used: usage.projectRequests } });
++  }
++  if (p.orgHardLimitUsd !== null && usage.spendUsd >= p.orgHardLimitUsd) {
++    throw new FetchaError("USAGE_LIMIT_REACHED", "Organization hard spending limit reached.", { details: { limit_usd: p.orgHardLimitUsd, spent_usd: usage.spendUsd } });
++  }
++  if (p.projectHardLimitUsd !== null && usage.projectSpendUsd >= p.projectHardLimitUsd) {
++    throw new FetchaError("USAGE_LIMIT_REACHED", "Project hard spending limit reached.", { details: { limit_usd: p.projectHardLimitUsd, spent_usd: usage.projectSpendUsd } });
++  }
++  return usage;
++}
++
++export async function invalidateUsageCache(organizationId: string, projectId: string): Promise<void> {
++  await getKV().del(`fch:usage:${organizationId}:${projectId}`).catch(() => {});
++}

added apps/api/src/redis.ts +133 −0

++import Redis from "ioredis";
++import { config } from "./config";
++
++/**
++ * Redis client with an in-memory fallback for local development. Production requires
++ * REDIS_URL — the fallback logs a warning and only works within a single process.
++ */
++export interface KV {
++  incrWithTtl(key: string, ttlSec: number): Promise<number>;
++  decr(key: string): Promise<number>;
++  get(key: string): Promise<string | null>;
++  set(key: string, value: string, ttlSec?: number): Promise<void>;
++  del(key: string): Promise<void>;
++  /** Sliding-window counter: returns count within window after adding one hit. */
++  slidingWindow(key: string, windowMs: number, limit: number): Promise<{ count: number; allowed: boolean; retryAfterMs: number }>;
++  ping(): Promise<boolean>;
++  kind: "redis" | "memory";
++}
++
++class MemoryKV implements KV {
++  kind = "memory" as const;
++  private store = new Map<string, { v: string; exp: number | null }>();
++  private windows = new Map<string, number[]>();
++
++  private alive(k: string) {
++    const e = this.store.get(k);
++    if (!e) return null;
++    if (e.exp !== null && e.exp < Date.now()) {
++      this.store.delete(k);
++      return null;
++    }
++    return e;
++  }
++  async incrWithTtl(key: string, ttlSec: number) {
++    const e = this.alive(key);
++    const n = (e ? Number(e.v) : 0) + 1;
++    this.store.set(key, { v: String(n), exp: e?.exp ?? Date.now() + ttlSec * 1000 });
++    return n;
++  }
++  async decr(key: string) {
++    const e = this.alive(key);
++    const n = Math.max(0, (e ? Number(e.v) : 0) - 1);
++    if (e) this.store.set(key, { v: String(n), exp: e.exp });
++    return n;
++  }
++  async get(key: string) {
++    return this.alive(key)?.v ?? null;
++  }
++  async set(key: string, value: string, ttlSec?: number) {
++    this.store.set(key, { v: value, exp: ttlSec ? Date.now() + ttlSec * 1000 : null });
++  }
++  async del(key: string) {
++    this.store.delete(key);
++  }
++  async slidingWindow(key: string, windowMs: number, limit: number) {
++    const now = Date.now();
++    const arr = (this.windows.get(key) ?? []).filter((t) => t > now - windowMs);
++    arr.push(now);
++    this.windows.set(key, arr);
++    const allowed = arr.length <= limit;
++    return { count: arr.length, allowed, retryAfterMs: allowed ? 0 : Math.max(0, arr[0]! + windowMs - now) };
++  }
++  async ping() {
++    return true;
++  }
++}
++
++class RedisKV implements KV {
++  kind = "redis" as const;
++  constructor(readonly client: Redis) {}
++  async incrWithTtl(key: string, ttlSec: number) {
++    const res = await this.client.multi().incr(key).expire(key, ttlSec, "NX").exec();
++    return Number(res?.[0]?.[1] ?? 0);
++  }
++  async decr(key: string) {
++    const n = await this.client.decr(key);
++    if (n < 0) await this.client.set(key, "0");
++    return Math.max(0, n);
++  }
++  async get(key: string) {
++    return this.client.get(key);
++  }
++  async set(key: string, value: string, ttlSec?: number) {
++    if (ttlSec) await this.client.set(key, value, "EX", ttlSec);
++    else await this.client.set(key, value);
++  }
++  async del(key: string) {
++    await this.client.del(key);
++  }
++  async slidingWindow(key: string, windowMs: number, limit: number) {
++    const now = Date.now();
++    const member = `${now}-${Math.random().toString(36).slice(2, 8)}`;
++    const res = await this.client
++      .multi()
++      .zremrangebyscore(key, 0, now - windowMs)
++      .zadd(key, now, member)
++      .zcard(key)
++      .zrange(key, 0, 0, "WITHSCORES")
++      .pexpire(key, windowMs)
++      .exec();
++    const count = Number(res?.[2]?.[1] ?? 0);
++    const oldest = Number((res?.[3]?.[1] as string[] | undefined)?.[1] ?? now);
++    const allowed = count <= limit;
++    return { count, allowed, retryAfterMs: allowed ? 0 : Math.max(0, oldest + windowMs - now) };
++  }
++  async ping() {
++    try {
++      return (await this.client.ping()) === "PONG";
++    } catch {
++      return false;
++    }
++  }
++}
++
++let _kv: KV | null = null;
++
++export function getKV(): KV {
++  if (_kv) return _kv;
++  if (config.redisUrl) {
++    const client = new Redis(config.redisUrl, { maxRetriesPerRequest: 2, enableOfflineQueue: true, lazyConnect: false });
++    client.on("error", (e) => console.error("[redis]", e.message));
++    _kv = new RedisKV(client);
++  } else {
++    if (config.env === "production") console.warn("[redis] REDIS_URL not set — falling back to in-memory limits (single process only)");
++    _kv = new MemoryKV();
++  }
++  return _kv;
++}
++
++export async function closeKV(): Promise<void> {
++  if (_kv && _kv.kind === "redis") await (_kv as RedisKV).client.quit().catch(() => {});
++  _kv = null;
++}

added apps/api/src/routes/fetch.ts +136 −0

++import { FetchaError, PLAN_LIMITS, extractDomain, fetchRequestSchema, newId, type FetchRequest } from "@fetcha/core";
++import { db, eq, proxySessions, sql } from "@fetcha/db";
++import type { ProviderId } from "@fetcha/providers";
++import type { AttemptRecord } from "@fetcha/routing";
++import type { ConcreteNetwork } from "@fetcha/core";
++import type { ApiPrincipal } from "../auth";
++import { config } from "../config";
++import { acquireConcurrency, checkMonthlyLimits, checkRateLimits, invalidateUsageCache } from "../limits";
++import { getEngine } from "../services/engine";
++import { completeRequest, createRequestRow, failRequest, recordAttempt, type RequestContext } from "../services/persist";
++import { checkSpendAlerts, notifyHardLimit, recordAbuse } from "../services/alerts";
++
++export interface FetchHandlerInput {
++  principal: ApiPrincipal;
++  body: unknown;
++  source: "api" | "playground" | "sdk";
++  clientIp: string | null;
++  userAgent: string | null;
++}
++
++export interface FetchHandlerOutput {
++  requestId: string;
++  status: number;
++  body: unknown;
++}
++
++/**
++ * Shared /v1/fetch pipeline used by the public API and the dashboard playground.
++ * Order matters: validate → limits → SSRF (inside executor) → route → persist.
++ */
++export async function handleFetch(input: FetchHandlerInput): Promise<FetchHandlerOutput> {
++  const { principal } = input;
++  const requestId = newId("req");
++  const started = performance.now();
++
++  const parsed = fetchRequestSchema.safeParse(input.body);
++  if (!parsed.success) {
++    throw new FetchaError("INVALID_REQUEST", "The request body is invalid.", {
++      requestId,
++      details: { issues: parsed.error.issues.map((i) => ({ path: i.path.join("."), message: i.message })) },
++    });
++  }
++  const req: FetchRequest = parsed.data;
++  const limits = PLAN_LIMITS[principal.plan];
++  if (req.timeout > limits.max_timeout_ms) req.timeout = limits.max_timeout_ms;
++  if (req.network !== "auto" && !limits.networks.includes(req.network)) {
++    throw new FetchaError("NETWORK_UNAVAILABLE", `The "${req.network}" network is not included in the ${limits.label} plan.`, { requestId });
++  }
++  if (req.browser) throw new FetchaError("BROWSER_UNAVAILABLE", undefined, { requestId });
++
++  await checkRateLimits(principal, input.clientIp);
++  let monthly: Awaited<ReturnType<typeof checkMonthlyLimits>>;
++  try {
++    monthly = await checkMonthlyLimits(principal);
++  } catch (e) {
++    if (e instanceof FetchaError && e.code === "USAGE_LIMIT_REACHED" && (principal.projectHardLimitUsd !== null || principal.orgHardLimitUsd !== null)) {
++      const { monthlyUsage } = await import("../limits");
++      notifyHardLimit(principal, await monthlyUsage(principal)).catch(() => {});
++    }
++    throw e;
++  }
++  const release = await acquireConcurrency(principal);
++
++  const domain = extractDomain(req.url);
++  const ctx: RequestContext = {
++    requestId,
++    organizationId: principal.organizationId,
++    projectId: principal.projectId,
++    apiKeyId: principal.keyId,
++    source: input.source,
++    plan: principal.plan,
++    clientIp: input.clientIp,
++    userAgent: input.userAgent,
++    logLevel: principal.projectLogLevel,
++  };
++
++  const attempts: AttemptRecord[] = [];
++  try {
++    await createRequestRow(ctx, req, domain);
++    const engine = await getEngine();
++
++    // Resolve a Fetcha session (sess_…) into a provider-pinned sticky key.
++    let sessionKey: string | null = null;
++    let sessionProvider: ProviderId | null = null;
++    let sessionNetwork: ConcreteNetwork | null = null;
++    if (req.session) {
++      const [s] = await db.select().from(proxySessions).where(eq(proxySessions.id, req.session)).limit(1);
++      if (!s || s.projectId !== principal.projectId) throw new FetchaError("SESSION_NOT_FOUND", undefined, { requestId });
++      if (s.status !== "active" || s.expiresAt.getTime() < Date.now()) throw new FetchaError("SESSION_EXPIRED", undefined, { requestId });
++      sessionKey = s.stickyKey;
++      sessionProvider = s.provider as ProviderId;
++      sessionNetwork = s.network as ConcreteNetwork;
++      if (!req.country && s.country) req.country = s.country;
++      if (req.network === "auto") req.network = s.network as FetchRequest["network"];
++      db.update(proxySessions)
++        .set({ lastUsedAt: new Date(), requestCount: sql`${proxySessions.requestCount} + 1` })
++        .where(eq(proxySessions.id, s.id))
++        .catch(() => {});
++    }
++
++    const knowledge = await engine.knowledge(domain);
++    const result = await engine.executor.execute({
++      requestId,
++      plan: principal.plan,
++      request: req,
++      sessionKey,
++      sessionProvider,
++      sessionNetwork,
++      knowledge,
++      providerVisibility: principal.providerVisibility,
++      maxResponseBytes: Math.min(req.max_response_bytes ?? config.maxResponseBytesDefault, config.maxResponseBytesDefault),
++      onAttempt: async (a) => {
++        attempts.push(a);
++        await recordAttempt(requestId, a).catch(() => {});
++      },
++    });
++    const latencyMs = Math.round(performance.now() - started);
++    await completeRequest(ctx, req, result, latencyMs);
++    await invalidateUsageCache(principal.organizationId, principal.projectId);
++    if (principal.projectSoftLimitUsd !== null || principal.orgSoftLimitUsd !== null) {
++      const { monthlyUsage } = await import("../limits");
++      monthlyUsage(principal).then((u) => checkSpendAlerts(principal, u)).catch(() => {});
++    }
++    void monthly;
++    return { requestId, status: 200, body: result.body };
++  } catch (e) {
++    const latencyMs = Math.round(performance.now() - started);
++    const err = e instanceof FetchaError ? e : new FetchaError("INTERNAL_ERROR", undefined, { requestId, cause: e });
++    await failRequest(ctx, err.code, err.message, attempts, latencyMs, domain).catch(() => {});
++    if (err.code === "URL_NOT_ALLOWED") await recordAbuse(principal, requestId, "ssrf_attempt", `${req.method} ${req.url}`);
++    if (!(e instanceof FetchaError)) console.error(`[fetch] ${requestId} internal error`, e);
++    throw Object.assign(err, { requestId });
++  } finally {
++    await release();
++  }
++}

added apps/api/src/routes/internal.ts +111 −0

++import type { FastifyInstance } from "fastify";
++import { z } from "zod";
++import { FetchaError } from "@fetcha/core";
++import { db, desc, providerHealth, sql } from "@fetcha/db";
++import { assertInternalToken, principalForProject } from "../auth";
++import { getEngine } from "../services/engine";
++import { handleFetch } from "./fetch";
++import { closeSession, createSession, listSessions } from "./sessions";
++import { usageResponse } from "./misc";
++
++/**
++ * Internal routes used by the dashboard (Next.js server) with the shared service token.
++ * They are never exposed publicly: the web app proxies only /v1/* to this service.
++ */
++export async function registerInternalRoutes(app: FastifyInstance) {
++  app.addHook("onRequest", async (req) => {
++    if (req.url.startsWith("/internal/")) assertInternalToken(req.headers.authorization);
++  });
++
++  const playgroundSchema = z.object({ project_id: z.string(), user_id: z.string(), request: z.unknown() });
++
++  app.post("/internal/fetch", async (req, reply) => {
++    const parsed = playgroundSchema.safeParse(req.body);
++    if (!parsed.success) throw new FetchaError("INVALID_REQUEST", "project_id, user_id and request are required.");
++    const principal = await principalForProject(parsed.data.project_id, parsed.data.user_id);
++    const out = await handleFetch({
++      principal,
++      body: parsed.data.request,
++      source: "playground",
++      clientIp: (req.headers["x-forwarded-for"] as string | undefined)?.split(",")[0]?.trim() ?? req.ip,
++      userAgent: "fetcha-playground",
++    });
++    reply.header("x-fetcha-request-id", out.requestId);
++    return out.body;
++  });
++
++  const sessionSchema = z.object({ project_id: z.string(), user_id: z.string(), options: z.unknown().optional() });
++  app.post("/internal/sessions", async (req) => {
++    const parsed = sessionSchema.safeParse(req.body);
++    if (!parsed.success) throw new FetchaError("INVALID_REQUEST");
++    const principal = await principalForProject(parsed.data.project_id, parsed.data.user_id);
++    return createSession(principal, parsed.data.options ?? {});
++  });
++  app.get<{ Querystring: { project_id: string; user_id: string } }>("/internal/sessions", async (req) => {
++    const principal = await principalForProject(req.query.project_id, req.query.user_id);
++    return listSessions(principal);
++  });
++  app.delete<{ Params: { id: string }; Querystring: { project_id: string; user_id: string } }>("/internal/sessions/:id", async (req) => {
++    const principal = await principalForProject(req.query.project_id, req.query.user_id);
++    return closeSession(principal, req.params.id);
++  });
++  app.get<{ Querystring: { project_id: string; user_id: string } }>("/internal/usage", async (req) => {
++    const principal = await principalForProject(req.query.project_id, req.query.user_id);
++    return usageResponse(principal);
++  });
++
++  /** Admin: provider status (names visible — admin only). */
++  app.get("/internal/providers", async () => {
++    const engine = await getEngine();
++    const latest = await db
++      .select()
++      .from(providerHealth)
++      .where(sql`${providerHealth.checkedAt} > now() - interval '1 day'`)
++      .orderBy(desc(providerHealth.checkedAt))
++      .limit(200);
++    const seen = new Set<string>();
++    const health = latest.filter((h) => {
++      const k = `${h.provider}:${h.network}`;
++      if (seen.has(k)) return false;
++      seen.add(k);
++      return true;
++    });
++    return {
++      providers: engine.registry.all().map((p) => ({
++        id: p.id,
++        label: p.label,
++        configured: p.isConfigured(),
++        networks: p.networks,
++        prices: Object.fromEntries(p.networks.map((n) => [n, p.pricePerGb(n)])),
++        health: health.filter((h) => h.provider === p.id).map((h) => ({ network: h.network, status: h.status, latency_ms: h.latencyMs, detail: h.detail, checked_at: h.checkedAt })),
++        circuits: engine.circuit.snapshot().filter((c) => c.key.startsWith(`${p.id}:`)),
++      })),
++      available_networks: engine.registry.availableNetworks(),
++    };
++  });
++
++  app.post("/internal/providers/probe", async () => {
++    const engine = await getEngine();
++    await engine.reload();
++    await engine.probeAll();
++    return { ok: true };
++  });
++
++  app.post("/internal/providers/reload", async () => {
++    const engine = await getEngine();
++    await engine.reload();
++    return { ok: true };
++  });
++
++  app.post<{ Body: { key?: string } }>("/internal/circuits/reset", async (req) => {
++    const engine = await getEngine();
++    engine.circuit.reset(req.body?.key);
++    return { ok: true };
++  });
++
++  app.post<{ Body: { key_hash: string } }>("/internal/keys/invalidate", async (req) => {
++    const { invalidateKeyCache } = await import("../auth");
++    if (req.body?.key_hash) await invalidateKeyCache(req.body.key_hash);
++    return { ok: true };
++  });
++}

added apps/api/src/routes/misc.ts +50 −0

++import { PLAN_LIMITS } from "@fetcha/core";
++import { db, fetchRequests, sql } from "@fetcha/db";
++import type { ApiPrincipal } from "../auth";
++import { monthlyUsage } from "../limits";
++
++export function meResponse(p: ApiPrincipal) {
++  return {
++    project: { id: p.projectId, name: p.projectName },
++    organization: { id: p.organizationId, name: p.organizationName, plan: p.plan },
++    key: { id: p.keyId, name: p.keyName, mode: p.mode, scopes: p.scopes },
++  };
++}
++
++export async function usageResponse(p: ApiPrincipal) {
++  const usage = await monthlyUsage(p);
++  const limits = PLAN_LIMITS[p.plan];
++  const start = new Date();
++  start.setUTCDate(1);
++  start.setUTCHours(0, 0, 0, 0);
++  const [agg] = await db
++    .select({
++      total: sql<number>`count(*)::int`,
++      ok: sql<number>`count(*) filter (where ${fetchRequests.status} = 'success')::int`,
++      bytes: sql<number>`coalesce(sum(${fetchRequests.bytesIn} + ${fetchRequests.bytesOut}), 0)::float`,
++      p50: sql<number>`coalesce(percentile_cont(0.5) within group (order by ${fetchRequests.latencyMs}), 0)::float`,
++      p95: sql<number>`coalesce(percentile_cont(0.95) within group (order by ${fetchRequests.latencyMs}), 0)::float`,
++    })
++    .from(fetchRequests)
++    .where(sql`${fetchRequests.projectId} = ${p.projectId} and ${fetchRequests.createdAt} >= ${start}`);
++  return {
++    period_start: start.toISOString(),
++    plan: { id: p.plan, label: limits.label, monthly_requests: limits.monthly_requests, concurrency: limits.concurrency },
++    organization: { requests: usage.requests, spend_usd: round(usage.spendUsd) },
++    project: {
++      requests: usage.projectRequests,
++      spend_usd: round(usage.projectSpendUsd),
++      successful_requests: agg?.ok ?? 0,
++      success_rate: agg?.total ? round((agg.ok / agg.total) * 100, 1) : null,
++      bandwidth_bytes: agg?.bytes ?? 0,
++      latency_p50_ms: Math.round(agg?.p50 ?? 0),
++      latency_p95_ms: Math.round(agg?.p95 ?? 0),
++    },
++    remaining_requests: Math.max(0, limits.monthly_requests - usage.requests),
++  };
++}
++
++function round(n: number, d = 4): number {
++  const f = 10 ** d;
++  return Math.round(n * f) / f;
++}

added apps/api/src/routes/sessions.ts +82 −0

++import { FetchaError, PLAN_LIMITS, newId, normalizeGeo, randomToken, sessionCreateSchema } from "@fetcha/core";
++import { and, db, desc, eq, proxySessions } from "@fetcha/db";
++import type { ApiPrincipal } from "../auth";
++import { getEngine } from "../services/engine";
++import { getKV } from "../redis";
++
++export function serializeSession(s: typeof proxySessions.$inferSelect) {
++  return {
++    id: s.id,
++    label: s.label,
++    status: s.status === "active" && s.expiresAt.getTime() < Date.now() ? "expired" : s.status,
++    network: s.network,
++    country: s.country,
++    region: s.region,
++    city: s.city,
++    request_count: s.requestCount,
++    last_used_at: s.lastUsedAt?.toISOString() ?? null,
++    expires_at: s.expiresAt.toISOString(),
++    created_at: s.createdAt.toISOString(),
++  };
++}
++
++export async function createSession(principal: ApiPrincipal, body: unknown, idempotencyKey?: string) {
++  const parsed = sessionCreateSchema.safeParse(body ?? {});
++  if (!parsed.success) {
++    throw new FetchaError("INVALID_REQUEST", "Invalid session options.", { details: { issues: parsed.error.issues.map((i) => ({ path: i.path.join("."), message: i.message })) } });
++  }
++  const input = parsed.data;
++  const kv = getKV();
++  if (idempotencyKey) {
++    const existing = await kv.get(`fch:idem:${principal.projectId}:${idempotencyKey}`).catch(() => null);
++    if (existing) {
++      const [s] = await db.select().from(proxySessions).where(eq(proxySessions.id, existing)).limit(1);
++      if (s) return serializeSession(s);
++    }
++  }
++  const limits = PLAN_LIMITS[principal.plan];
++  const geo = normalizeGeo({ country: input.country, region: input.region, city: input.city });
++  const engine = await getEngine();
++  const plan = engine.routing.plan({ domain: "", network: input.network, geo, plan: principal.plan, sessionRequired: true, browser: false });
++  const cand = plan.candidates.find((c) => c.provider.id !== "direct");
++  if (!cand) throw new FetchaError("NETWORK_UNAVAILABLE", "No sticky-capable network is available for these options.");
++  if (!limits.networks.includes(cand.network)) throw new FetchaError("NETWORK_UNAVAILABLE");
++
++  const id = newId("sess");
++  const row = {
++    id,
++    organizationId: principal.organizationId,
++    projectId: principal.projectId,
++    label: input.label ?? null,
++    provider: cand.provider.id,
++    network: cand.network,
++    country: geo.country,
++    region: geo.region,
++    city: geo.city,
++    stickyKey: randomToken(12).replace(/[^a-zA-Z0-9]/g, "").slice(0, 16) || id.slice(5),
++    status: "active",
++    expiresAt: new Date(Date.now() + input.ttl * 1000),
++  };
++  await db.insert(proxySessions).values(row);
++  if (idempotencyKey) await kv.set(`fch:idem:${principal.projectId}:${idempotencyKey}`, id, 86_400).catch(() => {});
++  const [s] = await db.select().from(proxySessions).where(eq(proxySessions.id, id)).limit(1);
++  return serializeSession(s!);
++}
++
++export async function getSession(principal: ApiPrincipal, id: string) {
++  const [s] = await db.select().from(proxySessions).where(and(eq(proxySessions.id, id), eq(proxySessions.projectId, principal.projectId))).limit(1);
++  if (!s) throw new FetchaError("SESSION_NOT_FOUND");
++  return serializeSession(s);
++}
++
++export async function closeSession(principal: ApiPrincipal, id: string) {
++  const [s] = await db.select().from(proxySessions).where(and(eq(proxySessions.id, id), eq(proxySessions.projectId, principal.projectId))).limit(1);
++  if (!s) throw new FetchaError("SESSION_NOT_FOUND");
++  await db.update(proxySessions).set({ status: "closed" }).where(eq(proxySessions.id, id));
++  return { id, status: "closed" };
++}
++
++export async function listSessions(principal: ApiPrincipal) {
++  const rows = await db.select().from(proxySessions).where(eq(proxySessions.projectId, principal.projectId)).orderBy(desc(proxySessions.createdAt)).limit(100);
++  return { data: rows.map(serializeSession) };
++}

added apps/api/src/server.ts +160 −0

++import Fastify from "fastify";
++import cors from "@fastify/cors";
++import { FetchaError, isFetchaError, newId } from "@fetcha/core";
++import { closeDb, db, sql } from "@fetcha/db";
++import { closeAllDispatchers } from "@fetcha/providers";
++import { authenticateApiKey, requireScope } from "./auth";
++import { assertProductionConfig, config } from "./config";
++import { closeKV, getKV } from "./redis";
++import { handleFetch } from "./routes/fetch";
++import { registerInternalRoutes } from "./routes/internal";
++import { meResponse, usageResponse } from "./routes/misc";
++import { closeSession, createSession, getSession, listSessions } from "./routes/sessions";
++import { getEngine, startHealthLoop } from "./services/engine";
++
++export async function buildServer() {
++  const app = Fastify({
++    logger: {
++      level: config.logLevel,
++      ...(config.env !== "production" ? { transport: { target: "pino-pretty", options: { colorize: true, translateTime: "HH:MM:ss" } } } : {}),
++      redact: ["req.headers.authorization", "req.headers['x-api-key']", "req.headers.cookie"],
++    },
++    trustProxy: true,
++    bodyLimit: 4 * 1024 * 1024,
++    genReqId: () => newId("req"),
++    disableRequestLogging: config.env === "production",
++  });
++
++  await app.register(cors, {
++    origin: true,
++    methods: ["GET", "POST", "DELETE", "OPTIONS"],
++    allowedHeaders: ["authorization", "content-type", "x-api-key", "idempotency-key"],
++    exposedHeaders: ["x-fetcha-request-id", "x-request-id"],
++  });
++
++  app.addHook("onSend", async (req, reply) => {
++    if (!reply.getHeader("x-fetcha-request-id")) reply.header("x-fetcha-request-id", req.id);
++    reply.header("x-fetcha-version", config.version);
++    reply.header("cache-control", "no-store");
++  });
++
++  app.setErrorHandler((err: unknown, req, reply) => {
++    if (isFetchaError(err)) {
++      const e = err as FetchaError;
++      const rid = e.requestId ?? req.id;
++      reply.header("x-fetcha-request-id", rid);
++      if (e.code === "RATE_LIMITED" && e.details?.retry_after_ms) reply.header("retry-after", String(Math.ceil(Number(e.details.retry_after_ms) / 1000)));
++      return reply.status(e.status).send(e.toJSON(rid));
++    }
++    const fe = err as { statusCode?: number; validation?: unknown; message?: string; code?: string };
++    if (fe.statusCode === 400 || fe.validation || fe.code === "FST_ERR_CTP_INVALID_MEDIA_TYPE" || fe.code === "FST_ERR_CTP_EMPTY_JSON_BODY") {
++      return reply.status(400).send(new FetchaError("INVALID_REQUEST", fe.code === "FST_ERR_CTP_INVALID_MEDIA_TYPE" ? "Send a JSON body with Content-Type: application/json." : "Malformed JSON body.").toJSON(req.id));
++    }
++    if (fe.statusCode === 413) return reply.status(413).send(new FetchaError("INVALID_REQUEST", "Request body too large.").toJSON(req.id));
++    if (fe.statusCode === 404) return reply.status(404).send(new FetchaError("NOT_FOUND").toJSON(req.id));
++    req.log.error({ err }, "unhandled error");
++    return reply.status(500).send(new FetchaError("INTERNAL_ERROR").toJSON(req.id));
++  });
++
++  app.setNotFoundHandler((req, reply) => {
++    reply.status(404).send(new FetchaError("NOT_FOUND", `No route for ${req.method} ${req.url.split("?")[0]}.`).toJSON(req.id));
++  });
++
++  // ---- Health ---------------------------------------------------------------
++  app.get("/health", async () => ({ status: "ok", version: config.version, time: new Date().toISOString() }));
++  app.get("/ready", async (_req, reply) => {
++    const checks: Record<string, boolean> = {};
++    try {
++      await db.execute(sql`select 1`);
++      checks.database = true;
++    } catch {
++      checks.database = false;
++    }
++    checks.cache = await getKV().ping();
++    const engine = await getEngine().catch(() => null);
++    checks.providers = Boolean(engine && engine.registry.available().length > 0);
++    const ok = checks.database && checks.cache && checks.providers;
++    return reply.status(ok ? 200 : 503).send({ status: ok ? "ready" : "degraded", checks, available_networks: engine?.registry.availableNetworks() ?? [] });
++  });
++
++  // ---- Public API v1 ----------------------------------------------------------
++  const clientIp = (req: { headers: Record<string, unknown>; ip: string }) => ((req.headers["x-forwarded-for"] as string | undefined)?.split(",")[0]?.trim() ?? req.ip) || null;
++
++  app.post("/v1/fetch", async (req, reply) => {
++    const principal = await authenticateApiKey(req.headers.authorization, req.headers["x-api-key"] as string | undefined);
++    requireScope(principal, "fetch:execute");
++    const source = /fetcha-sdk/i.test(String(req.headers["user-agent"] ?? "")) ? "sdk" : "api";
++    const out = await handleFetch({ principal, body: req.body, source, clientIp: clientIp(req), userAgent: (req.headers["user-agent"] as string | undefined) ?? null });
++    reply.header("x-fetcha-request-id", out.requestId);
++    return reply.status(out.status).send(out.body);
++  });
++
++  app.post("/v1/sessions", async (req) => {
++    const principal = await authenticateApiKey(req.headers.authorization, req.headers["x-api-key"] as string | undefined);
++    requireScope(principal, "sessions:write");
++    return createSession(principal, req.body, req.headers["idempotency-key"] as string | undefined);
++  });
++  app.get("/v1/sessions", async (req) => {
++    const principal = await authenticateApiKey(req.headers.authorization, req.headers["x-api-key"] as string | undefined);
++    return listSessions(principal);
++  });
++  app.get<{ Params: { id: string } }>("/v1/sessions/:id", async (req) => {
++    const principal = await authenticateApiKey(req.headers.authorization, req.headers["x-api-key"] as string | undefined);
++    return getSession(principal, req.params.id);
++  });
++  app.delete<{ Params: { id: string } }>("/v1/sessions/:id", async (req) => {
++    const principal = await authenticateApiKey(req.headers.authorization, req.headers["x-api-key"] as string | undefined);
++    requireScope(principal, "sessions:write");
++    return closeSession(principal, req.params.id);
++  });
++
++  app.get("/v1/me", async (req) => {
++    const principal = await authenticateApiKey(req.headers.authorization, req.headers["x-api-key"] as string | undefined);
++    return meResponse(principal);
++  });
++  app.get("/v1/usage", async (req) => {
++    const principal = await authenticateApiKey(req.headers.authorization, req.headers["x-api-key"] as string | undefined);
++    requireScope(principal, "usage:read");
++    return usageResponse(principal);
++  });
++
++  // Explicitly unavailable surfaces (never fake functionality).
++  app.post("/v1/browser", async () => {
++    throw new FetchaError("BROWSER_UNAVAILABLE", "Browser actions are not yet available. Follow the changelog at https://www.fetcha.co/changelog.");
++  });
++  app.post("/v1/extract", async () => {
++    throw new FetchaError("INVALID_REQUEST", "Structured extraction is not yet available on this plan. Follow the changelog at https://www.fetcha.co/changelog.");
++  });
++
++  await registerInternalRoutes(app);
++  return app;
++}
++
++async function main() {
++  assertProductionConfig();
++  const app = await buildServer();
++  const engine = await getEngine();
++  app.log.info({ providers: engine.registry.available().map((p) => p.id), networks: engine.registry.availableNetworks() }, "providers loaded");
++  const stopHealth = startHealthLoop(engine, app.log);
++
++  const shutdown = async (signal: string) => {
++    app.log.info(`${signal} received, shutting down`);
++    stopHealth();
++    await app.close();
++    await Promise.all([closeAllDispatchers(), closeKV(), closeDb()]);
++    process.exit(0);
++  };
++  process.on("SIGINT", () => void shutdown("SIGINT"));
++  process.on("SIGTERM", () => void shutdown("SIGTERM"));
++
++  await app.listen({ port: config.port, host: config.host });
++  app.log.info(`Fetcha API listening on http://${config.host}:${config.port}`);
++}
++
++const isMain = process.argv[1] && /server\.ts$|server\.js$/.test(process.argv[1]);
++if (isMain) {
++  main().catch((e) => {
++    console.error(e);
++    process.exit(1);
++  });
++}

added apps/api/src/services/alerts.ts +48 −0

++import { newId } from "@fetcha/core";
++import { abuseEvents, db } from "@fetcha/db";
++import { getEmailService } from "@fetcha/email";
++import type { ApiPrincipal } from "../auth";
++import type { MonthlyUsage } from "../limits";
++import { getKV } from "../redis";
++import { formatUsd } from "./pricing";
++
++function monthKey(): string {
++  const d = new Date();
++  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}`;
++}
++
++/** Send soft-limit alerts once per project/org per month (idempotent via KV flags). */
++export async function checkSpendAlerts(p: ApiPrincipal, usage: MonthlyUsage): Promise<void> {
++  const kv = getKV();
++  const email = getEmailService();
++  const checks: Array<{ key: string; spent: number; limit: number | null; label: string }> = [
++    { key: `fch:alert:soft:proj:${p.projectId}:${monthKey()}`, spent: usage.projectSpendUsd, limit: p.projectSoftLimitUsd, label: p.projectName },
++    { key: `fch:alert:soft:org:${p.organizationId}:${monthKey()}`, spent: usage.spendUsd, limit: p.orgSoftLimitUsd, label: p.organizationName },
++  ];
++  for (const c of checks) {
++    if (c.limit === null || c.limit <= 0 || c.spent < c.limit) continue;
++    if (await kv.get(c.key).catch(() => "1")) continue;
++    await kv.set(c.key, "1", 40 * 86_400).catch(() => {});
++    email.sendUsageAlert(p.ownerEmail, { projectName: c.label, spent: formatUsd(c.spent), limit: formatUsd(c.limit), kind: "soft" }).catch(() => {});
++  }
++}
++
++/** Notify once per month when a hard limit blocks requests. */
++export async function notifyHardLimit(p: ApiPrincipal, usage: MonthlyUsage): Promise<void> {
++  const kv = getKV();
++  const key = `fch:alert:hard:${p.projectId}:${monthKey()}`;
++  if (await kv.get(key).catch(() => "1")) return;
++  await kv.set(key, "1", 40 * 86_400).catch(() => {});
++  const limit = p.projectHardLimitUsd ?? p.orgHardLimitUsd ?? 0;
++  getEmailService()
++    .sendUsageAlert(p.ownerEmail, { projectName: p.projectName, spent: formatUsd(Math.max(usage.projectSpendUsd, usage.spendUsd)), limit: formatUsd(limit), kind: "hard" })
++    .catch(() => {});
++}
++
++/** Record an abuse signal (SSRF attempt, prohibited target…) for admin review. */
++export async function recordAbuse(p: ApiPrincipal, requestId: string, kind: "ssrf_attempt" | "prohibited_target" | "rate_abuse", detail: string): Promise<void> {
++  await db
++    .insert(abuseEvents)
++    .values({ id: newId("abuse"), organizationId: p.organizationId, projectId: p.projectId, requestId, kind, severity: kind === "ssrf_attempt" ? "medium" : "low", detail: detail.slice(0, 500) })
++    .catch(() => {});
++}

added apps/api/src/services/engine.ts +104 −0

++import { db, providerConfigs, providerHealth, domainProfiles, eq } from "@fetcha/db";
++import { ProviderRegistry, type ProviderId } from "@fetcha/providers";
++import { CircuitBreaker, FetchExecutor, RoutingEngine, type DomainKnowledge } from "@fetcha/routing";
++import { newId } from "@fetcha/core";
++import { config } from "../config";
++
++export interface Engine {
++  registry: ProviderRegistry;
++  circuit: CircuitBreaker;
++  routing: RoutingEngine;
++  executor: FetchExecutor;
++  reload(): Promise<void>;
++  probeAll(): Promise<void>;
++  knowledge(domain: string): Promise<DomainKnowledge | null>;
++}
++
++let _engine: Engine | null = null;
++
++export async function getEngine(): Promise<Engine> {
++  if (_engine) return _engine;
++  const circuit = new CircuitBreaker();
++  let registry = new ProviderRegistry();
++  let routing = new RoutingEngine(registry, circuit);
++  let executor = new FetchExecutor(routing, circuit);
++
++  const engine: Engine = {
++    get registry() {
++      return registry;
++    },
++    circuit,
++    get routing() {
++      return routing;
++    },
++    get executor() {
++      return executor;
++    },
++    async reload() {
++      // Prices and enabled flags come from the DB; credentials always from the environment.
++      const rows = await db.select().from(providerConfigs).catch(() => []);
++      const prices: Partial<Record<ProviderId, Record<string, number>>> = {};
++      const disabled: ProviderId[] = [];
++      for (const r of rows) {
++        prices[r.id as ProviderId] = r.pricePerGbUsd;
++        if (!r.enabled) disabled.push(r.id as ProviderId);
++      }
++      registry = new ProviderRegistry({ prices, disabled });
++      routing = new RoutingEngine(registry, circuit);
++      executor = new FetchExecutor(routing, circuit);
++    },
++    async probeAll() {
++      const results = await Promise.all(
++        registry.all().flatMap((p) => p.networks.map((n) => p.health(n).catch((e) => ({ provider: p.id, network: n, status: "down" as const, latencyMs: null, detail: (e as Error).message, checkedAt: new Date() })))),
++      );
++      for (const h of results) {
++        await db
++          .insert(providerHealth)
++          .values({ id: newId("evt"), provider: h.provider, network: h.network, status: h.status, latencyMs: h.latencyMs, detail: h.detail ?? null, checkedAt: h.checkedAt })
++          .catch(() => {});
++      }
++    },
++    async knowledge(domain: string) {
++      if (!domain) return null;
++      const [row] = await db.select().from(domainProfiles).where(eq(domainProfiles.domain, domain)).limit(1).catch(() => []);
++      if (!row) return null;
++      return { domain, routeStats: row.routeStats ?? {}, policy: row.policy ?? null, browserRequiredRate: row.requests ? row.browserRequired / row.requests : 0 };
++    },
++  };
++  await engine.reload();
++  _engine = engine;
++  return engine;
++}
++
++export function startHealthLoop(engine: Engine, log: { info: (m: string) => void; warn: (m: string) => void }): () => void {
++  let stopped = false;
++  let ticks = 0;
++  const run = async () => {
++    if (stopped) return;
++    try {
++      await engine.reload();
++      await engine.probeAll();
++      log.info("provider health probe complete");
++    } catch (e) {
++      log.warn(`provider health probe failed: ${(e as Error).message}`);
++    }
++    // Retention prune roughly every 6 hours (every Nth probe), plus once shortly after boot.
++    const every = Math.max(1, Math.round((6 * 60 * 60_000) / config.healthProbeIntervalMs));
++    if (ticks % every === 0) {
++      try {
++        const { pruneRetention } = await import("./retention");
++        await pruneRetention(log);
++      } catch (e) {
++        log.warn(`retention prune failed: ${(e as Error).message}`);
++      }
++    }
++    ticks++;
++  };
++  const t = setTimeout(run, 5_000);
++  const interval = setInterval(run, config.healthProbeIntervalMs);
++  return () => {
++    stopped = true;
++    clearTimeout(t);
++    clearInterval(interval);
++  };
++}

added apps/api/src/services/persist.ts +219 −0

++import { newId, redactHeaders, type ConcreteNetwork, type FetchRequest, type Plan } from "@fetcha/core";
++import { db, domainProfiles, fetchRequests, requestAttempts, routingMetrics, usageEvents, sql } from "@fetcha/db";
++import { foldRouteStat, preferredRoute, routeKey, type AttemptRecord, type ExecutionResult } from "@fetcha/routing";
++import { priceRequest } from "./pricing";
++
++export interface RequestContext {
++  requestId: string;
++  organizationId: string;
++  projectId: string;
++  apiKeyId: string | null;
++  source: "api" | "playground" | "sdk";
++  plan: Plan;
++  clientIp: string | null;
++  userAgent: string | null;
++  logLevel: "none" | "metadata" | "headers" | "full";
++}
++
++export async function createRequestRow(ctx: RequestContext, req: FetchRequest, domain: string): Promise<void> {
++  await db.insert(fetchRequests).values({
++    id: ctx.requestId,
++    organizationId: ctx.organizationId,
++    projectId: ctx.projectId,
++    apiKeyId: ctx.apiKeyId,
++    source: ctx.source,
++    url: req.url,
++    domain,
++    method: req.method,
++    requestedNetwork: req.network,
++    country: req.country ?? null,
++    region: req.region ?? null,
++    city: req.city ?? null,
++    sessionId: req.session ?? null,
++    browser: req.browser,
++    format: req.format,
++    status: "pending",
++    requestHeaders: ctx.logLevel === "headers" || ctx.logLevel === "full" ? redactHeaders(req.headers) : null,
++    clientIp: ctx.clientIp,
++    userAgent: ctx.userAgent,
++  });
++}
++
++export async function recordAttempt(requestId: string, a: AttemptRecord): Promise<void> {
++  await db.insert(requestAttempts).values({
++    id: a.attemptId,
++    requestId,
++    attemptNo: a.attemptNo,
++    provider: a.provider,
++    network: a.network,
++    country: a.country,
++    sessionKey: a.sessionKey,
++    outcome: a.outcome,
++    httpStatus: a.httpStatus,
++    errorCode: a.errorCode,
++    errorDetail: a.errorDetail,
++    blockReason: a.blockReason,
++    durationMs: a.durationMs,
++    bytesIn: a.bytesIn,
++    bytesOut: a.bytesOut,
++    unitPricePerGb: a.unitPricePerGb,
++    costUsd: a.costUsd,
++    routingScore: a.routingScore,
++    timing: a.timing ? { ...a.timing } : null,
++  });
++}
++
++export interface CompletionSummary {
++  priceUsd: number;
++  costUsd: number;
++}
++
++/** Persist a successful (or blocked-but-answered) execution: request row, usage ledger, domain intelligence, routing metrics. */
++export async function completeRequest(ctx: RequestContext, req: FetchRequest, result: ExecutionResult, latencyMs: number): Promise<CompletionSummary> {
++  const network = result.network;
++  const price = priceRequest({ plan: ctx.plan, network, bytes: result.bytesIn + result.bytesOut, upstreamCostUsd: result.costUsd, attempts: result.attempts.length, success: result.body.success });
++  const finalStatus = result.body.success ? "success" : "failed";
++
++  await db
++    .update(fetchRequests)
++    .set({
++      status: finalStatus,
++      httpStatus: result.body.status,
++      errorCode: result.body.success ? null : "TARGET_BLOCKED",
++      errorMessage: result.body.success ? null : "The target blocked every route we tried.",
++      finalUrl: result.finalUrl,
++      network,
++      attempts: result.attempts.length,
++      latencyMs,
++      bytesIn: result.bytesIn,
++      bytesOut: result.bytesOut,
++      costUsd: result.costUsd,
++      priceUsd: price.totalUsd,
++      responseHeaders: ctx.logLevel === "headers" || ctx.logLevel === "full" ? redactHeaders(result.body.headers) : null,
++      timing: result.body.metadata.timing ? { ...result.body.metadata.timing } : null,
++      completedAt: new Date(),
++    })
++    .where(sql`${fetchRequests.id} = ${ctx.requestId}`);
++
++  await writeUsage(ctx, result, price.totalUsd, network);
++  await Promise.all([updateDomainProfile(result.domain, result.attempts, result.body.success), updateRoutingMetrics(result.attempts)]);
++  return { priceUsd: price.totalUsd, costUsd: result.costUsd };
++}
++
++export async function failRequest(ctx: RequestContext, code: string, message: string, attempts: AttemptRecord[], latencyMs: number, domain: string): Promise<void> {
++  const costUsd = attempts.reduce((s, a) => s + a.costUsd, 0);
++  await db
++    .update(fetchRequests)
++    .set({ status: "failed", errorCode: code, errorMessage: message, attempts: attempts.length, latencyMs, costUsd, completedAt: new Date() })
++    .where(sql`${fetchRequests.id} = ${ctx.requestId}`);
++  // Failed requests still count against the request quota (abuse control) but are not priced.
++  await db.insert(usageEvents).values({
++    id: newId("usage"),
++    organizationId: ctx.organizationId,
++    projectId: ctx.projectId,
++    requestId: ctx.requestId,
++    metric: "request",
++    quantity: 1,
++    unit: "count",
++    costUsd: 0,
++    upstreamCostUsd: costUsd,
++  });
++  if (attempts.length) await Promise.all([updateDomainProfile(domain, attempts, false), updateRoutingMetrics(attempts)]);
++}
++
++async function writeUsage(ctx: RequestContext, result: ExecutionResult, priceUsd: number, network: ConcreteNetwork | null) {
++  const bytes = result.bytesIn + result.bytesOut;
++  const rows = [
++    { metric: "request", quantity: 1, unit: "count", costUsd: priceUsd, upstreamCostUsd: result.costUsd },
++    { metric: "bandwidth", quantity: bytes, unit: "bytes", costUsd: 0, upstreamCostUsd: 0 },
++  ];
++  if (network === "residential" || network === "isp") rows.push({ metric: "residential_bandwidth", quantity: bytes, unit: "bytes", costUsd: 0, upstreamCostUsd: 0 });
++  if (network === "mobile") rows.push({ metric: "mobile_bandwidth", quantity: bytes, unit: "bytes", costUsd: 0, upstreamCostUsd: 0 });
++  await db.insert(usageEvents).values(
++    rows.map((r) => ({ id: newId("usage"), organizationId: ctx.organizationId, projectId: ctx.projectId, requestId: ctx.requestId, ...r })),
++  );
++}
++
++async function updateDomainProfile(domain: string, attempts: AttemptRecord[], success: boolean) {
++  if (!domain) return;
++  const [existing] = await db.select().from(domainProfiles).where(sql`${domainProfiles.domain} = ${domain}`).limit(1);
++  const stats = { ...(existing?.routeStats ?? {}) };
++  let blocks = 0;
++  let captchas = 0;
++  for (const a of attempts) {
++    foldRouteStat(stats, routeKey(a.provider, a.network), { ok: a.outcome === "success", blocked: a.outcome === "blocked", latencyMs: a.durationMs, costUsd: a.costUsd });
++    if (a.outcome === "blocked") blocks++;
++    if (a.blockReason === "captcha" || a.blockReason === "cloudflare_challenge") captchas++;
++  }
++  const pref = preferredRoute(stats);
++  const totalLatency = attempts.reduce((s, a) => s + a.durationMs, 0);
++  const n = (existing?.requests ?? 0) + 1;
++  const avgLatency = existing ? existing.avgLatencyMs + (totalLatency - existing.avgLatencyMs) / n : totalLatency;
++  await db
++    .insert(domainProfiles)
++    .values({
++      domain,
++      preferredNetwork: pref?.network ?? null,
++      preferredProvider: pref?.provider ?? null,
++      requests: 1,
++      successes: success ? 1 : 0,
++      blocks,
++      captchas,
++      avgLatencyMs: totalLatency,
++      routeStats: stats,
++      lastSeenAt: new Date(),
++    })
++    .onConflictDoUpdate({
++      target: domainProfiles.domain,
++      set: {
++        preferredNetwork: pref?.network ?? null,
++        preferredProvider: pref?.provider ?? null,
++        requests: sql`${domainProfiles.requests} + 1`,
++        successes: sql`${domainProfiles.successes} + ${success ? 1 : 0}`,
++        blocks: sql`${domainProfiles.blocks} + ${blocks}`,
++        captchas: sql`${domainProfiles.captchas} + ${captchas}`,
++        avgLatencyMs: avgLatency,
++        routeStats: stats,
++        lastSeenAt: new Date(),
++        updatedAt: new Date(),
++      },
++    });
++}
++
++async function updateRoutingMetrics(attempts: AttemptRecord[]) {
++  const bucket = new Date();
++  bucket.setMinutes(0, 0, 0);
++  for (const a of attempts) {
++    const ok = a.outcome === "success" ? 1 : 0;
++    const blocked = a.outcome === "blocked" ? 1 : 0;
++    const errors = ok || blocked ? 0 : 1;
++    await db
++      .insert(routingMetrics)
++      .values({
++        id: newId("evt"),
++        bucket,
++        provider: a.provider,
++        network: a.network,
++        country: a.country ?? "",
++        requests: 1,
++        successes: ok,
++        blocked,
++        errors,
++        latencySumMs: a.durationMs,
++        bytes: a.bytesIn + a.bytesOut,
++        costUsd: a.costUsd,
++      })
++      .onConflictDoUpdate({
++        target: [routingMetrics.bucket, routingMetrics.provider, routingMetrics.network, routingMetrics.country],
++        set: {
++          requests: sql`${routingMetrics.requests} + 1`,
++          successes: sql`${routingMetrics.successes} + ${ok}`,
++          blocked: sql`${routingMetrics.blocked} + ${blocked}`,
++          errors: sql`${routingMetrics.errors} + ${errors}`,
++          latencySumMs: sql`${routingMetrics.latencySumMs} + ${a.durationMs}`,
++          bytes: sql`${routingMetrics.bytes} + ${a.bytesIn + a.bytesOut}`,
++          costUsd: sql`${routingMetrics.costUsd} + ${a.costUsd}`,
++        },
++      });
++  }
++}

added apps/api/src/services/pricing.ts +51 −0

Large diff (51 lines) is not loaded by default to keep the page fast.Load diff

added apps/api/src/services/retention.ts +26 −0

Large diff (26 lines) is not loaded by default to keep the page fast.Load diff

added apps/api/tsconfig.json +9 −0

Large diff (9 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/eslint.config.mjs +10 −0

Large diff (10 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/next.config.ts +34 −0

Large diff (34 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/package.json +52 −0

Large diff (52 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/postcss.config.mjs +2 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/public/icon.svg +1 −0

Large diff (1 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/public/robots.txt +6 −0

Large diff (6 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/actions/account.ts +52 −0

Large diff (52 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/actions/admin.ts +437 −0

Large diff (437 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/actions/api-keys.ts +106 −0

Large diff (106 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/actions/legal.ts +24 −0

Large diff (24 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/actions/playground.ts +68 −0

Large diff (68 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/actions/projects.ts +112 −0

Large diff (112 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/actions/sessions.ts +77 −0

Large diff (77 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(auth)/forgot-password/page.tsx +47 −0

Large diff (47 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(auth)/layout.tsx +24 −0

Large diff (24 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(auth)/login/login-form.tsx +74 −0

Large diff (74 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(auth)/login/page.tsx +13 −0

Large diff (13 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(auth)/reset-password/page.tsx +67 −0

Large diff (67 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(auth)/signup/page.tsx +13 −0

Large diff (13 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(auth)/signup/signup-form.tsx +111 −0

Large diff (111 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(auth)/verify-email/page.tsx +36 −0

Large diff (36 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/changelog/page.tsx +114 −0

Large diff (114 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/authentication/page.tsx +172 −0

Large diff (172 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/browser/page.tsx +133 −0

Large diff (133 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/errors/page.tsx +243 −0

Large diff (243 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/examples/page.tsx +448 −0

Large diff (448 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/extraction/page.tsx +99 −0

Large diff (99 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/fetch/page.tsx +341 −0

Large diff (341 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/geolocation/page.tsx +162 −0

Large diff (162 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/layout.tsx +25 −0

Large diff (25 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/networks/page.tsx +228 −0

Large diff (228 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/openapi.json/route.ts +442 −0

Large diff (442 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/page.tsx +176 −0

Large diff (176 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/quickstart/page.tsx +170 −0

Large diff (170 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/rate-limits/page.tsx +224 −0

Large diff (224 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/retries/page.tsx +225 −0

Large diff (225 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/sdks/page.tsx +268 −0

Large diff (268 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/sessions/page.tsx +182 −0

Large diff (182 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/docs/webhooks/page.tsx +148 −0

Large diff (148 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/layout.tsx +14 −0

Large diff (14 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/legal/acceptable-use/page.tsx +141 −0

Large diff (141 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/legal/cookies/page.tsx +127 −0

Large diff (127 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/legal/dpa/page.tsx +178 −0

Large diff (178 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/legal/privacy/page.tsx +172 −0

Large diff (172 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/legal/terms/page.tsx +177 −0

Large diff (177 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/page.tsx +361 −0

Large diff (361 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/pricing/page.tsx +306 −0

Large diff (306 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/(marketing)/status/page.tsx +209 −0

Large diff (209 lines) is not loaded by default to keep the page fast.Load diff

added apps/web/src/app/admin/abuse/loading.tsx +5 −0