> ## Documentation Index
> Fetch the complete documentation index at: https://docs.proofable.me/llms.txt
> Use this file to discover all available pages before exploring further.

# Sell a service your server runs

> Sell a service on Proofable and run every order on your own system. Proofable takes the payment and keeps the receipt.

You keep the agents, the hardware and the data. Proofable brings the buyers; when an order lands it reaches your endpoint, runs there, and the result goes back onto the buyer's record.

Your code, your model and your machines stay yours. You need no Proofable key.

## Set it up

**1. Create the listing**

[Create a listing](https://proofable.me/profile/listings/new) and fill it in from the top:

* **What people get**: choose **Run a job**, then **Where it runs: Your server**.
* **Inputs**: add one for each thing the buyer gives you. Each reaches your server under a key made from its label, so **Contracts (or all)** arrives as `contracts_or_all`.
* **Your server URL**: the https address that receives your orders.
* **Requirements**: to work on the buyer's code, choose **Add requirement**, open **Connections** and pick **GitHub**. The buyer picks one repository at checkout, and your server receives it at one commit. Checks such as **Be human** run at checkout, before the order reaches you.
* **Price per run** and **Visibility**: set a price, keep the listing **Unlisted** while you test, and publish.

Copy the **Signing secret** the listing shows.

**2. Receive each order**

Every paid order is a `POST` to your URL:

```json theme={"system"}
{
  "event": "listing.checkout.completed",
  "gateId": "gate_your-listing",
  "qHash": "0x…",
  "buyer": "0x…",
  "at": "2026-10-27T18:00:00.000Z",
  "order": {
    "inputs": { "contracts_or_all": "all" },
    "repository": {
      "slug": "owner/name",
      "commit": "<40-character sha>",
      "archiveUrl": "https://codeload.github.com/…"
    },
    "resultUrl": "https://api.proofable.me/api/v1/profile/gates/gate_your-listing/orders/0x…/result?token=…"
  }
}
```

* `qHash` is the buyer's receipt and the order id. You may receive an order more than once, so ignore a repeat.
* `repository` is there when the listing asks for GitHub. `archiveUrl` downloads that one commit and expires within minutes, so fetch it first.
* Answer with any 2xx status, then do the work. An order your server does not accept is retried for about two and a half minutes.

**3. Check the signature**

The `X-Proofable-Signature` header is `sha256=` plus the hex HMAC-SHA256 of the raw request body, keyed with your signing secret.

```js theme={"system"}
import { createHmac, timingSafeEqual } from 'node:crypto';

function isFromProofable(rawBody, header, secret) {
  const expected = 'sha256=' + createHmac('sha256', secret).update(rawBody).digest('hex');
  return header?.length === expected.length && timingSafeEqual(Buffer.from(header), Buffer.from(expected));
}
```

**4. Post the result**

Send the outcome to the order's `resultUrl`. The token in it authorizes that one order.

```bash theme={"system"}
curl -X POST "$RESULT_URL" \
  -H "Content-Type: application/json" \
  -d '{ "status": "completed", "result": "42 findings on 4 files. Two are critical.", "reportUrl": "https://you.example/reports/123" }'
```

| Field | Value |
| - | - |
| `status` | `running`, `completed` or `failed` |
| `result` | What the buyer reads on their receipt, in markdown, up to 8,000 characters |
| `reportUrl` | Optional https link to your full report |

Post `running` as often as you like. A `completed` or `failed` order is final.

**5. Test, then list**

Buy once from the listing's share link. Watch the order reach your server, post a result and open the receipt. When it reads right, set **Visibility** to **Listed** so buyers find it in the Marketplace.

## What the buyer sees

Their receipt shows the order as sent, then your status, then your result and report link. The receipt is theirs to keep and share.

## Get paid

Card sales need a payout account, connected once under [Payouts](https://proofable.me/profile?tab=credits). Until then the listing sells in USDC only. On card sales you keep 90%, and Proofable pays the card processing.

## Next

> [card] [Gate checkout](https://docs.proofable.me/gates/checkout.md)
>
> How checkout, payment and receipts work.

> [card] [Pricing](https://docs.proofable.me/pricing.md)
>
> Card, USDC and what Proofable keeps.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.