myrt API docs

Run code and drive an AI agent over HTTP — sandboxed, metered, honest. Everything below talks to the API endpoint …; the examples fill it in automatically for this deployment.

Quickstart#

1. Create an account — sign up free, no credit card. Prefer a guided start? 60-second Get Started.
2. Create an API key — Keys page → Create key.
3. Run your first task — POST the key and your code to /execute:

curl -X POST BASE/execute \
  -H "X-API-Key: myrt_sk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"code": "6*7"}'

Response (v:2 contract):

{
  "v": 2,
  "result": 42,
  "stdout": ""
}

Authentication#

Two kinds of credential, two jobs:

API keys are scoped to your account, hashed at rest (only the SHA-256 is stored), revocable in one call, and rotatable with a 5-minute grace window so rotation never drops traffic. Never put an API key in client-side code — it is a server-side secret.

POST /execute#

Runs JavaScript in a sandboxed runtime and returns the answer.

curl -X POST BASE/execute \
  -H "X-API-Key: myrt_sk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"code": "console.log(\"hello\"); [1,2,3].map(x => x*x)"}'

{
  "v": 2,
  "result": [1, 4, 9],
  "stdout": "hello\n"
}

Check your remaining allowance any time with GET /wasm-quota (WASM component invocations) using the same X-API-Key header.

Key lifecycle#

These routes use your login session (the dashboard sends the JWT for you — on the Keys page everything below is one click):

Tiers & limits#

Allowances reset at 00:00 UTC. The runaway ceiling is an emergency per-run cost stop, far above a normal task's cost — if a run ever loops out of control it is stopped there, and you keep the answer up to that point. Editor runs via the dashboard are free and never count against the allowance.

Rate-limited responses (429) carry a Retry-After header. Your remaining daily allowance is available any time from the quota endpoints — GET /api/agent/quota with your login session, or the quota line under the app composer — so you can back off before hitting the wall.

Errors (and what to do)#

More examples#

Python (requests)

import requests

API = "BASE"
KEY  = "myrt_sk_live_YOUR_KEY"

r = requests.post(f"{API}/execute",
    headers={"X-API-Key": KEY},
    json={"code": "6*7"},
    timeout=15)
r.raise_for_status()
print(r.json())          # {'v': 2, 'result': 42, 'stdout': ''}

# Retry-After-aware error handling
if r.status_code == 429:
    wait = int(r.headers.get("Retry-After", "60"))
    print(f"Rate limited — retry in {wait}s")

Node.js (built-in fetch, Node 18+)

const API = "BASE";
const KEY = "myrt_sk_live_YOUR_KEY";

const res = await fetch(`${API}/execute`, {
  method: "POST",
  headers: { "X-API-Key": KEY, "Content-Type": "application/json" },
  body: JSON.stringify({ code: "console.log('hi'); 6*7" }),
});
const data = await res.json();

if (res.status === 429) {
  const wait = res.headers.get("Retry-After") ?? "60";
  console.log(`Rate limited — retry in ${wait}s`);
} else {
  console.log(data); // { v: 2, result: 42, stdout: 'hi\n' }
}

In the browser (from the dashboard origin)

// From dashboard pages, the /api/my/execute proxy avoids CORS
// and forwards your key (server-scoped to your account).
const res = await fetch("/api/my/execute", {
  method: "POST",
  headers: { "Content-Type": "application/json", "X-API-Key": KEY },
  body: JSON.stringify({ code: "6*7" }),
});
console.log(await res.json()); // { v: 2, result: 42, stdout: '' }

BYO brain — your own models, $0.00/token#

The most common cloud objection is the bill: "AI APIs are expensive — why can't I use my own local model?" You can — three ways, and every one ends in the same card: Settings → Integrations & credentials → BYO brain. myrt live-verifies the endpoint on save (a real /v1/models call — never on faith), and the pre-flight card prices runs that ride it at $0.00.

1. Same machine or LAN

Any OpenAI-compatible endpoint — Ollama, LM Studio, llama.cpp llama-server, LocalAI, vLLM — at http://localhost:11434 or a LAN address. Position First = local-first with cloud failover; Fallback = cloud-first with your endpoint catching cloud outages.

2. The mesh inference node — your home GPU, no open ports

The machine next to your GPU pairs onto the myrt mesh as a locked-down inference node (Settings → Inference node → Pair a node; single-use code, one binary, no root, NAT-proof). It is reachable only inside the tailnet — never exposed to the internet — and myrt verifies it live by probing it through the mesh. Media lanes ride the same node: image (A1111-compatible), STT and TTS (OpenAI-compatible), each live-verified on its own canonical port.

3. A tunnel — cloudflared, Tailscale Funnel or frp

Put a public URL in front of your home server and paste it into the same card. Each recipe's honest security posture is in the full guide (repo: docs/BYO-BRAIN.md) — the short version: a public URL is public; run a key-enforcing server behind it.

Honest split-routing — no parity promises

Local-first for mechanical lanes (summarize, extract, classify, reformat, drafts), cloud escalation for judgment lanes (debugging, refactoring, API design). Not vibes — receipts: on the cloud workhorse model the reproducible ceiling is 5/9 floor, 6/9 observed (the L1-L9 agent benchmark, pinned temp 0.2 / seed 42; full method in docs/EVAL_BASELINE.md), with debugging / refactoring / API design the stable failures even on the cloud model. A local model will not clear a bar the cloud workhorse misses — so myrt promises no local-cloud parity, ever. The chain position (First / Fallback) is the policy knob, and the pre-flight card shows the price per run before it happens.

Self-hosting & go-live#

Running your own myrt.cloud deployment? This is the operator checklist — everything below is already true for this deployment except the two steps that need a domain owner (DNS and the Polar product).

1. Point the domain

Create an A record for myrt.cloud (and www) pointing at this VPS. Once DNS resolves, Caddy issues a Let’s Encrypt certificate automatically on the first request — ports 80 and 443 are already open and the HTTPS site block (HSTS, SSE-safe timeouts, www redirect) is already configured. No certificate files to manage.

2. Turn on card billing

Billing runs on Polar.sh (Stripe was replaced — checkout and webhooks are already implemented). Create the products in Polar, then fill in the empty values the service unit already reserves:

# /etc/systemd/system/myrt-dashboard.service
Environment=POLAR_ACCESS_TOKEN=polar_at_...
Environment=POLAR_WEBHOOK_SECRET=whsec_...   # endpoint: https://myrt.cloud/api/billing/webhook
Environment=POLAR_PRODUCT_STARTUP=productid  # maps the 'startup' plan
Environment=POLAR_PRODUCT_PRO=productid      # maps the 'pro' plan
# then: systemctl daemon-reload && systemctl restart myrt-dashboard

Until those are set, the billing API answers honestly in dev mode: POST /api/billing/webhook with {"email","tier"} simulates a payment so you can test upgrades end-to-end. Signatures are verified with Polar’s Webhook-Id / Webhook-Timestamp / Webhook-Signature headers (HMAC-SHA256) once a secret is configured.