# Pricing

Free to build. On Free, services.dev earns only when your Service gets paid. There is no trial clock: each gated key runs three paid live jobs, however long they take.

Every key runs on every plan in test, so you build and test the whole Service on Free. Your plan decides which keys run on live jobs, and `check` names the plan your file needs, with the line that needs it:

```txt
$ npx services.dev check
services/translation.ts · 14 lines · $89 per job, within 48 hours, charged on file's receipt.
  plan    Launch (services.dev) · roles.translator.pool at services/translation.ts:6 · subject at :13 · clocks at :14
          every key runs in test on any plan · deploy --live asks for Launch
  take    your plan's take on each released charge · never on the translator's $30.00
```

## Which plan does a Service like mine need?

`check` derives it from the files. For the reference Services, rung by rung:

| Service | Plan | Because | Run |
|---|---|---|---|
| [lingua](https://services.dev/docs/examples/lingua.md) | Free | no gated key | `npx services.dev check --plan services/` |
|  | Launch | `Pool({...})` | `npx services.dev check --plan grow/role.ts` |
| [api.lawyer](https://services.dev/docs/examples/legal.md) | Free | no gated key | `npx services.dev check --fit free services/trademark-response.ts` |
|  | Launch | `Brand.domain`, `Pool({...})`, `Pool.dispatch`, `subject, subject.period`, `on.schedule`, `price.every, price.includes`, `clocks.lives_on: 'subject'` | `npx services.dev check --fit launch` |
|  | Team | `Rules.regions`, `dispatch: 'cascade'`, `Pool.rank, Pool.affinity`, `Pool.tiers, Pool.firms`, `on.event`, `subject.of_record.custodian, subject.steward` | `npx services.dev check --plan` |
| [apis.tax](https://services.dev/docs/examples/tax.md) | Free | no gated key | `npx services.dev check --fit free services/annual-return.ts` |
|  | Launch | `Brand.domain`, `Pool({...})`, `Pool.payouts.schedule, hold_first`, `subject, subject.period`, `subject.keeps`, `clocks.lives_on: 'subject'`, `price.every, price.includes`, `price.share, outcome`, `on.schedule`, `on.event`, `pool: '<door>/<pool>'` | `npx services.dev check --fit launch` |
|  | Team | `Pool.door, Pool.public`, `Pool.tiers, Pool.firms`, `Pool.rank, Pool.affinity`, `Pool.standby`, `subject.of_record.custodian, subject.steward`, `clocks.<c>.guarantee`, `on.event` | `npx services.dev check --plan` |
| [api.forsale](https://services.dev/docs/examples/sales.md) | Free | no gated key | `npx services.dev check --fit free services/deal.ts` |
|  | Launch | `Brand.domain`, `Pool({...})`, `door: '<existing door>'`, `Pool.payouts.schedule, hold_first`, `pay: { usd, on: <end> }`, `price.share, outcome` | `npx services.dev check --fit launch` |
|  | Team | `Pool.rank, Pool.affinity`, `Pool.tiers, Pool.firms`, `pay: { share }` | `npx services.dev check --plan` |

| Plan | For | Price | Take on each paid job | Runs live |
|---|---|---|---|---|
| **Free** | Sell your first Service | $0 | The highest | lingua; api.lawyer's trademark responses, signed by you; apis.tax's returns, signed by you; api.forsale's meetings, held by you |
| **Launch** | Your name, your people, work that recurs | — | A lower | lingua with its own Pool; api.lawyer as a small practice; apis.tax as a small practice; api.forsale on closers.deals |
| **Team** | Run a market, paid on the win | — | A lower still | api.lawyer at full depth; apis.tax at full depth; api.forsale at full depth |
| **Scale** | Pass the buyer's review | — | The lowest | any of them, private and pinned to a region |

## Free · Sell your first Service

Pay only when a job's charge releases.

| Adds | Key |
|---|---|
| API, CLI, MCP, SDK, Site, Docs and every app, on builder.domains | `Service({...})` |
| The brand's own words on every surface | `Brand.words` |
| Adversarial and "yes, and" review, any lenses, any rounds | `review` |
| A person approves the jobs you pick | `human: 'risky'` |
| A fixed share of delivered jobs checked | `human: { sample }` |
| The seven asks: sign, consent, answer, upload, direct, decide, grant | `deliver.<step>.ask` |
| Your own code as a step, citing the rule it follows | `deliver.<step>.by` |
| Filings with typed receipts and repair windows | `deliver.<step>.submit` |
| Deadlines, ends, policy, signals, talk and nested Services | `within, ends, policy` |
| Dates the world sets on a job, with rungs that run steps and moves | `clocks` |
| Per job, per unit, by tier, self-help and an approval upgrade | `price` |
| Release on delivery, acceptance or a receipt | `price.release` |
| Pass-through fees at cost | `price.lines` |
| You and your staff, as signers and reviewers | `roles.<r>` |
| Test and live keys, and buyer OAuth |  |

## Launch · Your name, your people, work that recurs

You need Launch when: the Service moves to your own domain (`Brand.domain`); the second verified person (`Pool({...})`); the first Task an imported Pool fills (`pool: '<door>/<pool>'`); your Pool lists on an existing door (`door: '<existing door>'`); the first obligation that outlives its job (`subject, subject.period`); the first subscription (`price.every, price.includes`); the first deal paid on the close (`price.share, outcome`); the first review line worth deleting (`human: { sample, floor }`); the take you'd save passes Launch's price.

| Adds | Key |
|---|---|
| Your own domain for every surface and app | `Brand.domain` |
| A sample that falls while send-backs stay rare | `human: { sample, floor }` |
| The "delete the line" signal, once a person stops changing anything |  |
| Brief corrections written back from reviews | `deliver.feedback` |
| A clock that lives on the subject and outlives its job | `clocks.lives_on: 'subject'` |
| What outlives the job, one job per period | `subject, subject.period` |
| Facts kept for next period, such as carryforwards | `subject.keeps` |
| Subscriptions with allowances | `price.every, price.includes` |
| Schedules that mint jobs on the minted Service's own dates, and catch up after a gap or a late start | `on.schedule` |
| Events that mint a Service the same subscription's allowance counts | `on.event` |
| Outcome pricing, with proof and reversal windows | `price.share, outcome` |
| Flat pay at an end, held with the outcome | `pay: { usd, on: <end> }` |
| A payout schedule, and a hold on a new member's first Tasks | `Pool.payouts.schedule, hold_first` |
| An imported Pool another operator runs, with its placement line | `pool: '<door>/<pool>'` |
| Your Pool listed on an existing door, with its placement line | `door: '<existing door>'` |
| Your own Pool, at /<pool> on your brand | `Pool({...})` |
| Feed, pick and direct dispatch | `Pool.dispatch` |
| The default fill ladder, and probation | `Pool.fill, Pool.probation` |
| Separation of duties across your members | `with: { differ }` |

## Team · Run a market, paid on the win

You need Team when: placement paid passes the cost of a door of your own (`Pool.door, Pool.public`); the first Task nobody claims (`dispatch: 'cascade'`); the first firm with a bench (`Pool.tiers, Pool.firms`); the first member paid a share (`pay: { share }`); the first season your Pool can't fill on raises alone (`Pool.standby`); the second region (`Rules.regions`); the first reseller (`Brand.tenants`); the take you'd save passes Team's price.

| Adds | Key |
|---|---|
| A credential the brand holds that no Rules row requires, and credentials across regions | `Brand.credentials` |
| Tenants reselling your Services as their own offers | `Brand.tenants` |
| Review evals: each lens scored on held-out jobs |  |
| A date sold as a promise: penalties credited from your line, up to a cap | `clocks.<c>.guarantee` |
| The custodian ladder for who is of record, and a steward Service | `subject.of_record.custodian, subject.steward` |
| Events routed to Services outside the subscription, and grants kept on a subject | `on.event` |
| Share pay to members, and referral shares | `pay: { share }` |
| Cascade: each Task offered to one member at a time, and a fill ladder you tune | `dispatch: 'cascade'` |
| Ranked offers, and affinity to the member who served the buyer before | `Pool.rank, Pool.affinity` |
| Tiers, golden Tasks and firms with a bench | `Pool.tiers, Pool.firms` |
| Separation across roles and firms | `with: { differ }` |
| Work-register Pools: completion evidence at a site, in a window | `Pool.register: 'work'` |
| A door your account operates, on its own domain, with a public demand board | `Pool.door, Pool.public` |
| Committed hours for a dated season | `Pool.standby` |
| One Pool across your brands |  |
| Rules across regions | `Rules.regions` |
| Staff SSO, custom roles and preview deploys |  |
| OAuth apps for integrators |  |

## Scale · Pass the buyer's review

You need Scale when: a buyer's security questionnaire; another operator asks to staff from your Pool (`Pool.export`); a practice wants its own bench (`Brand.workspaces`); the take you'd save passes Scale's price.

| Adds | Key |
|---|---|
| Practice workspaces, with their own professionals | `Brand.workspaces` |
| Unlimited members in Pools you own |  |
| Your Pool exported for import; you earn its placement line | `Pool.export` |
| SCIM, audit export and SIEM |  |
| Private deploys, data regions, uptime terms and invoices |  |

## Limits

| Limit | Free | Launch | Team | Scale |
|---|---|---|---|---|
| Signers: you and your staff | 3 | — | — | — |
| Members in Pools you own | none | 5 | 50 | Unlimited |
| Members in a Pool you import | none | Unlimited | Unlimited | Unlimited |
| Tenants | none | none | 10 | 25 and up |
| Rules regions | 1 | 1 | Unlimited | Unlimited |
| The audit log | 7 days | 30 days | 90 days | 400 days |

At a limit, the next member, tenant or region answers the same OFFER; nothing already running stops.

## Never for sale

| On every plan | Key |
|---|---|
| Rules rows, each with counsel's position | `rules` |
| Every reserved act is signed by a credentialed person or refused with its cure; the plan sets how many people you seat, never whether an act is lawful | `sign: { by: '<role>' }` |
| A credential the brand holds, when a Rules row names it for a reserved act | `and: { brand: '<credential>' }` |
| The stamped signature, written into the artifact before it is hashed | `stamp: true` |
| Consent and sign asks | `ask: 'client'` |
| A licensed fee on the member's own rail, at a two-seller checkout | `rail: 'member'` |
| No take on a licensed fee, or on any member-rail fee | `the take` |
| Flat pay on every outcome of the act, a send-back and a decline included | `pay: <usd>` |
| Pay accrues at the act, on its own clock, and is never clawed back, on a sampled job or after a downgrade | `payouts: { at: 'act' }` |
| Held share pay sits untransferred under its own job, and only that job's outcome going back inside its window reverses it | `held_pay_exposed` |
| services.dev takes nothing a member pays | `Pool.fee, instant_fee` |
| No member is charged per Task, per lead or by a percentage; the one allowed charge is a flat software fee, declared before anyone joins | `member_charged` |
| A refusal never charges | `act_refused` |
| The append-only record of every job | `the record` |

## The take

Each dollar of a released charge has one claimant. services.dev's take sits on one line: the value your brand adds.

**you = charge − tax − processing − AI − pay − pass-through − coverage − placement − nested Services − services.dev's take**

It applies only when a charge releases, reverses with it, and falls as the plan rises. Its base is the value your brand adds: the released charge, less member pay, pass-through fees and coverage at cost, licensed fees, placement lines and nested Services' own lines. A placement line carries one claim, the door operator's. On an outcome price, the take is held beside the held share and reverses with it inside `outcome.window`. A tenant's markup is the tenant's own seller line, under its own plan's take. A subscription's take falls at each release, on that cycle's charge less that cycle's pay, and a job inside an allowance carries none. Nothing is taken from a member's pay.

A plan pays for itself once the take it saves passes its price: your month's take base, times the gap between the two plans' takes, against the gap between their prices.

**lingua**

```txt
job_7Hq2 · Translation, signed · $89.00 released on delivery
  line                  amount  claimant              services.dev's take
  The translator's pay  $30.00  the sworn translator  $0
  lingua's value added  $59.00  lingua                the take
  AI $0.84 comes out of lingua's line. The take sits on $59.00 and nowhere else.
```

**api.lawyer**

```txt
job_7Hq3 · Trademark Office Action Response · $349.00 released on the USPTO's receipt
  line                                      amount   claimant                            services.dev's take
  The attorney's fee, sold by the attorney  $175.00  the attorney, on their own account  $0
  Coverage, at cost                         $4.00    the Pool's malpractice cover        $0
  api.lawyer's value added                  $170.00  api.lawyer                          the take
  Two sellers on one receipt. AI $2.10 comes out of api.lawyer's line.
```

**apis.tax**

```txt
sbn_7Hq2 · Tax Plan, cycle 1 · $2,400.00 released at the cycle's end, 2028-01-20
  line                                  amount     claimant                services.dev's take
  The signer's pay, two signatures      $210.00    the signer              $0
  The representative's pay, one notice  $90.00     the representative      $0
  Eight jobs inside the allowance       $0.00      no charge of their own  $0
  apis.tax's value added                $2,100.00  apis.tax                the take
  AI $7.56 across the eight jobs comes out of apis.tax's line. The take settles once, on $2,100.00.
```

**api.forsale**

```txt
job_7Hq5 · Deal, 5% at won and the closer's 10% · $11,100.00 released at won on a $74,000.00 deal, proven by the payment
  line                                       amount     claimant                              services.dev's take
  The closer's share, charged to the seller  $7,400.00  the closer, 10% at won                $0 · held to the window
  The setter's pay                           $250.00    the setter, flat at the held meeting  $0
  Placement, two gigs on closers.deals       $50.00     the door's operator                   $0
  api.forsale's value added                  $3,400.00  api.forsale                           the take · held to the window
  AI $11.34 comes out of api.forsale's line. If the payment reverses inside the 60 days, the 5%, the closer's share and the take reverse together; the setter keeps their $250.00.
```

## Going live on a gated key

Each gated key runs three released live jobs before your plan is asked for. Then `deploy --live` answers OFFER with the plan, the keys that need it, and the cure:

```txt
$ npx services.dev deploy --live
OFFER · Launch runs this Service live.
  because roles.translator.pool at services/translation.ts:6 · 3 of 3 sampled jobs released
          subject at services/translation.ts:13 · 1 of 3 sampled jobs released
          clocks.renewal at services/translation.ts:14 · 1 of 3 sampled jobs released
  cure    upgrade to Launch, or services.dev check --fit free
  next    npx services.dev plan upgrade launch
```

The gate reads each Service, not the folder: apis.tax sells transcripts on Free while its annual return's sample runs, and only the jobs that reach a gated key wait for its plan. A job, a subject and a subscription keep the plan they started under.

## Before you pick

**Do I choose a plan?** `check` reads it off your files and names each line that needs it. `deploy --live` asks for it once a gated key has run its three sampled jobs, and your coding agent can accept within a plan ceiling you set.

**Is there a trial?** There is no clock. Every key runs in test on every plan, and each gated key runs three paid live jobs before your plan is asked for, however long a season takes. Where a job takes months to release, three run in flight at a time, a fourth live order answers OFFER, and the console dates the end.

**What does the take apply to?** The value your brand adds, never the whole charge: you = charge − tax − processing − AI − pay − pass-through − coverage − placement − nested Services − services.dev's take. A placement line carries one claim, the door operator's, and the take never touches it.

**What happens on a refund?** The take reverses with the charge. Each charge runs on behalf of your account, so a refund draws on your share of it, and pay a member earned at the act stays theirs.

**Can I downgrade?** Yes, and nothing in flight stops. A job, a subject with its clocks, and a paid subscription cycle keep the plan they started under. Members see any change on the delivery portal before new Tasks stop.

**Do my buyers see services.dev?** No. Every surface, app and receipt carries your brand, and the take is a line on your ledger, never the buyer's.

[Plans in the docs](https://services.dev/docs/money/plans.md)