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
- The extension declares a preference of type
passwordinpackage.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. - The extension reads the key with
getPreferenceValues()and sends it to your server on each request, for example in anAuthorizationheader. - 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.
Recommended setup
| 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
- License key validation for Raycast extensions
- Offline license verification for Raycast extensions
- License key validation in Node.js
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.