MyAPI

The action layer for AI agents. One key for every capability a real online business needs — domain, site, backend, auth, payments, email, data — so your agent ships the whole thing in a loop, instead of you wiring ten subscriptions together yourself.

npm install @myapihq/cli

Your agent is the brain; MyAPI is the hands. Point any agent harness at the CLI, install the skills, and it runs the loop — decide, run one myapi command, read the result, repeat — until the thing is actually live: a domain resolves, a site is up, logins work, an email lands, a charge goes through.

Who it's for

• AI agents — and the people running them. Claude, Codex, Gemini, OpenClaw, Hermes — any harness. The skills teach it the command surface; the CLI gives it hands. Hand it a goal, it ships.
• Indie hackers & builders. No agent in the loop? The same one-key platform is just as good to drive by hand.

How it works

1. Install the CLI and the skills (myapi install-skills).
2. Point your agent at it. The skills in skills/ teach it every command — when to reach for funnel, domain, auth, payments, and how.
3. Give it a goal. It runs the loop — decide → run one myapi command → read the result → repeat — until a real domain, site, login, email, and charge all exist.

What it replaces

To ship and run a small product the usual way, you assemble — and pay for, and wire together — something like this:

What you need	The usual tool	~Price	With MyAPI
Hosting / deploy	Vercel	$20/mo	myapi funnel publish
Backend / compute	AWS or GCP	~$25/mo	myapi fn deploy
CDN · DNS · TLS	Cloudflare	~$20/mo	built in
Auth / logins	Clerk	$25/mo	myapi auth tenant create
Business email / mailboxes	Google Workspace	~$8/seat	myapi email
Transactional email	Resend	$20/mo	myapi email send
Database	Supabase	$25/mo	myapi database
Workflows / webhooks	Zapier / Make	~$25/mo	myapi workflow · myapi webhook
Error tracking	Sentry	$26/mo	built in
Product analytics	PostHog	~$15/mo	myapi pixel
Total	~10 logins · ~10 bills	≈ $220/mo + weeks of wiring, and they don't share data	one key · one bill · usage at cost

You'll still pay these — MyAPI just wires them up, at cost: a domain (~$12/yr, via myapi domain register) and payments (your own Stripe, your rate, via myapi payments charge). MyAPI doesn't remove the domain fee or mark up Stripe — it removes the other ten subscriptions, the ten logins, and the weeks of glue.

_{Typical paid tiers, 2026. Prices change; the point doesn't.}

---

See it

This runs right now — copy, paste, done:

npm i -g @myapihq/cli
myapi account setup
echo '<h1>We are live</h1>' | myapi funnel push /

✓ Pushed page to /
Preview: https://swift-fox-42.makeautonomous.com

A real, public website in 30 seconds. No config, no deploy step, no account form — account setup creates an anonymous account, an org, and a site for you.

Then give it a backend and a checkout:

myapi fn deploy <id> ./api.js        # edge function
myapi payments charge --amount 19    # Stripe checkout link

Run myapi --help for the full command surface.

---

What you can build

→ You're an indie hacker

Go from idea to a paid product without standing up infrastructure:

myapi funnel publish ./site                    # your landing page, live
myapi fn create --name api                     # an edge function
myapi fn deploy <id> ./api.js                  # ship its code
myapi payments connect --stripe-key sk_live_…  # link your Stripe
myapi payments charge --amount 29 --every month --description "Pro plan"

The funnel is your site, the function is your backend, payments hands you a hosted Stripe Checkout URL. No servers to manage.

Functions are plain JavaScript that run on the edge, with the MyAPI SDK built in.

→ You're building an AI agent

Every capability is in the SDK, typed, behind one key — so an agent can take real-world actions without juggling ten vendor APIs:

import { funnel, payments } from '@myapihq/sdk';

await funnel.publishFiles(key, orgId, funnelId, files);
const charge = await payments.createCharge(key, orgId, {
  amount_cents: 1900,
  description: 'Pro plan',
});
console.log(charge.checkout_url);

And skills/ holds drop-in skill definitions that teach an AI agent (Claude, Codex, Gemini, …) to drive MyAPI directly:

myapi install-skills

---

The platform

One key, one CLI, one SDK — across every capability a company needs:

• Web — funnel (sites & landing pages), domain (registration + DNS), url (short links)
• Backend — fn (edge functions), workflow (event automations), database (KV store), storage (assets)
• Auth & payments — auth (OIDC logins for your app's users), payments (Stripe Checkout: one-off & recurring)
• Comms — email (send + verify), webhook (inbound events)
• Data & AI — llm, image, crm, people, company, audience, pixel

Coming soon — payments with no Stripe account of your own. Today payments connects your Stripe account. Managed payments — take real money without your own Stripe account or a registered company — is on the way. The goal: anyone, or any agent, can run a business end to end.

Maturity varies by service — myapi status shows the live picture. Today, roughly:

Status	Services
✅ Stable	hq · domain · funnel · email-verify · image · webhook · crm · storage · database · workflow · llm · auth
🧪 Preview	email · url · functions · payments · people · company · audience
🔜 Planned	pixel

---

What's in this repo

packages/cli      @myapihq/cli  — the myapi command-line tool
packages/sdk      @myapihq/sdk  — the TypeScript SDK
skills/           agent skill definitions (Claude, Codex, Gemini, …)
packages/n8n      n8n community node          (experimental)
packages/make     Make (Integromat) modules   (experimental)

The experimental packages work but aren't published to their marketplaces yet — PRs welcome.

SDK

npm install @myapihq/sdk

import { hq, funnel } from '@myapihq/sdk';

const orgs = await hq.listOrgs('hq_live_…');
const funnels = await funnel.listFunnels('hq_live_…', orgs[0].id);

Development

# Build (SDK first — the CLI depends on it)
cd packages/sdk && npm install && npm run build
cd ../cli && npm install && npm run build
node dist/index.js --help

The CLI test suite runs in tiers:

cd packages/cli
npm test            # fast unit tests — no build, no network
npm run test:smoke  # builds, then exercises every --help / error path — the push gate
npm run test:online # mutating tests against a real test account (skipped if unconfigured)

Tier 1 runs against an isolated HOME, so it never touches your real ~/.myapi/config.json. Service base URLs can be pointed at a local backend via MYAPI_*_URL env vars — see packages/sdk/src/config.ts.

Cutting a release? See RELEASING.md.

Engineering principles

Zero third-party dependencies. The CLI and SDK pull in no third-party runtime code — the CLI's only dependency is the MyAPI SDK, which is ours. JavaScript's package ecosystem gets compromised regularly, and a globally-installed CLI that holds your API key must not inherit that risk. Zero dependencies means you can audit the whole client yourself. The same standard applies to the infrastructure behind the API.

Built for agents. Two numbers decide how good an agent tool is: tokens spent reading its output, and latency per call. We optimize both. A lean CLI beats MCP on each — MCP adds schema and per-call overhead the agent pays every time. We may ship an MCP server if there's demand; the CLI stays the primary surface.

No lock-in. Every MyAPI service is optional. Use one, use all of them, or use none and bring your own. Where we can, we give you a second option — you are never trapped in our ecosystem.

Contributing

Issues and PRs welcome. For significant changes, open an issue first to discuss the approach.

License

Apache-2.0 — see LICENSE.