Developer Platform · API v1

Throwing, as an API.

Model a trajectory, initiate a governed throw, and clear it against the Do-Not-Yeet registry — in one HTTPS request. REST resources, JSON everywhere, signed webhooks, and official SDKs. Every call returns a ground-contact certificate. Regret is not a supported response type.

Introduction

The Yeeterprise API is organized around REST. It has predictable, resource-oriented URLs, accepts application/json request bodies, returns JSON responses, and uses standard HTTP verbs and response codes. The one non-standard guarantee: nothing you send goes up and stays there.

BASEhttps://api.yeeterprise.com/v1All requests over TLS 1.3. HTTP is dropped, appropriately.
The API is live and versioned. Breaking changes ship behind a new major version; v1 is supported until the objects it describes have all reached the ground.

Authentication

Authenticate with your secret API key in the Authorization header as a Bearer token. Keys carry the environment in the prefix: sk_live_ for production throws, sk_test_ for the sandbox (where objects are thrown but never actually leave the origin).

Authorization headerhttp
Authorization: Bearer sk_live_9f2c••••••••••••••••a71b
Treat secret keys like a loaded catapult. Never commit them, never ship them client-side, and rotate them from the Trust Center the moment one is exposed.

Quickstart

Initiate your first governed throw. This models the arc, clears the payload against the registry, and — if compliant — commits it to the ground with a certificate.

Initiate a throwcURL
curl https://api.yeeterprise.com/v1/throws \
  -H "Authorization: Bearer sk_live_9f2c…a71b" \
  -H "Content-Type: application/json" \
  -d '{
    "payload": "a slightly overripe banana",
    "origin": "desk-4F",
    "target_zone": "bin-north",
    "force": "governed"
  }'
202 Acceptedjson
{
  "id": "thr_0Kp9c2Ba71b",
  "object": "throw",
  "status": "in_flight",
  "compliance": { "registry_cleared": true, "class": null },
  "trajectory": { "apex_cm": 142, "time_to_ground_s": 0.71 },
  "regret": 0,
  "certificate_url": "https://api.yeeterprise.com/v1/throws/thr_0Kp9c2Ba71b/certificate"
}

Throws

A throw is the core object: one governed act of downward force, from release to ground contact, with its trajectory and compliance verdict attached.

POST/v1/throwsInitiate a governed throw
GET/v1/throws/:idRetrieve a throw
GET/v1/throwsList throws
POST/v1/throws/:id/abortAbort mid-arc (best effort; gravity permitting)

Request body

FieldTypeDescription
payloadstringrequiredA plain-language description of the object. Screened against the Do-Not-Yeet registry before release.
originstringrequiredRelease location. Used for arc modeling and audit.
target_zonestringoptionalIntended ground-contact zone. Defaults to nearest_sanctioned.
forceenumoptionalgoverned (default), gentle, or ceremonial. reckless is not a valid value and never will be.
idempotency_keystringoptionalGuarantees a payload is thrown at most once. Strongly recommended.

Trajectories

Model an arc before you commit to it. Returns apex, time-to-ground, and a confidence interval — no object leaves the origin.

POST/v1/trajectories/modelForecast an arc without releasing
Model a trajectoryjson
// POST /v1/trajectories/model
{
  "mass_g": 118,
  "release_velocity_ms": 3.4,
  "angle_deg": 38
}
// → { "apex_cm": 142, "time_to_ground_s": 0.71, "confidence": 0.992 }

Compliance checks

Query the Do-Not-Yeet registry directly. Every POST /v1/throws runs this automatically, but you can pre-flight a payload to fail fast and keep your regret metric clean.

GET/v1/compliance/check?asset=:textScreen a payload against 84 protected classes
403 — payload is protectedjson
{
  "error": {
    "type": "do_not_yeet",
    "code": "DNY-0002",
    "message": "Payload matches a protected class: a sleeping cat.",
    "resolution": "Do not yeet. There is no override. This is the whole point."
  }
}

Webhooks

Subscribe to lifecycle events so your systems learn the instant an object reaches the ground. Payloads are signed with your endpoint's secret; verify the Yeet-Signature header before trusting a body.

EventFires when
throw.in_flightA payload has been released and is airborne.
throw.groundedGround contact confirmed. Certificate attached.
throw.blockedThe policy engine halted a release pre-flight.
compliance.violation_avertedA registry match prevented a throw. Regret held at zero.

Rate limits

Limits are per API key, by plan. Exceeding a limit returns 429 with a Retry-After header. Objects do not queue in the air.

PlanThrows / minModel calls / minBurst
Sandbox6012010
Team6001,20060
EnterpriseNegotiatedNegotiatedBy SLA

Errors & status codes

Yeeterprise uses conventional HTTP status codes. Codes in the 2xx range mean the object is on its way down; 4xx means it never should have gone up.

CodeMeaning
200OK — resource retrieved.
202Accepted — throw released and in flight.
400Bad request — the payload description was unmodelable.
401Unauthorized — missing or invalid API key.
403Do-Not-Yeet — payload matches a protected class. Non-overridable.
409Conflict — idempotency key already thrown.
429Too many throws — slow down; gravity is a shared resource.
5xxGround fault — our side. The object stays put; we investigate.

SDKs

Official libraries wrap authentication, retries with idempotency, and webhook signature verification.

Installshell
# Node.js
npm install @yeeterprise/node
# Python
pip install yeeterprise
# Go
go get github.com/yeeterprise/yeeterprise-go
throw.jsnode
import Yeeterprise from "@yeeterprise/node";
const y = new Yeeterprise("sk_live_9f2c…a71b");

const throw_ = await y.throws.create({
  payload: "a stress ball, retired",
  origin: "desk-4F",
  force: "governed",
});
console.log(throw_.status, throw_.regret); // "in_flight" 0
Get your API keys. Keys are provisioned from the Trust Center with your workspace. Sandbox keys are instant; live keys unlock after a short compliance attestation. developers@yeeterprise.com for enterprise onboarding.
Source code on a screen

Built for builders

Throw programmatically. Attest automatically.

Issue a governed throw with a single API call and receive a signed attestation the moment the object reaches the ground. Every request is validated against the Do-Not-Yeet registry, so protected classes are rejected at the SDK layer before they ever leave your process.

Read the docs

Build downward

Ship your first governed throw today.

REST, JSON, webhooks, and SDKs — with a ground-contact certificate on every call.

Get API keys Read the Trust Center