MoneMee MoneMeeLog in
For Lovable, Bolt, Replit, v0, Claude Code & Cursor

Add license keys to your app — and sell it without building a payment backend.

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.

Set it up in one command with the Monemee SDK

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 init

Packages: 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)

How it works — 4 steps

A license key is proof of purchase your app can verify itself. No user accounts, no payment integration required.

  1. Create the product

    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.

  2. The buyer gets the key

    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.

  3. Add the check to your app

    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.

  4. Sell

    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.

The API in 30 seconds

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.

Integration by stack

Browser app, React, Lovable, v0, Bolt

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.

Copy-paste prompt for Lovable, Bolt, Claude Code and Cursor

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".

Lovable · Bolt · Claude Code · Cursor
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.

What to check afterwards — five points, two minutes:

  1. No key: Open the app in an incognito window. You must see the input form, not the app.
  2. Wrong key: Enter MM-TEST-0000-0000-0000. It must say "Unknown key" and the app must stay locked.
  3. Real key: Buy your own product once (you can refund the test purchase in MoneMee afterwards — that revokes the key, which is exactly what test 4 needs). The app must unlock.
  4. Revoked key: After the refund, reload (or "Remove license" and re-enter). It must now say "Key has been revoked".
  5. Network tab: In browser DevTools → Network, find the call to 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."

Best practices

  • Validate on start, not on every click.

    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.

  • Be offline-tolerant.

    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.

  • Show a distinct message per reason.

    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".

  • Never hardcode a license key.

    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.

  • Treat revoked as final.

    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.

  • Use device binding only where it makes sense.

    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.

  • Log the status, not the key.

    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).

  • Make the input forgiving.

    Trim whitespace, uppercase, accept paste with or without dashes. Most license support tickets are typos.

  • Link to the purchase directly.

    The input form needs a link to your MoneMee product page. Someone opening the app without a key is a warm lead.

Security — explained honestly

  • What a license key protects

    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.

  • What it does not protect

    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.

  • When a backend check makes sense

    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.

  • Why no secret is needed

    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.

  • What someone can do with an intercepted key — and what not

    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.

  • Brute force

    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.

  • Privacy

    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.

  • Legal

    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.

Comparison: MoneMee vs. Lemon Squeezy vs. Polar.sh vs. Gumroad

Third-party details as of Oct 2026, without guarantee. Providers change fees and features — please verify on their official pages before deciding.

CriterionMoneMeeLemon SqueezyPolar.shGumroad
License API (validate)Yes, no secret, CORS for browsers, always HTTP 200 with reason codeYes (/v1/licenses/validate), no auth, 60 req/minYes; customer-portal endpoint without auth, needs organization_id; server endpoint with tokenYes (/v2/licenses/verify), no auth
Activation / device limitYes (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 refundAutomatic (revoked), also on chargeback; manual revoke + reissue in one clickDashboard; cannot be deactivated via APIStatus revokedCheck refunded/disputed fields yourself
Buyer data in the validate responseNoneCustomer email in plaintext (meta.customer_email)Customer objectEmail and name in plaintext
Invoice under German lawAutomatic for business sellers: VAT shown or small-business notice (§ 19 UStG); UI, terms and support in German. Reverse charge/OSS remain your responsibilityMerchant of record: invoice issued by Lemon Squeezy (Stripe)Merchant of record: invoice issued by PolarInvoice 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
AffiliatesBuilt in, creator network, commission per product freely setAffiliate program availableNo 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 guarantee4% + $0.40 per transaction — as of Oct 2026, without guarantee10% per sale — as of Oct 2026, without guarantee
Suitability for non-codersCopy-paste prompt for Lovable/Bolt/Cursor in the dashboard, German guideDeveloper docs, EnglishDeveloper docs, English, SDKsSimple, but the increment_uses_count trap on app-start checks
MCP server for Claude/CursorYes (@monemee/mcp-server)NoYesNo

Honest assessment

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

Frequently asked questions

What is a license key and why does my app need one?

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.

Does this work if my app runs only in the browser (Lovable, v0, Bolt)?

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.

How does the buyer get their license key?

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.

Do I need an API key or secret in my app?

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.

What happens on a refund?

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.

Can I limit a license to a number of devices?

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.

What if my user is offline or MoneMee is unreachable?

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.

Can I sell subscriptions or time-limited licenses?

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.

Is this privacy-compliant? What data goes to MoneMee?

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.

What does it cost?

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.

Ready to sell your app?

Sign up for free — creating a product takes about five minutes.