# Selling software with license keys without Gumroad: activate, validate and deactivate, tested with curl

> Sendclap issues per-device license keys at a 1% fee with no API key in your app. Every activate, validate and deactivate response tested with curl on 2026-11-20.

Published November 20, 2026 on Sendclap Notes: https://blog.sendclap.com/software-license-keys-without-gumroad-curl-tested/

Lemon Squeezy closed new store sign-ups on November 16, 2026 and announced it is shutting down on March 31, 2027. If you move to Stripe Managed Payments, Lemon Squeezy's own migration guide says digital fulfillment and license keys aren't included. That leaves Gumroad at 10% + 50¢ per direct sale (or 30% via Discover), where the license API only keeps a flat usage integer, or building your own license server.

[Sendclap](https://sendclap.com) issues per-device license keys out of the box at a flat 1% fee plus Stripe's card processing (or 1% flat in crypto), with three unauthenticated endpoints your app can call straight from the user's machine: `/api/v1/licenses/activate`, `/api/v1/licenses/validate`, and `/api/v1/licenses/deactivate`. On a $29 software license, you keep about $27.57 by US card or $28.71 in USDC on Base, compared to $25.60 on Gumroad or $27.05 on Lemon Squeezy while it lasts. Sendclap isn't a merchant of record, so you handle your own sales tax and VAT, and payouts settle directly in your own Stripe account or wallet.

I ran every license endpoint and error path with `curl` on November 20, 2026. Because Sendclap's live `/demo` page takes real money, I verified the unknown-key responses against live `https://sendclap.com/api/v1/licenses/*` and ran the full purchase, activation, limit, deactivation, refund, and subscription-expiry sequence against a local `backmeupplz/sendclap` server (commit `8432e113`, Bun 1.3.1, `SIMULATE=1`). Here are the exact responses and how they compare with Gumroad and Lemon Squeezy.

## How Sendclap generates and stores a key

When someone buys a product with license keys turned on, Sendclap generates a 20-character key from a 32-character alphabet without `0`, `1`, `I`, or `O` (`ABCDEFGHJKLMNPQRSTUVWXYZ23456789`) so customers don't mix up zeroes and letters when typing a key in. It formats the key in four groups of five characters, puts it in the receipt email, and shows it under `/account`.

Buying the $29 "Pro license" on the local demo page (default limit of 3 devices) issued `RNBAB-FPZWW-8RSNN-3JGXV`. Activations live in SQLite with a composite primary key on `(license_key, instance)`, so activating the same machine twice never burns a second seat.

## Validate always returns HTTP 200

Mixing HTTP errors with license states forces every client app to guess whether a 404 came from a mistyped key, a misconfigured proxy, or a broken route. Sendclap's `POST /api/v1/licenses/validate` always answers HTTP 200 with a boolean `valid` and a five-value `status`: `active`, `not_activated`, `expired`, `disabled`, or `not_found`. Your app branches on one field and saves offline grace handling for real network errors or 5xx replies.

Hitting live `sendclap.com` with an unknown key on 2026-11-20 (`server-timing: app;dur=1.33`):

```sh
curl -i -X POST https://sendclap.com/api/v1/licenses/validate \
  -H "Content-Type: application/json" \
  -d '{"license_key":"AAAAA-BBBBB-CCCCC-DDDDD"}'
```

```json
HTTP/2 200
{"valid":false,"status":"not_found"}
```

On the freshly issued key before any device activates it, calling `validate` without an `instance_id` checks the key itself:

```sh
curl -X POST http://127.0.0.1:3999/api/v1/licenses/validate \
  -H "Content-Type: application/json" \
  -d '{"license_key":"RNBAB-FPZWW-8RSNN-3JGXV"}'
```

```json
{"valid":true,"status":"active","license":{"key":"RNBAB-FPZWW-8RSNN-3JGXV","activations":0,"max_activations":3,"expires_at":null},"product":{"id":1,"name":"Pro license"}}
```

Pass an `instance_id` that hasn't been activated yet and `validate` still returns HTTP 200, with `valid: false` and `status: "not_activated"`:

```sh
curl -X POST http://127.0.0.1:3999/api/v1/licenses/validate \
  -H "Content-Type: application/json" \
  -d '{"license_key":"RNBAB-FPZWW-8RSNN-3JGXV","instance_id":"macbook"}'
```

```json
{"valid":false,"status":"not_activated","license":{"key":"RNBAB-FPZWW-8RSNN-3JGXV","activations":0,"max_activations":3,"expires_at":null},"product":{"id":1,"name":"Pro license"}}
```

## Activate, idempotency, and the 409 limit

Activating the first machine registers `"macbook"` against the key:

```sh
curl -X POST http://127.0.0.1:3999/api/v1/licenses/activate \
  -H "Content-Type: application/json" \
  -d '{"license_key":"RNBAB-FPZWW-8RSNN-3JGXV","instance_id":"macbook"}'
```

```json
{"activated":true,"instance_id":"macbook","license":{"key":"RNBAB-FPZWW-8RSNN-3JGXV","activations":1,"max_activations":3,"expires_at":null},"product":{"id":1,"name":"Pro license"}}
```

Running that exact `activate` call again returned `200` with `activations: 1`. Because Sendclap keys on the `instance_id` you send (up to 200 characters, like a hostname or hashed machine ID), a retry after a dropped connection or a reinstall on the same laptop never eats another seat.

If you're moving an app off Lemon Squeezy, you don't even have to switch away from form posts immediately. Sendclap accepts `application/x-www-form-urlencoded` and treats `instance_name` as an alias for `instance_id`:

```sh
curl -X POST http://127.0.0.1:3999/api/v1/licenses/activate \
  -d "license_key=RNBAB-FPZWW-8RSNN-3JGXV" \
  -d "instance_name=linux-box"
```

```json
{"activated":true,"instance_id":"linux-box","license":{"key":"RNBAB-FPZWW-8RSNN-3JGXV","activations":2,"max_activations":3,"expires_at":null},"product":{"id":1,"name":"Pro license"}}
```

After activating a third machine (`"ci-runner"`, `activations: 3`), trying a fourth (`"spare-laptop"`) returned HTTP 409:

```json
HTTP/1.1 409
{"license":{"key":"RNBAB-FPZWW-8RSNN-3JGXV","activations":3,"max_activations":3,"expires_at":null},"product":{"id":1,"name":"Pro license"},"error":"activation limit reached","code":"activation_limit"}
```

Unlike the other errors, `409 activation_limit` returns the `license` and `product` objects so your app can show "3 of 3 devices used" without making a second request. Missing `instance_id` returns HTTP 400 (`bad_request`). An unknown key on `activate` or `deactivate` returns HTTP 404 (`license_not_found`), which I verified both locally and on live `sendclap.com`.

## Deactivate a machine to free a seat

When a buyer switches laptops, your app can release its own seat without talking to your backend:

```sh
curl -X POST http://127.0.0.1:3999/api/v1/licenses/deactivate \
  -H "Content-Type: application/json" \
  -d '{"license_key":"RNBAB-FPZWW-8RSNN-3JGXV","instance_id":"ci-runner"}'
```

```json
{"deactivated":true,"license":{"key":"RNBAB-FPZWW-8RSNN-3JGXV","activations":2,"max_activations":3,"expires_at":null},"product":{"id":1,"name":"Pro license"}}
```

Activating `"spare-laptop"` right after succeeded with `activations: 3`. Calling `deactivate` on a device that isn't activated on the key returned HTTP 404 (`{"error":"that instance is not activated on this license key","code":"instance_not_found"}`).

## Refunds, disputes, and subscription keys

I checked `app/src/stripe.ts`, `app/src/evidence.ts`, and `app/src/ledger.ts` to see how post-sale events affect keys, then verified both states with `curl`.

When Stripe sends a full `charge.refunded` webhook (partial refunds leave the key active) or `charge.dispute.created`, Sendclap sets `licenses.disabled = 1`. From that point on, `validate` returns HTTP 200 with `{"valid":false,"status":"disabled"}` and `activate` returns HTTP 403 (`code: "license_disabled"`). If you fight the dispute and win (`charge.dispute.closed` with `won` or `warning_closed`), Sendclap flips `disabled` back to `0` automatically.

There's a practical bonus hidden in `server.ts`: every `activate`, `validate`, and `deactivate` call on a real key logs an event with the device string and IP address against that payment. If a customer opens a chargeback, Sendclap pulls those events into a dispute evidence report (downloadable as a PDF and drafted onto the Stripe dispute). Checking the license on startup builds your delivery proof for free.

For recurring software, a product can bill weekly, monthly, or yearly, or a membership tier can include a licensed product's key. Each subscriber gets one key whose `expires_at` is `period_end` plus 3 days of grace (`LICENSE_GRACE = 3 * 86400`) for slow renewals, or exact `period_end` with no grace once they cancel. Past `expires_at`, `validate` returns HTTP 200 with `status: "expired"` and `activate` returns HTTP 403 (`code: "license_expired"`):

```json
HTTP/1.1 200
{"valid":false,"status":"expired","license":{"key":"SUBKY-23456-789AB-CDEFG","activations":0,"max_activations":3,"expires_at":"2026-11-20T10:05:20.000Z"},"product":{"id":1,"name":"Pro license"}}
```

If that member rejoins later, Sendclap revives the same key (unless it was disabled in a dispute) so their installed app keeps working without pasting a new code.

## Sendclap vs Gumroad and Lemon Squeezy license APIs

I checked `gumroad.com/pricing`, `gumroad.com/help/article/76-license-keys`, `docs.lemonsqueezy.com/api/license-api`, and `lemonsqueezy.com/blog/saying-goodbye-to-lemon-squeezy`, and called all three live APIs on November 20, 2026.

| Feature | Sendclap | Gumroad | Lemon Squeezy |
|---|---|---|---|
| Base fee | 1% + Stripe / 1% crypto | 10% + 50¢ (30% Discover) | 5% + 50¢ (ends 2027-03-31) |
| Keep on $29 | $27.57 / $28.71 | $25.60 | $27.05 |
| Tax (MoR) | No | Yes | Yes |
| Device tracking | Your `instance_id` | Flat `uses` count | Server UUID |
| Client deactivate | Yes (no key) | No (needs token) | Yes (no key) |
| Validate unknown | `200` `not_found` | `404` | `404` |
| Email in response | No | Yes | Yes |

Three differences matter when you wire this into real client code.

First, Gumroad's `POST https://api.gumroad.com/v2/licenses/verify` requires `product_id` (for products created on or after January 9, 2023) and defaults `increment_uses_count` to `"true"`. Forget to send `increment_uses_count=false` on startup checks and every app launch burns another use. Gumroad doesn't track devices or enforce seat limits itself, and decrementing uses requires `PUT /v2/licenses/decrement_uses_count` with your creator `access_token`, so a desktop app can't release its own seat without a backend proxy. For subscriptions, Gumroad leaves the key enabled until you disable it and expects your app to check `subscription_ended_at`, `subscription_cancelled_at`, `subscription_failed_at`, `refunded`, and `disputed`. Calling `api.gumroad.com/v2/licenses/verify` with a fake key today returned HTTP 404 (`{"success":false,"message":"That license does not exist for the provided product."}`).

Second, Lemon Squeezy's `activate` accepts `instance_name` and invents a random server-side `instance.id` UUID that your app has to store locally for every future `validate` and `deactivate` call. Lose local state or reinstall the OS and you can't re-activate the same machine idempotently. Its `validate` endpoint returned HTTP 404 (`{"valid":false,"error":"license_key not found."}`) on a fake key today, requires form-encoded requests, and exposes `customer_name` and `customer_email` in the unauthenticated response. More importantly, new sign-ups closed on November 16, 2026 and the platform shuts down on March 31, 2027.

Third, Sendclap keeps customer emails out of the public license endpoints, lets your app supply its own deterministic `instance_id`, and gives `validate` a single `valid` + `status` answer covering activations, refunds, disputes, and subscription expiry. For full fee tables at $5, $10, and $50, see [Sendclap vs Gumroad](https://sendclap.com/compare/gumroad) and [Sendclap vs Lemon Squeezy](https://sendclap.com/compare/lemon-squeezy).

## Official SDKs if you want to skip curl

[sendclap-sdk](https://github.com/backmeupplz/sendclap-sdk) (v0.5.0, MIT) ships `LicenseClient` for JavaScript/TypeScript, Python, Go, Rust, C#/.NET, Swift, and PHP with zero external dependencies in five of the seven languages. Here is a startup check with offline grace in JavaScript:

```js
import { LicenseClient, NetworkError, instanceName } from 'sendclap'

const licenses = new LicenseClient()
try {
  const r = await licenses.validate(key, await instanceName())
  if (!r.valid) lockApp(r.status) // "not_found", "disabled", "expired" or "not_activated"
} catch (e) {
  if (!(e instanceof NetworkError)) throw e // offline: allow a grace period
}
```

Examples for all seven languages are in the [Sendclap API docs](https://sendclap.com/docs#sdks).

## FAQ

**Do I need an API key inside my desktop app?**
No. `/api/v1/licenses/activate`, `/validate`, and `/deactivate` are public and send CORS headers for browser apps too. Your `sc_` creator API key stays on your server for creating checkouts and reading payments.

**Can a buyer move their license to a new laptop?**
Yes. Call `POST /api/v1/licenses/deactivate` with the license key and the old `instance_id` to free the seat, then `/activate` on the new machine.

**Does Sendclap collect VAT or sales tax?**
No. Sendclap isn't a merchant of record. Card payments go straight to your Stripe Connect account and crypto goes straight to your wallet, so you handle your own sales tax and VAT.

*Tested on 2026-11-20 against `backmeupplz/sendclap` commit `8432e113` running locally on Bun 1.3.1 (`SIMULATE=1`), live `https://sendclap.com/api/v1/licenses/*`, `https://api.gumroad.com/v2/licenses/verify`, and `https://api.lemonsqueezy.com/v1/licenses/validate`. Pricing and migration docs read on 2026-11-20; `sendclap-sdk` checked at v0.5.0.*

[Sendclap](https://sendclap.com) gives creators and indie software makers one page for digital products with license keys, memberships, and tips at a flat 1% fee, paid by card or crypto.

