Clavem

Selling and licensing a Raycast extension

A Raycast Store extension is submitted as a pull request to a public repository and must be MIT-licensed, so the extension itself cannot keep anything secret. Sell the service behind it: the user pastes a key into a password preference, and your server checks the key with Clavem.

The Store is open source

Raycast’s own pages set the frame. The Extensions Guidelines say you submit by “opening a PR in the Raycast Extensions repository”, and the Store technical guidelines say to “ensure you use MIT in the license field”. Community Managers review each pull request. The guidelines cover value, uniqueness, documentation and reasons for rejection; they have no section on charging for an extension.

Put those together: whatever you publish in the Store is readable by everyone, can be copied under the MIT license, and runs on the user’s computer. A license check inside that code protects nothing. A bypass is a one-line change in a fork.

So there are three honest models.

Model What you sell Where the check runs Fit
Free extension, paid service An API, a sync service, a hosted feature Your server Best fit for the Store
Free extension for a paid Mac app The app The app, which is licensed as in macOS apps Good: the extension is a shortcut into the app
Paid extension outside the Store Code The extension Weak: the source is readable and users lose the Store’s discovery

The first is the one this page covers.

How it works

  1. The extension declares a preference of type password in package.json. Raycast’s manifest docs say preferences hold “configuration values and passwords or personal access tokens”, and they appear in Raycast’s settings for the extension.
  2. The extension reads the key with getPreferenceValues() and sends it to your server on each request, for example in an Authorization header.
  3. Your server checks the key with Clavem and decides what the request may do.

The server check must not call Clavem on every request. The License API allows 60 requests a minute per license key, so a busy user would hit the limit. Cache the answer for a few minutes:

const cache = new Map();

export async function isLicensed(licenseKey) {
  const hit = cache.get(licenseKey);
  if (hit && hit.until > Date.now()) return hit.valid;

  const res = await fetch('https://clavem.io/v1/licenses/validate', {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ license_key: licenseKey }),
    signal: AbortSignal.timeout(5000),
  });
  if (res.status === 429 || res.status >= 500) return hit?.valid ?? false;

  const body = await res.json();
  const valid = res.status === 200 && body.valid === true;
  cache.set(licenseKey, { valid, until: Date.now() + 10 * 60_000 });
  return valid;
}

This was run against the public demo key: it answers true for the demo key and false for an unknown key. On a 429 or a 5xx it reuses the last known answer instead of locking the user out. Also check that the key belongs to your product: the response’s meta.product_id identifies it, and a key from another of your products should not work for this one.

If you would rather not call Clavem from the server at all, the signed token does the same job. The extension sends the token from the last activation, and your server verifies the Ed25519 signature offline and checks pid, valid and refresh_by; see offline verification.

What the key does not do here

Do not count on a device limit in the extension. Public code cannot be trusted to report which machine it runs on. Enforce limits on your server: count distinct clients per key if you need to. Alternatively, call activate from your server with an instance_name and a fingerprint that you derive from what the request shows, so Clavem’s device limit applies to what you can observe.

Abuse is a server problem. A leaked key in a public repository or a screenshot lets anyone call your service. Rate limit per key, watch for unusual patterns, and disable a key with the management API when needed. Nothing in the extension can stop it.

Setting Suggested value Why
License type Subscription tied to the service’s running cost The service is what costs you money
Device limit 3, enforced on the server Laptop, desktop and a spare
Trial A free tier on the server, or a time-limited key The extension is free to install, so give it a free mode
Updates Raycast delivers extension updates Nothing to gate: the value is server-side

Doing this with Clavem

Create a product, connect Stripe, map the price. A buyer gets a key and an order page. The README of the extension tells them where to buy and where to paste the key. For how the validate call behaves, and what each status means, see the API reference. The Raycast extension guide shows the client side.

Clavem is not a merchant of record, so tax on subscriptions is yours to handle through Stripe.

Guides to follow

Questions

Can I charge for a Raycast Store extension?

Raycast's guidelines describe review, quality and rejection reasons, and say nothing about taking payment. Because Store extensions are public code under the MIT license, the practical model is a free extension that connects to a paid service you run.

Where does the user enter the license key?

In a preference of type password declared in the extension's package.json. Raycast shows it in the extension's settings, and the extension reads it with the preferences API. Your server decides what the key allows.

Sources

  1. Raycast, prepare an extension for the Store (checked November 2026)
  2. Raycast Extensions Guidelines (checked November 2026)
  3. Raycast, extension manifest and preferences (checked November 2026)