pitch.api.forsale

api.forsale

Sales is now an API.

Define your offer and your Mandate. Agents work every Deal; human closers take over exactly where you declare. You pay on outcomes.

↓ scroll · arrow keys

The capability contract

A Deal is a state machine: sourced → qualified → meeting → proposal → negotiation → closed_won | closed_lost. Stages are derived from Events — the append-only log every executor writes to — never authored. Terminal is forever — a lost Deal is never reopened; re-engagement mints a new Deal with a lineage edge, so history stays immutable.

You declare one object — the Mandate — and the rail does the rest:

POST /deals
{
  "account": { "name": "Northwind", "industry": "Enterprise SaaS", "actor": "B2B" },
  "listValueUsd": 80000,
  "mandate": {
    "staffing": {
      "setter":   "agent",
      "closer":   { "humanIf": { "minDealSizeUsd": 25000 } },
      "nurturer": "agent"
    },
    "floorPct": 0.8,
    "commissionPct": 0.10,
    "fees": { "setterUsd": 250, "nurturerUsd": 150 },
    "stallTimeoutDays": 14
  }
}

Staffing is per-Role, not per-stage: Setter (sourced → meeting held), Closer (meeting → terminal), Nurturer (a stalled Deal — a gone_dark Signal — back to revived or confirmed dead). In execution terms: a Setter runs outreach to your prospects in your name — sourcing, first touch, follow-up — until a meeting is held; a Closer runs the meeting, the proposal, and the negotiation; a Nurturer works a gone-dark Deal back to life. None of them can promise anything on your behalf: everything an executor does — every advance, every close — only proposes, and only your Deal's Gate commits. Each Role has a defined exit condition, and each value is 'agent' | 'human' | { humanIf }. Out-of-bounds values are a 422 at creation; platform defaults fill anything left unset. Parameters are yours; semantics are house rules. That is what keeps every closer's Register — the record of Gate-committed closes that serves as their résumé — comparable, and every Gig evaluable from the feed it posts to.

Propose → Gate → commit

Everything that works a Deal — an AI agent, a human closer — is judgment-only. Executors return proposals: advance-to, close value, discovered Signals. One code path commits: the Deal's Gate, which enforces transition legality, your negotiation floor, and the commission cap. A below-floor close comes back as a 422 even when a human proposed it, and the Gig stays claimed.

This is the answer to the real reason you haven't handed your deals to anyone: everywhere else, delegation means surrendering authority. Here, authority is structural. It never sits with the maker of the proposal, human or agent — it never leaves the rail.

Postedapi.forsale/docs/quickstart

The gate mechanics are shown as a labeled demo scenario in the live docs: an $80,000-list Deal with a $64,000 floor refuses a $50,000 close mid-Gig (422, Gig stays claimed) and commits the $74,000 retry. Illustrative product mechanics, not results.

Three surfaces, one rail

  • HTTPPOST /deals, stage advances, settlement records. Webhook-style callbacks; typed refusals.
  • MCP — mount a sales team as a tool: sell, get_deal, advance_deal. Built for agent callers from day one; the B2A motion is the same surface with a machine on the other end.
  • SDK — a thin, hand-rolled typed client. Non-2xx surfaces as typed errors (GateRefusedError carries the refusal payload), and domain types are re-exported so your code never imports the server.
Postedapi.forsale

api.forsale is live with the onboarding funnel and six docs pages: Quickstart · Concepts · API reference · SDK · MCP · Demo environment. The quickstart runs a deal to close in five calls against the demo environment, no key required.

Pendinggate: demo environment served from api.forsale itself

Every copy-paste snippet in the docs points at api.forsale itself before any API key ships — nothing you paste will ever reference a domain the brand doesn't own.

Why this has to exist

Every other function of a software company became infrastructure — payments, infra, comms, auth: callable, declarative, priced on use. Sales is the last one you're still told to staff. The alternatives all charge for effort: agencies and SDR shops invoice by the month whether or not anything closes, and with outsourced commission arrangements, you find out what was promised to your buyer after it was promised.

The people this rail serves shipped a product that sells — they can close it themselves when they demo it. What they don't have, and don't want, is an org: recruiting, ramping, forecast calls, quota misses. What they've never been offered is delegation that doesn't surrender authority — which the Gate enforces in code.

Human~95% of function cost
Agenticorchestration-priced
Generativeinference-priced
Codenear-zero marginal

How it goes to market

The motion is B2D: developers and agent-builders, reached where they already evaluate — the docs, the runnable demo, the MCP registry surface. No paid or scaled acquisition pre-launch; the funnel is an honest onboarding survey, and keys go out in small batches as access opens. The secondary motion is B2A: the same rail addressed by agents directly over MCP, with machine-readable offers on the roadmap.

The Actor axis (B2B / B2C / B2D / B2A) is deal-level configuration on the rail — one closing capability specialized per buyer — never a product split.

Where it stands

Postedapi.forsale

The demand rail's front door is live: hero contract, docs, and the API-key onboarding funnel.

Postedclosers.sale

The human fulfillment layer has live doors: closers.sale (high-ticket B2C tribe) and closers.deals (B2B), recruiting supply against the same substrate.

Pendinggate: first external Seller Deal settled on closed_won

Settlement has run end-to-end in the demo environment — fee, commission, and platform fee on one Deal. The claim that matters posts when a real Seller's Deal settles, with the record in evidence. Marketplace liquidity is never implied before it exists.

Two faces, one substrate

The human marketplace is not a separate product — it is the fulfillment layer for the rail's hard cases. When your Mandate escalates a Role, a fully-briefed, flat-priced Gig posts to the supply doors; everything the contractor does, intermediate advances included, only proposes back through your Deal's Gate. One Deal model, one Register system, one authority seam.

Demand face: this rail. Supply face: closers.sale — where the same Gate that enforces your floor is what makes a closer's record provable. That is the whole meaning of verified here: a closer is verified by their Register — Gate-committed closes on this rail — not by a badge or a résumé.

Run it

Read the docs. Run the quickstart against the demo environment — deal to close in five calls, no key required. When it holds up, apply for a key: keys go out in small batches, and the short survey (what you sell, actor mix, volume) is how you get into the next one. Early Sellers get design-partner attention — your Mandate is one of the ones the rail is tuned against while the batches are still small.