Your tool is live — a web app on your own domain, a Chrome extension, a CLI. It works. The question is how to charge for it. Stripe webhooks, user accounts, invoices, VAT: that's more work than the app itself.
MoneMee handles the selling. Every buyer receives a license key; your app checks it with a single POST request. Checkout, invoicing, payouts and affiliates run on our side. You build, MoneMee sells.
No monthly fee. One request per check. Works in the browser, on the server and on the device.
There is an open-source SDK for web apps with a login, desktop software and Python tools. The CLI logs you in, creates the product, writes your .env and wires the paywall into your code, starting in test mode.
npx monemee initPackages: monemee-node (Express, Next.js), monemee-react, monemee-client (Electron, Tauri, extensions, signed for offline use) and monemee for Python.
SDK on GitHub · Documentation · Guides (Electron, Chrome extension, Next.js, Python, Tauri)
A license key is proof of purchase your app can verify itself. No user accounts, no payment integration required.
Add your tool as a software product on MoneMee, set a price and enable "License key per purchase". Optionally set how many devices a key may be active on at once and whether it has a term. Takes about five minutes.
Right after checkout the buyer sees their license key on the confirmation page and receives it by email, together with the invoice. Nothing for you to send.
Your app shows an input field for the key and sends it with your product_id to POST https://monemee.com/api/v1/licenses/validate. The response says valid: true or false plus a reason code. Code for every stack is below, including a prompt for Lovable, Bolt, Claude Code and Cursor.
Share your product link. MoneMee handles payment, invoice and payout to your bank account. Refunded? The key is revoked automatically. Other creators can promote your tool for a commission.
One endpoint covers most apps:
POST https://monemee.com/api/v1/licenses/validate
Content-Type: application/json
{ "key": "MM-A7K2-9FQ3-XT8M-2B4C", "product_id": 123, "device_id": "optional" }Response for a valid key (always HTTP 200):
{
"success": true,
"data": {
"valid": true,
"license_id": 987,
"product_id": 123,
"plan": "pro",
"status": "active",
"expires_at": "2027-10-30T12:00:00.000Z",
"activations": { "used": 1, "max": 3 },
"device": { "activated": true, "device_id": "optional" }
}
}Response for an invalid key (also HTTP 200):
{ "success": true, "data": { "valid": false, "reason": "revoked", "product_id": 123 } }reason is one of six codes: not_found (unknown key or typo), revoked (blocked, e.g. after a refund), expired (term ended), product_mismatch (key belongs to another product), device_not_activated (device limit full and this device is not among them), activation_limit (only on activate: no slot left). HTTP 400 is returned only for a malformed request (bad format, missing product_id), 429 when rate-limited. plan, expires_at and activations.max may be null.
No API key, no secret: the license key itself is the proof. CORS is open for /api/v1/licenses/*, so the call works straight from the browser. Your product_id is the number in your product's dashboard URL; it is public and safe to ship in frontend code. Key format: MM-XXXX-XXXX-XXXX-XXXX, uppercase letters and digits without I, L, O, U — lowercase is accepted server-side, but your input should uppercase anyway. Limits: 60 requests per minute per IP, 30 per minute per key.
For device limits there are two more endpoints: POST /api/v1/licenses/activate with { key, product_id, device_id, device_name? } claims a slot (idempotent: the same device_id counts once) and responds like validate, or with valid: false, reason: "activation_limit" when full. POST /api/v1/licenses/deactivate with { key, product_id, device_id } frees the slot and responds with { "deactivated": true, "activations": { "used": 2, "max": 3 } }. Apps without device binding only need validate. If you pass a device_id to validate that is not yet activated, you get valid: true with device.activated: false while a slot is free — your app then calls activate.
The app stores the key in localStorage, validates on every start and keeps running for up to 72 hours on the last valid answer when the server is unreachable. Without a valid key the user only sees the input form.
// src/license/useLicense.js
import { useEffect, useState } from 'react';
const PRODUCT_ID = 123; // your product_id (public)
const STORAGE_KEY = 'monemee_license';
const GRACE_MS = 72 * 60 * 60 * 1000; // 72h offline grace
export function normalizeKey(input) {
return input.trim().toUpperCase();
}
export async function validateKey(key) {
const res = await fetch('https://monemee.com/api/v1/licenses/validate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ key, product_id: PRODUCT_ID }),
});
if (res.status === 400) return { valid: false, reason: 'not_found' }; // malformed = treat as typo
if (!res.ok) throw new Error(`http_${res.status}`); // 429/5xx → offline path
const { data } = await res.json();
return data; // { valid, reason?, plan, status, expires_at, activations, device }
}
export function useLicense() {
const [state, setState] = useState({ loading: true, valid: false, reason: null, offline: false });
useEffect(() => {
const stored = JSON.parse(localStorage.getItem(STORAGE_KEY) || 'null');
if (!stored?.key) return setState({ loading: false, valid: false, reason: null, offline: false });
validateKey(stored.key)
.then((d) => {
if (d.valid) localStorage.setItem(STORAGE_KEY, JSON.stringify({ key: stored.key, checkedAt: Date.now() }));
setState({ loading: false, valid: d.valid, reason: d.reason || null, offline: false });
})
.catch(() => {
// server unreachable: accept the last valid check within the grace period
const withinGrace = Date.now() - (stored.checkedAt || 0) < GRACE_MS;
setState({ loading: false, valid: withinGrace, reason: null, offline: true });
});
}, []);
async function activate(input) {
const key = normalizeKey(input);
const d = await validateKey(key);
if (d.valid) localStorage.setItem(STORAGE_KEY, JSON.stringify({ key, checkedAt: Date.now() }));
setState({ loading: false, valid: d.valid, reason: d.reason || null, offline: false });
return d;
}
function reset() {
localStorage.removeItem(STORAGE_KEY);
setState({ loading: false, valid: false, reason: null, offline: false });
}
return { ...state, activate, reset };
}// src/license/LicenseGate.jsx
import { useState } from 'react';
import { useLicense } from './useLicense';
const MESSAGES = {
not_found: 'Unknown key. Check for typos or paste it from your purchase email.',
revoked: 'This key has been revoked. Please contact support.',
expired: 'This license has expired. You can renew it in the shop.',
product_mismatch: 'This key belongs to a different product.',
device_not_activated: 'Device limit reached. Release another device first.',
activation_limit: 'Device limit reached. Release another device first.',
};
export default function LicenseGate({ children, buyUrl }) {
const { loading, valid, activate } = useLicense();
const [input, setInput] = useState('');
const [msg, setMsg] = useState('');
if (loading) return <p>Checking license …</p>;
if (valid) return children;
async function onSubmit(e) {
e.preventDefault();
try {
const d = await activate(input);
if (!d.valid) setMsg(MESSAGES[d.reason] || MESSAGES.not_found);
} catch {
setMsg('No connection. Please try again later.');
}
}
return (
<form onSubmit={onSubmit}>
<h2>Enter your license key</h2>
<input
value={input}
onChange={(e) => setInput(e.target.value.toUpperCase())}
placeholder="MM-XXXX-XXXX-XXXX-XXXX"
autoCapitalize="characters"
autoFocus
/>
<button type="submit">Unlock</button>
{msg && <p role="alert">{msg}</p>}
<p>No key yet? <a href={buyUrl}>Buy now</a></p>
</form>
);
}Wrap your app: <LicenseGate buyUrl="https://monemee.com/@your-name/your-tool"><App /></LicenseGate>.
If your Lovable/Supabase app already has user accounts, store the key on the user record instead of localStorage so it follows the user across devices. The validate call stays the same. If your app has server-side functions (Supabase Edge Functions, API routes), validate there — see Node/Express and the security section.
If your app has a backend, check there — nobody can skip a check the browser never runs. The backend caches results for 24 hours, which also keeps an app with many users behind one server IP under the 60 requests/minute limit.
// server/licenseMiddleware.js
const PRODUCT_ID = Number(process.env.MONEMEE_PRODUCT_ID);
const cache = new Map(); // key -> { valid, reason, checkedAt }
const TTL_MS = 24 * 60 * 60 * 1000;
async function checkLicense(rawKey) {
const key = rawKey.trim().toUpperCase();
const hit = cache.get(key);
if (hit && Date.now() - hit.checkedAt < TTL_MS) return hit;
const res = await fetch('https://monemee.com/api/v1/licenses/validate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ key, product_id: PRODUCT_ID }),
});
if (res.status === 400) return { valid: false, reason: 'not_found', checkedAt: Date.now() };
if (!res.ok) {
if (hit) return hit; // offline grace: reuse last answer
throw new Error(`monemee_http_${res.status}`);
}
const { data } = await res.json();
const entry = { valid: data.valid, reason: data.reason || null, checkedAt: Date.now() };
cache.set(key, entry);
return entry;
}
function requireLicense(req, res, next) {
const key = req.get('x-license-key') || req.query.license_key;
if (!key) return res.status(401).json({ error: 'license_required' });
checkLicense(key)
.then((lic) => {
if (!lic.valid) return res.status(403).json({ error: 'license_invalid', reason: lic.reason });
req.license = lic;
next();
})
.catch(() => res.status(503).json({ error: 'license_check_unavailable' }));
}
module.exports = { requireLicense };// server/index.js
const { requireLicense } = require('./licenseMiddleware');
app.use('/api/premium', requireLicense);The frontend sends the key as an x-license-key header. After a refund MoneMee returns reason: "revoked" and access is blocked once the cache expires (24 hours at most).
Same idea as with Express: validate server-side, cache the result for 24 hours, reuse the last answer on network errors.
# license.py
import os, time, functools
import requests
from flask import request, jsonify
PRODUCT_ID = int(os.environ["MONEMEE_PRODUCT_ID"])
VALIDATE_URL = "https://monemee.com/api/v1/licenses/validate"
TTL = 24 * 60 * 60
_cache: dict[str, dict] = {}
def check_license(raw_key: str) -> dict:
key = raw_key.strip().upper()
hit = _cache.get(key)
if hit and time.time() - hit["checked_at"] < TTL:
return hit
try:
r = requests.post(VALIDATE_URL, json={"key": key, "product_id": PRODUCT_ID}, timeout=5)
if r.status_code == 400:
return {"valid": False, "reason": "not_found", "checked_at": time.time()}
r.raise_for_status()
data = r.json()["data"]
except requests.RequestException:
if hit:
return hit # offline grace
raise
entry = {"valid": data["valid"], "reason": data.get("reason"), "checked_at": time.time()}
_cache[key] = entry
return entry
def require_license(view):
@functools.wraps(view)
def wrapper(*args, **kwargs):
key = request.headers.get("X-License-Key") or request.args.get("license_key")
if not key:
return jsonify(error="license_required"), 401
try:
lic = check_license(key)
except requests.RequestException:
return jsonify(error="license_check_unavailable"), 503
if not lic["valid"]:
return jsonify(error="license_invalid", reason=lic["reason"]), 403
return view(*args, **kwargs)
return wrapper# app.py
from flask import Flask
from license import require_license
app = Flask(__name__)
@app.get("/api/premium/export")
@require_license
def export():
return {"ok": True}The same logic works as a Depends() dependency in FastAPI.
Store the key in chrome.storage.sync (follows the user across devices), validate when the service worker starts and once a day via an alarm.
// manifest.json (excerpt)
{
"manifest_version": 3,
"permissions": ["storage", "alarms"],
"host_permissions": ["https://monemee.com/*"],
"background": { "service_worker": "background.js" },
"options_page": "options.html"
}// background.js
const PRODUCT_ID = 123;
const GRACE_MS = 72 * 60 * 60 * 1000;
async function validate(key) {
const res = await fetch('https://monemee.com/api/v1/licenses/validate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ key, product_id: PRODUCT_ID }),
});
if (res.status === 400) return { valid: false, reason: 'not_found' };
if (!res.ok) throw new Error(`http_${res.status}`);
return (await res.json()).data;
}
async function recheck() {
const { licenseKey } = await chrome.storage.sync.get('licenseKey');
if (!licenseKey) return chrome.storage.local.set({ licensed: false });
try {
const d = await validate(licenseKey);
await chrome.storage.local.set({ licensed: d.valid, reason: d.reason || null, ...(d.valid && { checkedAt: Date.now() }) });
} catch {
const { checkedAt = 0 } = await chrome.storage.local.get('checkedAt');
await chrome.storage.local.set({ licensed: Date.now() - checkedAt < GRACE_MS }); // offline grace
}
}
chrome.runtime.onInstalled.addListener(() => chrome.alarms.create('license-recheck', { periodInMinutes: 24 * 60 }));
chrome.runtime.onStartup.addListener(recheck);
chrome.alarms.onAlarm.addListener((a) => a.name === 'license-recheck' && recheck());
chrome.runtime.onMessage.addListener((msg, _s, sendResponse) => {
if (msg.type === 'ACTIVATE_LICENSE') {
const key = msg.key.trim().toUpperCase();
validate(key)
.then(async (d) => {
if (d.valid) await chrome.storage.sync.set({ licenseKey: key });
await chrome.storage.local.set({ licensed: d.valid, reason: d.reason || null, ...(d.valid && { checkedAt: Date.now() }) });
sendResponse(d);
})
.catch(() => sendResponse({ valid: false, reason: 'offline' }));
return true; // async
}
});<!-- options.html -->
<form id="f">
<label>License key <input id="key" placeholder="MM-XXXX-XXXX-XXXX-XXXX" style="text-transform:uppercase"></label>
<button>Unlock</button>
<p id="msg"></p>
</form>
<script src="options.js"></script>// options.js
const TEXT = {
not_found: 'Unknown key.', revoked: 'Key revoked.', expired: 'License expired.',
product_mismatch: 'Key belongs to a different product.', device_not_activated: 'Device limit reached.',
offline: 'No connection.',
};
document.getElementById('f').addEventListener('submit', async (e) => {
e.preventDefault();
const key = document.getElementById('key').value;
const d = await chrome.runtime.sendMessage({ type: 'ACTIVATE_LICENSE', key });
document.getElementById('msg').textContent = d.valid ? 'Unlocked.' : (TEXT[d.reason] || TEXT.not_found);
});Read chrome.storage.local.get('licensed') before any premium feature in content scripts or the popup.
For installed software you usually want to cap how many machines a key runs on. That's what activate and deactivate are for. You generate the device_id yourself — stable, but not personal data (allowed: up to 128 chars of A-Z a-z 0-9 . _ : -).
// license.js (Node; works in Electron main as well)
const os = require('os');
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const PRODUCT_ID = 123;
const BASE = 'https://monemee.com/api/v1/licenses';
const CONFIG = path.join(os.homedir(), '.mytool', 'license.json');
const GRACE_MS = 7 * 24 * 3600 * 1000; // 7 days offline ok
function deviceId() {
// stable per machine+user, but no plaintext hostname leaves the device
return crypto.createHash('sha256').update(`${os.hostname()}|${os.userInfo().username}|${os.platform()}`).digest('hex').slice(0, 32);
}
async function call(endpoint, body) {
const res = await fetch(`${BASE}/${endpoint}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(body),
});
if (res.status === 400) return { valid: false, reason: 'not_found' };
if (!res.ok) throw new Error(`http_${res.status}`);
return (await res.json()).data;
}
function load() { try { return JSON.parse(fs.readFileSync(CONFIG, 'utf8')); } catch { return null; } }
function save(data) { fs.mkdirSync(path.dirname(CONFIG), { recursive: true }); fs.writeFileSync(CONFIG, JSON.stringify(data)); }
async function activate(rawKey) {
const key = rawKey.trim().toUpperCase();
const d = await call('activate', { key, product_id: PRODUCT_ID, device_id: deviceId(), device_name: os.hostname() });
if (d.valid) save({ key, checkedAt: Date.now() });
return d;
}
async function deactivate() {
const stored = load();
if (!stored) return { deactivated: true };
const d = await call('deactivate', { key: stored.key, product_id: PRODUCT_ID, device_id: deviceId() });
fs.rmSync(CONFIG, { force: true });
return d; // { deactivated: true, activations: { used, max } }
}
async function ensureLicensed() {
const stored = load();
if (!stored) throw new Error('No license. Run: mytool license activate <KEY>');
try {
let d = await call('validate', { key: stored.key, product_id: PRODUCT_ID, device_id: deviceId() });
if (d.valid && d.device && !d.device.activated) d = await activate(stored.key); // slot free, device not bound yet
if (!d.valid) throw new Error(`License invalid (${d.reason}). Run: mytool license activate <KEY>`);
save({ ...stored, checkedAt: Date.now() });
return true;
} catch (e) {
if (e.message.startsWith('License')) throw e;
if (Date.now() - stored.checkedAt > GRACE_MS) throw new Error('License could not be verified for 7 days. Please go online.');
return true;
}
}
module.exports = { activate, deactivate, ensureLicensed };// cli.js
const { activate, deactivate, ensureLicensed } = require('./license');
const [cmd, sub, arg] = process.argv.slice(2);
const REASON = {
not_found: 'unknown key', revoked: 'key revoked', expired: 'license expired',
product_mismatch: 'key belongs to a different product', activation_limit: 'device limit reached', device_not_activated: 'device limit reached',
};
(async () => {
if (cmd === 'license' && sub === 'activate') {
const d = await activate(arg || '');
console.log(d.valid ? `Activated (${d.activations.used}/${d.activations.max ?? '∞'} devices).` : `Failed: ${REASON[d.reason] || d.reason}`);
return;
}
if (cmd === 'license' && sub === 'deactivate') {
const d = await deactivate();
console.log(`Device released (${d.activations ? `${d.activations.used}/${d.activations.max ?? '∞'}` : 'ok'}).`);
return;
}
await ensureLicensed();
// ... actual CLI logic
})().catch((e) => { console.error(e.message); process.exit(1); });In Tauri, call the same endpoints from Rust (reqwest) or from the frontend via @tauri-apps/plugin-http; derive device_id from a machine UID (e.g. the machine-uid crate), hashed as above. Every desktop app needs a deactivate command — otherwise "new laptop, license doesn't work" becomes your most frequent support ticket. As the creator you can also release a device from the license list in your dashboard.
You don't need to understand the code above. Paste this prompt into your AI builder and replace the two placeholders. The same prompt, with your values filled in, is in your product under "License keys → Integration".
Add a license check via Monemee to this app.
Endpoint: POST https://monemee.com/api/v1/licenses/validate
Body (JSON): { "key": "<key entered by the user>", "product_id": 123, "device_id": "<stable device/browser id, optional>" }
← replace 123 with your product_id (the number in the product URL in your Monemee dashboard)
Response (always HTTP 200): { "success": true, "data": { "valid": true|false, "reason": "...", "plan": "...", "expires_at": "...", "activations": { "used": 1, "max": 3 } } }
No API key needed. CORS is enabled. Rate limit: 60 requests/minute per IP.
Purchase URL for users without a key: https://monemee.com/@your-name/your-tool ← replace
Requirements:
1. On first start/login show an input form "License key" (format MM-XXXX-XXXX-XXXX-XXXX, input automatically uppercased), with a link "No key yet? Buy now" to the purchase URL below it. The rest of the app stays hidden until a valid key exists.
2. Send the key to the endpoint. If valid=true, store the key locally (localStorage or config file) and unlock the app.
3. If valid=false, show a clear message per reason: not_found → "Unknown key", revoked → "Key has been revoked", expired → "License expired", product_mismatch → "Key belongs to a different product", activation_limit/device_not_activated → "Device limit reached".
4. Re-validate on every app start; if the server is unreachable (network error, 429 or 5xx), accept the last successful validation for up to 72 hours and do not show an "invalid" message.
5. If the app has a backend: perform the check there and do not put the key into frontend code. Never hardcode a license key, only the product_id.
6. If devices should be bound: on first use call POST https://monemee.com/api/v1/licenses/activate with device_id and device_name, afterwards only validate; a button "Release device" calls POST https://monemee.com/api/v1/licenses/deactivate.
7. Add a "Remove license" button in settings that deletes the stored key and returns to the input form.
Put the logic in its own file and the input form in its own component. No new dependencies; use native fetch. Change nothing else in the app.MM-TEST-0000-0000-0000. It must say "Unknown key" and the app must stay locked.monemee.com/api/v1/licenses/validate. The request body must contain only key, product_id and, if used, device_id — no email, no name.If point 1 fails, the builder did not wrap the whole app in the gate. Prompt: "The license component must wrap all routes, not just the home page."
validate has no side effects, so calling it on every app start is fine. Checking on every action, however, eats into the rate limit (60/minute per IP, 30 per key) and burdens your users for nothing. Backends cache the result for 24 hours — otherwise all users behind one server IP share the IP limit.
If monemee.com is unreachable (network error, 429, 5xx), your app must not lock immediately. Rule of thumb: web apps keep running 72 hours, desktop/CLI 7 days on the last valid answer. Only then block.
not_found means "typo", revoked means "blocked, contact support", expired means "renew", product_mismatch means "wrong product", device_not_activated/activation_limit means "release a device". A network error is not an invalid license — say "no connection", not "invalid".
Only the product_id lives in your code. It is public and useless without a key. A hardcoded key would be readable by anyone who opens your app.
Don't delete the stored key automatically (the user may need it for support), but block access immediately and offer the purchase link. Refunds, chargebacks and manual revocations in your MoneMee dashboard all result in revoked. Reissuing a key revokes the old one and emails the buyer the new one.
For browser apps it mostly annoys (every browser would count as a device). For desktop, CLI and extensions with profiles it is useful. Set the limit generously (3–5 devices), ship a deactivate path, and remember you can release devices yourself from the license list. activate is idempotent — calling it repeatedly with the same device_id is harmless.
Logs, analytics and error reports get valid and reason, never the key itself. If you must reference it, use the first 7 characters (MM-A7K2).
Trim whitespace, uppercase, accept paste with or without dashes. Most license support tickets are typos.
The input form needs a link to your MoneMee product page. Someone opening the app without a key is a warm lead.
It prevents someone from using your app without buying it, as long as the check is not bypassed. It gives you control to revoke access after a refund or abuse — one click in the dashboard. And it ties every access to a purchase, an invoice and a buyer.
Code that runs in the browser can be copied. Someone who knows what they are doing can remove the check from a pure frontend app or fake the response. A license key is a paywall for honest users and a hurdle for casual sharers, not copy protection. That is true for every online license check without signed responses — including Gumroad, Lemon Squeezy or Polar.
As soon as your app does something valuable on a server (AI calls that cost you money; data exports; database access), validate the license there before the server does the work. The browser then cannot bypass anything it does not execute itself. For purely local tools (calculators, formatters, in-browser generators) the frontend check is enough — a backend rarely pays off here.
The key itself is the proof. An additional API secret in the frontend would be just as readable as everything else and would gain nothing. The mandatory product_id ensures that a key for product A does not unlock product B (reason: product_mismatch). Your management endpoints (list, revoke, reissue licenses, release devices) run separately via the Public API with your personal API key — which never ships inside an app.
They can use the software like the buyer, up to the device limit. They cannot download files (download links are separate and email-verified), cannot read buyer data, cannot revoke the key and cannot validate other products. You see all activations with timestamps in the license list and can revoke and reissue; the buyer automatically receives the new key by email.
Keys have 80 bits of entropy (16 characters from a 32-character alphabet). The endpoints are limited to 60 requests per minute per IP and 30 per minute per key, and the response does not distinguish between "never existed" and "revoked" by status code. Guessing is practically hopeless. MoneMee stores keys only as a hash plus encrypted; a database dump yields no plaintext keys.
The validate call contains only key, product_id and optionally a device_id you generate. No email, no name. The response contains no buyer data at all — only license status, plan, expiry date and activation counts. Your app never learns who bought, and you process no personal data for the check. By comparison, Gumroad's verify endpoint returns the buyer's email and name in plaintext to any app that knows the key. If you send a device_id, generate it as a hash (see CLI/desktop) — a plaintext hostname like annas-macbook is already personal data; the optional device_name is meant for the creator's device list and should be chosen deliberately by the user. Only you as the creator see who bought, in your dashboard — masked in lists, in full in the purchase notification.
Selling through MoneMee gives the buyer a proper invoice with VAT shown or a small-business notice (for business sellers). You define the license terms (single user, number of devices, no redistribution) in the product description; MoneMee provides a template.
Third-party details as of Oct 2026, without guarantee. Providers change fees and features — please verify on their official pages before deciding.
| Criterion | MoneMee | Lemon Squeezy | Polar.sh | Gumroad |
|---|---|---|---|---|
| License API (validate) | Yes, no secret, CORS for browsers, always HTTP 200 with reason code | Yes (/v1/licenses/validate), no auth, 60 req/min | Yes; customer-portal endpoint without auth, needs organization_id; server endpoint with token | Yes (/v2/licenses/verify), no auth |
| Activation / device limit | Yes (activate/deactivate, limit per product, idempotent) | Yes (instances, limit per product) | Yes (activations, limit per benefit) | Only a uses counter; increments on every verify unless increment_uses_count=false |
| Revocation on refund | Automatic (revoked), also on chargeback; manual revoke + reissue in one click | Dashboard; cannot be deactivated via API | Status revoked | Check refunded/disputed fields yourself |
| Buyer data in the validate response | None | Customer email in plaintext (meta.customer_email) | Customer object | Email and name in plaintext |
| Invoice under German law | Automatic for business sellers: VAT shown or small-business notice (§ 19 UStG); UI, terms and support in German. Reverse charge/OSS remain your responsibility | Merchant of record: invoice issued by Lemon Squeezy (Stripe) | Merchant of record: invoice issued by Polar | Invoice from Gumroad; MoR status described differently across sources |
| Who is the buyer's contracting party? | You (Stripe Connect, payout straight to your account) | Lemon Squeezy (remits VAT) | Polar (remits VAT) | Gumroad |
| Affiliates | Built in, creator network, commission per product freely set | Affiliate program available | No native affiliate system (as of Oct 2026) | Affiliate program available |
| Fees | €0 monthly, fee only on a sale (plus Stripe fee) | 5% + $0.50 per transaction (+ surcharge for non-US payments) — as of Oct 2026, without guarantee | 4% + $0.40 per transaction — as of Oct 2026, without guarantee | 10% per sale — as of Oct 2026, without guarantee |
| Suitability for non-coders | Copy-paste prompt for Lovable/Bolt/Cursor in the dashboard, German guide | Developer docs, English | Developer docs, English, SDKs | Simple, but the increment_uses_count trap on app-start checks |
| MCP server for Claude/Cursor | Yes (@monemee/mcp-server) | No | Yes | No |
On pure transaction fees, Lemon Squeezy and Polar can be cheaper, especially at the start. They are merchants of record and handle VAT worldwide — if you mainly sell internationally, look at them. MoneMee is the right choice if you sell in Germany/EU, need invoices and terms in German, want to use affiliates, expect support in German and want to add the license check without a developer background. The sales fee decreases automatically as your revenue grows. Detailed comparison: Gumroad alternative
Official provider documentation: Lemon SqueezyPolar.shGumroad
A license key is a unique string a buyer receives after purchase and enters into your app. Your app validates it via API and unlocks. That lets you sell a hosted app, extension or CLI without building user accounts, a payment integration or invoicing logic yourself.
Yes. The validate endpoint allows browser calls (CORS) and needs no secret. Store the key in localStorage or on the user profile and validate on start. Keep in mind that pure frontend code can be copied — for server-side features that cost you money, validate on the backend as well.
Automatically. Right after checkout the key appears on the confirmation page and in the purchase email, together with the invoice. Logged-in buyers can see it any time under "My purchases". You don't send anything and don't pre-generate keys; MoneMee creates a unique key per purchase.
No. The license key itself is the proof, plus your public product_id. A secret in the frontend would be readable by anyone anyway. Your personal MoneMee API key is for server-side management tasks only and never ships inside an app.
The key is revoked and the next validation returns valid: false with reason revoked. If your app validates on every start, the block is immediate; a backend cache delays it by at most 24 hours. You can also revoke or reissue keys manually in the dashboard, for example when a key is being shared.
Yes. Set an activation limit per product (e.g. 3 devices). Your app calls activate with a self-generated device_id on first run and deactivate when the user switches machines; you can also release devices yourself from the license list. For pure browser apps we recommend no limit, since every browser would count as a device.
Your app should cache the last successful validation and keep running for a grace period — 72 hours for web apps, up to 7 days for desktop tools. The code samples on this page do exactly that. A network error is not an invalid license and should not be reported as one.
Time-limited licenses, yes: set a term in days per product, the API returns expires_at and reports reason expired afterwards. A native subscription flow with automatic renewal is on the roadmap; today you model terms as one-time purchases with an expiry date.
The validate call transmits only the key, the product_id and optionally a hashed device_id. No email, no name. The response contains no buyer data at all — only status, plan, expiry date and activation counts. Your app therefore processes no personal data for the check; invoicing and checkout run through MoneMee under German law.
No monthly fee, no charge per API call. You only pay a percentage per sale that decreases automatically as your revenue grows, plus the Stripe transaction fee. The current tiers are listed in the help center.
Sign up for free — creating a product takes about five minutes.
Related topics: