Any workflow, a REST route.

Publish a workflow — or a saved page-extraction job — and Writ serves it at /v1/{slug}/{path}: no /api prefix, no server of yours to run, and callers hold their own consumer keys, never your credentials.

route ▸ how a call resolves

The route, resolved.

The gateway has no fixed paths of its own: the slug names your tenant, the path matches an endpoint you registered, and anything that does not resolve is a 404.

call ▸ post, read data

The first call.

POST the inputs, read the data back — these samples are the whole client:

curl -X POST https://api.usewrit.app/v1/acme/price-check \
  -H "Authorization: Bearer $WRIT_CONSUMER_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/product/42"}'

import os, requests

res = requests.post(
    "https://api.usewrit.app/v1/acme/price-check",
    headers={"Authorization": f"Bearer {os.environ['WRIT_CONSUMER_KEY']}"},  # csk_...
    json={"url": "https://example.com/product/42"},
    timeout=120,
)
res.raise_for_status()
payload = res.json()
print(payload["run_id"], payload["data"])

const res = await fetch("https://api.usewrit.app/v1/acme/price-check", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.WRIT_CONSUMER_KEY}`, // csk_...
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ url: "https://example.com/product/42" }),
});

if (!res.ok) throw new Error(`Writ call failed: ${res.status}`);
const { run_id, data } = await res.json();
console.log(run_id, data);

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body, _ := json.Marshal(map[string]string{"url": "https://example.com/product/42"})
	req, _ := http.NewRequest("POST", "https://api.usewrit.app/v1/acme/price-check", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("WRIT_CONSUMER_KEY")) // csk_...
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	var out struct {
		RunID string          `json:"run_id"`
		Data  json.RawMessage `json:"data"`
	}
	json.NewDecoder(res.Body).Decode(&out)
	fmt.Println(out.RunID, string(out.Data))
}

use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("WRIT_CONSUMER_KEY")?; // csk_...
    let res: Value = reqwest::Client::new()
        .post("https://api.usewrit.app/v1/acme/price-check")
        .bearer_auth(key)
        .json(&json!({ "url": "https://example.com/product/42" }))
        .send()
        .await?
        .error_for_status()?
        .json()
        .await?;

    println!("{} {}", res["run_id"], res["data"]);
    Ok(())
}

wait ▸ sync by default

Synchronous by default, async on request.

There is no wait= parameter on this lane. A call runs synchronously up to the endpoint’s timeout_seconds (5–300, default 120) and answers 200 with the result inline; past the budget it answers 504 — still carrying the run handle, so nothing is lost.

Freshness

Send Cache-Control: max-age=N or ?max_age=N per call. 0 forces a fresh run; when absent, the endpoint’s own cache_ttl_seconds (0–86400) decides.

shape ▸ response_format

One of three envelopes.

Each endpoint chooses how its payload is wrapped:

order ▸ the gates

The gate order, exactly.

Every call walks the same ordered checks. Knowing the order tells you which limit you hit and which header to read:

1. 01
   Tenant

   Unknown {slug} → 404.

2. 02
   Endpoint

   No registered endpoint on this (method, path) → 404.

3. 03
   Consumer key

   Missing or invalid Bearer consumer key → 401.

4. 04
   Per-key rate limit

   A sliding 60-second window — the key’s rate_limit_per_minute, else the endpoint’s rate_limit_override, else 60/min. Over it → 429 with X-RateLimit-* and Retry-After: 60.

5. 05
   Daily fair-use

   An org-wide daily ceiling on relay calls to published endpoints — 2,000/day on Free up to 250,000/day on Enterprise. Over it → 429 with Retry-After: 3600.

6. 06
   Per-key monthly quota

   The key’s monthly_quota, counted before dispatch — over it → 429 “Used {n}/{quota} calls this month”.

7. 07
   Org monthly quota

   Your plan’s monthly managed-API call quota (managed_api_calls_per_month).

8. 08
   Cache

   A cached result younger than the allowed age returns here, without starting a run.

9. 09
   Dispatch

   The workflow — or saved extraction job — runs on its configured venue.

10. 10
    Usage

    The call lands in per-key and per-endpoint usage analytics.

Quotas by plan

Published routes are capped as objects; calls are capped monthly per org and daily as fair use. Unknown-key and 404 traffic never counts against you:

faq

Questions, answered.

go ▸ publish

Publish your first endpoint.

Pick a workflow, register a route, and hand your callers a URL that answers in one POST.