KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#typescript #ai-agents #cli #open-source #ai #claude-code #codex #deepseek-harness #dsh-plugin #react #windows #developer-tools

myapi

★ 83 Open GitHub ↗

The unified API for autonomous companies. Ship a real business — website, backend, payments — from one terminal.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# 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.

```bash
npm install @myapihq/cli
```

[![npm](https://img.shields.io/npm/v/@myapihq/sdk?label=%40myapihq%2Fsdk)](https://www.npmjs.com/package/@myapihq/sdk)
[![npm](https://img.shields.io/npm/v/@myapihq/cli?label=%40myapihq%2Fcli)](https://www.npmjs.com/package/@myapihq/cli)
[![license](https://img.shields.io/badge/license-Apache--2.0-blue)](https://raw.githubusercontent.com/myapihq/myapi/main/LICENSE)

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 message 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.

<sub>*Typical paid tiers, 2026. Prices change; the point doesn't.*</sub>

---

## See it

This runs right now — copy, paste, done:

```bash
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:

```bash
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:

```bash
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:

```ts
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:

```bash
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), `container` (dynamic apps & workers — custom domains via `myapi container domain`), `git` (hosted git repos), `queue` (durable job queue), `task` (agent-task queue), `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:

| Status | Services |
|---|---|
| ✅ Stable | hq · auth · domain · email · email-verify · funnel · image · webhook · crm · storage · database · llm · git · workflow |
| 🧪 Preview | url · pixel · feedback · people · company · audience · function · payments · container · queue · task |

---

## 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, …)
examples/         worked end-to-end examples spanning several services
```

**Building a real app?** Start with
[`examples/authenticated-app`](./examples/authenticated-app/) — the seam the
individual service docs don't cover: how a request carries an identity from the
hosted login page, through a container, into a per-user KV record. It also
documents the runtime behaviours that are only discoverable by being bitten by
them.

Previously this repo also carried `packages/n8n` (an n8n community node) and
`packages/make` (Make/Integromat modules). Both were early experiments frozen
at the ~1.0 API surface, excluded from workspaces and CI, and had drifted far
enough that a naive rebuild was actively dangerous — the n8n node passed a
cents-denominated amount to a `topUp` that now takes dollars. They were removed
rather than left as documented-broken code in a public repo; `git log` has them
if anyone wants to port one properly.

## SDK

```bash
npm install @myapihq/sdk
```

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

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

## Development

```bash
# 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:

```bash
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`.

### Environment variables

| Variable | Effect |
|---|---|
| `MYAPI_KEY` / `MYAPI_API_KEY` | API key to authenticate with. **Only inherits saved defaults (`default_org`, …) when the key belongs to an account in your config** — an unrecognised key carries no namespace pointers, so commands will ask for an explicit `--org` rather than write into whichever org happened to be active. |
| `MYAPI_CONFIG_DIR` | Use a different config directory instead of `~/.myapi`. Lets automation run against an isolated config without mutating yours. |
| `MYAPI_TIMEOUT_MS` | Per-attempt request deadline (default `120000`). `0` disables. |
| `MYAPI_MAX_ATTEMPTS` | Total attempts for retryable failures (default `3`). Only idempotent methods are retried; POST/PATCH never are. |
| `MYAPI_USER_AGENT` | Override the `User-Agent` sent on every request. |
| `MYAPI_*_URL` | Point a service at a different base URL — see `packages/sdk/src/config.ts`. |

Cutting a release? See [RELEASING.md](./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](./LICENSE).

myapi

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README