Dein Tool läuft gehostet — als Web-App unter deiner Domain, als Chrome-Extension, als CLI. Es funktioniert. Nur: Wie nimmst du Geld dafür? Stripe-Webhooks, Nutzerkonten, Rechnungen, Umsatzsteuer — das ist mehr Arbeit als die App selbst.
MoneMee übernimmt den Verkauf: Jeder Käufer bekommt einen Lizenzschlüssel, deine App prüft ihn mit einem einzigen POST-Request. Checkout, Rechnung, Auszahlung und Affiliates laufen bei uns. Du baust, MoneMee verkauft.
Keine Monatsgebühr. Ein Request pro Prüfung. Funktioniert im Browser, auf dem Server und auf dem Gerät.
Für Web-Apps mit Login, Desktop-Software und Python-Tools gibt es ein offenes SDK. Die CLI loggt dich ein, legt das Produkt an, schreibt die .env und bindet die Paywall in deinen Code ein, alles erst im Testmodus.
npx monemee initPakete: monemee-node (Express, Next.js), monemee-react, monemee-client (Electron, Tauri, Erweiterungen, offline signiert) und monemee für Python.
SDK auf GitHub · Dokumentation · Anleitungen (Electron, Chrome-Erweiterung, Next.js, Python, Tauri)
Ein Lizenzschlüssel ist der Kaufnachweis, den deine App selbst prüfen kann. Du brauchst dafür weder Nutzerkonten noch eine Zahlungsintegration.
Du legst dein Tool als Software-Produkt auf MoneMee an, setzt den Preis und schaltest „Lizenzschlüssel pro Kauf“ ein. Optional legst du fest, auf wie vielen Geräten ein Schlüssel gleichzeitig aktiv sein darf und ob er eine Laufzeit hat. Dauer: etwa fünf Minuten.
Nach dem Checkout bekommt der Käufer seinen Lizenzschlüssel sofort auf der Bestätigungsseite und per E-Mail — zusammen mit der Rechnung. Du musst nichts verschicken.
Deine App zeigt ein Eingabefeld für den Schlüssel und schickt ihn mit deiner product_id an POST https://monemee.com/api/v1/licenses/validate. Die Antwort sagt valid: true oder false plus einen Grund. Code-Beispiele für jeden Stack stehen unten, inklusive eines Prompts für Lovable, Bolt, Claude Code und Cursor.
Du teilst deinen Produktlink, MoneMee erledigt Zahlung, Rechnung und Auszahlung auf dein Konto. Rückerstattet? Der Schlüssel wird automatisch gesperrt. Andere Creator können dein Tool gegen Provision bewerben.
Ein Endpunkt reicht für die meisten 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" }Antwort bei gültigem Schlüssel (immer 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" }
}
}Antwort bei ungültigem Schlüssel (ebenfalls HTTP 200):
{ "success": true, "data": { "valid": false, "reason": "revoked", "product_id": 123 } }reason ist einer von sechs Codes: not_found (Schlüssel unbekannt oder Tippfehler), revoked (gesperrt, z. B. nach Rückerstattung), expired (Laufzeit abgelaufen), product_mismatch (Schlüssel gehört zu einem anderen Produkt), device_not_activated (Gerätelimit voll und dieses Gerät ist nicht dabei), activation_limit (nur bei activate: kein Platz mehr). HTTP 400 kommt nur bei kaputtem Request (Format falsch, product_id fehlt), 429 beim Rate-Limit. plan, expires_at und activations.max können null sein.
Kein API-Key, kein Secret: Der Lizenzschlüssel selbst ist der Nachweis. CORS ist für /api/v1/licenses/* offen, der Aufruf funktioniert also direkt aus dem Browser. Die product_id ist die Zahl aus deiner Produkt-URL im Dashboard; sie ist nicht geheim und darf im Frontend stehen. Schlüsselformat: MM-XXXX-XXXX-XXXX-XXXX, Großbuchstaben und Ziffern ohne I, L, O, U — Kleinschreibung wird serverseitig akzeptiert, deine Eingabemaske sollte trotzdem in Großbuchstaben umwandeln. Limits: 60 Anfragen pro Minute und IP, 30 pro Minute und Schlüssel.
Für Geräte-Limits gibt es zwei weitere Endpunkte: POST /api/v1/licenses/activate mit { key, product_id, device_id, device_name? } belegt einen Slot (idempotent: derselbe device_id zählt nur einmal) und antwortet wie validate, bei vollem Limit mit valid: false, reason: "activation_limit". POST /api/v1/licenses/deactivate mit { key, product_id, device_id } gibt den Slot frei und antwortet mit { "deactivated": true, "activations": { "used": 2, "max": 3 } }. Apps ohne Gerätebindung brauchen nur validate. Sendest du bei validate eine device_id, die noch nicht aktiviert ist, kommt valid: true mit device.activated: false — solange Platz ist; deine App ruft dann activate.
Die App speichert den Schlüssel in localStorage, prüft ihn bei jedem Start und läuft bis zu 72 Stunden auf der letzten gültigen Antwort weiter, wenn der Server nicht erreichbar ist. Ohne gültigen Schlüssel sieht der Nutzer nur das Eingabefeld.
// src/license/useLicense.js
import { useEffect, useState } from 'react';
const PRODUCT_ID = 123; // deine product_id (nicht geheim)
const STORAGE_KEY = 'monemee_license';
const GRACE_MS = 72 * 60 * 60 * 1000; // 72h Offline-Toleranz
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' }; // Formatfehler wie Tippfehler behandeln
if (!res.ok) throw new Error(`http_${res.status}`); // 429/5xx → Netzwerkpfad
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 nicht erreichbar: letzte gültige Prüfung innerhalb der Toleranz akzeptieren
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: 'Schlüssel unbekannt. Prüfe auf Tippfehler oder kopiere ihn aus deiner Kauf-E-Mail.',
revoked: 'Dieser Schlüssel wurde gesperrt. Bitte wende dich an den Support.',
expired: 'Diese Lizenz ist abgelaufen. Du kannst sie im Shop verlängern.',
product_mismatch: 'Dieser Schlüssel gehört zu einem anderen Produkt.',
device_not_activated: 'Gerätelimit erreicht. Gib zuerst ein anderes Gerät frei.',
activation_limit: 'Gerätelimit erreicht. Gib zuerst ein anderes Gerät frei.',
};
export default function LicenseGate({ children, buyUrl }) {
const { loading, valid, activate } = useLicense();
const [input, setInput] = useState('');
const [msg, setMsg] = useState('');
if (loading) return <p>Lizenz wird geprüft …</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('Keine Verbindung. Bitte später erneut versuchen.');
}
}
return (
<form onSubmit={onSubmit}>
<h2>Lizenzschlüssel eingeben</h2>
<input
value={input}
onChange={(e) => setInput(e.target.value.toUpperCase())}
placeholder="MM-XXXX-XXXX-XXXX-XXXX"
autoCapitalize="characters"
autoFocus
/>
<button type="submit">Freischalten</button>
{msg && <p role="alert">{msg}</p>}
<p>Noch keinen Schlüssel? <a href={buyUrl}>Jetzt kaufen</a></p>
</form>
);
}Einbinden: <LicenseGate buyUrl="https://monemee.com/@dein-name/dein-tool"><App /></LicenseGate>.
Wichtig für Lovable/Supabase-Projekte: Wenn deine App bereits Nutzerkonten hat, speichere den Schlüssel pro Nutzer in deiner Datenbank statt in localStorage — dann ist er auf jedem Gerät verfügbar. Der Validate-Aufruf bleibt derselbe. Und wenn deine App serverseitige Funktionen hat (Supabase Edge Functions, API-Routen), prüfe dort — siehe Node/Express und den Sicherheitsabschnitt.
Wenn deine App ein Backend hat, prüfe dort. Dann kann niemand die Prüfung im Browser überspringen. Das Backend cacht Ergebnisse 24 Stunden — so bleibt auch eine App mit vielen Nutzern hinter einer Server-IP unter dem Limit von 60 Anfragen pro Minute.
// 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-Toleranz: letzte Antwort nutzen
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);Das Frontend schickt den Schlüssel als Header x-license-key mit. Bei Rückerstattung liefert MoneMee reason: "revoked" — spätestens nach Ablauf des Caches (24 Stunden) ist der Zugang gesperrt.
Dieselbe Idee wie bei Express: serverseitig prüfen, Ergebnis 24 Stunden cachen, bei Netzwerkfehlern die letzte Antwort weiterverwenden.
# 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-Toleranz
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}Für FastAPI funktioniert dieselbe Logik als Depends()-Abhängigkeit.
Die Extension speichert den Schlüssel in chrome.storage.sync (gilt auf allen Geräten des Nutzers) und prüft beim Start des Service Workers sowie per Alarm einmal täglich.
// manifest.json (Auszug)
{
"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-Toleranz
}
}
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>Lizenzschlüssel <input id="key" placeholder="MM-XXXX-XXXX-XXXX-XXXX" style="text-transform:uppercase"></label>
<button>Freischalten</button>
<p id="msg"></p>
</form>
<script src="options.js"></script>// options.js
const TEXT = {
not_found: 'Schlüssel unbekannt.', revoked: 'Schlüssel gesperrt.', expired: 'Lizenz abgelaufen.',
product_mismatch: 'Schlüssel gehört zu einem anderen Produkt.', device_not_activated: 'Gerätelimit erreicht.',
offline: 'Keine Verbindung.',
};
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 ? 'Freigeschaltet.' : (TEXT[d.reason] || TEXT.not_found);
});In Content-Scripts oder Popup vor jeder Premium-Funktion chrome.storage.local.get('licensed') lesen.
Bei installierter Software willst du meist begrenzen, auf wie vielen Rechnern ein Schlüssel läuft. Dafür gibt es activate und deactivate. Die device_id erzeugst du selbst — stabil, aber nicht personenbezogen (erlaubt: bis 128 Zeichen aus A-Z a-z 0-9 . _ : -).
// license.js (Node, auch in Electron-Main nutzbar)
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(), '.meintool', 'license.json');
const GRACE_MS = 7 * 24 * 3600 * 1000; // 7 Tage offline ok
function deviceId() {
// stabil pro Rechner+Nutzer, aber kein Klartext-Hostname auf dem Server
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('Keine Lizenz. Starte: meintool 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); // Platz frei, Gerät noch nicht gebunden
if (!d.valid) throw new Error(`Lizenz ungültig (${d.reason}). Starte: meintool license activate <KEY>`);
save({ ...stored, checkedAt: Date.now() });
return true;
} catch (e) {
if (e.message.startsWith('Lizenz')) throw e;
if (Date.now() - stored.checkedAt > GRACE_MS) throw new Error('Lizenz konnte 7 Tage nicht geprüft werden. Bitte online gehen.');
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: 'Schlüssel unbekannt', revoked: 'Schlüssel gesperrt', expired: 'Lizenz abgelaufen',
product_mismatch: 'Schlüssel gehört zu einem anderen Produkt', activation_limit: 'Gerätelimit erreicht', device_not_activated: 'Gerätelimit erreicht',
};
(async () => {
if (cmd === 'license' && sub === 'activate') {
const d = await activate(arg || '');
console.log(d.valid ? `Aktiviert (${d.activations.used}/${d.activations.max ?? '∞'} Geräte).` : `Fehlgeschlagen: ${REASON[d.reason] || d.reason}`);
return;
}
if (cmd === 'license' && sub === 'deactivate') {
const d = await deactivate();
console.log(`Gerät freigegeben (${d.activations ? `${d.activations.used}/${d.activations.max ?? '∞'}` : 'ok'}).`);
return;
}
await ensureLicensed();
// ... eigentliche CLI-Logik
})().catch((e) => { console.error(e.message); process.exit(1); });Für Tauri rufst du dieselben Endpunkte aus Rust (reqwest) oder über das Frontend mit @tauri-apps/plugin-http auf; die device_id leitest du aus einer Machine-UID ab (z. B. Crate machine-uid), gehasht wie oben. Ein deactivate-Befehl gehört in jede Desktop-App — sonst häufen sich Support-Anfragen „neuer Laptop, Lizenz geht nicht“. Alternativ gibst du als Creator das Gerät in deiner Lizenzliste im Dashboard frei.
Du musst den Code oben nicht verstehen. Kopiere diesen Prompt in deinen KI-Builder und ersetze die zwei Platzhalter. Denselben Prompt findest du mit fertig eingesetzten Werten in deinem Produkt unter „Lizenzschlüssel → Integration“.
Baue in diese App eine Lizenzprüfung über Monemee ein.
Endpoint: POST https://monemee.com/api/v1/licenses/validate
Body (JSON): { "key": "<vom Nutzer eingegebener Schlüssel>", "product_id": 123, "device_id": "<stabile Geräte-/Browser-ID, optional>" }
← 123 durch deine product_id ersetzen (Zahl aus der Produkt-URL im Monemee-Dashboard)
Antwort (immer HTTP 200): { "success": true, "data": { "valid": true|false, "reason": "...", "plan": "...", "expires_at": "...", "activations": { "used": 1, "max": 3 } } }
Kein API-Key nötig. CORS ist erlaubt. Rate-Limit: 60 Anfragen/Minute pro IP.
Kauf-URL für Nutzer ohne Schlüssel: https://monemee.com/@dein-name/dein-tool ← ersetzen
Anforderungen:
1. Beim ersten Start/Login eine Eingabemaske „Lizenzschlüssel“ anzeigen (Format MM-XXXX-XXXX-XXXX-XXXX, Eingabe automatisch in Großbuchstaben), darunter ein Link „Noch keinen Schlüssel? Jetzt kaufen“ auf die Kauf-URL. Die restliche App bleibt verborgen, bis ein gültiger Schlüssel vorliegt.
2. Schlüssel an den Endpoint senden. Bei valid=true den Schlüssel lokal speichern (localStorage bzw. Config-Datei) und die App freischalten.
3. Bei valid=false eine verständliche deutsche Fehlermeldung je reason anzeigen: not_found → „Schlüssel unbekannt“, revoked → „Schlüssel wurde gesperrt“, expired → „Lizenz abgelaufen“, product_mismatch → „Schlüssel gehört zu einem anderen Produkt“, activation_limit/device_not_activated → „Gerätelimit erreicht“.
4. Bei jedem App-Start erneut prüfen; wenn der Server nicht erreichbar ist (Netzwerkfehler, 429 oder 5xx), die letzte gültige Prüfung bis zu 72 Stunden akzeptieren und keine Fehlermeldung „ungültig“ zeigen.
5. Wenn die App ein Backend hat: die Prüfung dort durchführen und den Schlüssel nicht in den Frontend-Code schreiben. Niemals einen Lizenzschlüssel hardcoden, nur die product_id.
6. Wenn Geräte gebunden werden sollen: beim ersten Mal POST https://monemee.com/api/v1/licenses/activate mit device_id und device_name aufrufen, danach nur noch validate; eine Schaltfläche „Gerät freigeben“ ruft POST https://monemee.com/api/v1/licenses/deactivate.
7. In den Einstellungen eine Schaltfläche „Lizenz entfernen“, die den gespeicherten Schlüssel löscht und zur Eingabemaske zurückführt.
Lege die Logik in eine eigene Datei und die Eingabemaske in eine eigene Komponente. Keine neuen Abhängigkeiten, natives fetch verwenden. Nichts anderes an der App ändern.MM-TEST-0000-0000-0000 eingeben. Es muss „Schlüssel unbekannt“ erscheinen, die App bleibt zu.monemee.com/api/v1/licenses/validate suchen. Im Request-Body dürfen nur key, product_id und gegebenenfalls device_id stehen — keine E-Mail, kein Name.Wenn Punkt 1 fehlschlägt, hat der Builder die Gate-Komponente nicht um die ganze App gelegt. Prompt: „Die Lizenz-Komponente muss alle Routen umschließen, nicht nur die Startseite.“
validate hat keine Nebenwirkungen, du kannst es bei jedem App-Start aufrufen. Jede Prüfung bei jeder Aktion belastet dagegen das Rate-Limit (60 pro Minute und IP, 30 pro Schlüssel) und deine Nutzer unnötig. Backends cachen das Ergebnis 24 Stunden — sonst teilen sich alle Nutzer hinter einer Server-IP das IP-Limit.
Wenn monemee.com nicht erreichbar ist (Netzwerkfehler, 429, 5xx), darf deine App nicht sofort zumachen. Faustregel: Web-Apps 72 Stunden, Desktop/CLI 7 Tage auf Basis der letzten gültigen Antwort weiterlaufen lassen. Erst danach blockieren.
not_found heißt „Tippfehler“, revoked heißt „gesperrt, wende dich an den Support“, expired heißt „verlängern“, product_mismatch heißt „falsches Produkt“, device_not_activated/activation_limit heißt „Gerät freigeben“. Netzwerkfehler sind keine ungültige Lizenz — zeige „keine Verbindung“, nicht „ungültig“.
Im Code steht nur die product_id. Sie ist öffentlich und nutzlos ohne Schlüssel. Ein hardcodierter Schlüssel wäre für jeden lesbar, der deine App öffnet.
Lösche den gespeicherten Schlüssel nicht automatisch (der Nutzer könnte ihn für den Support brauchen), aber sperre den Zugang sofort und biete den Kauf-Link an. Rückerstattungen, Chargebacks und manuelle Sperrungen in deinem MoneMee-Dashboard führen zu revoked. Stellst du einen Schlüssel neu aus, wird der alte ebenfalls gesperrt und der Käufer bekommt den neuen per E-Mail.
Für Browser-Apps ist sie meist lästig (jeder Browser wäre ein „Gerät“). Für Desktop, CLI und Extensions mit Profilen ist sie sinnvoll. Setze das Limit großzügig (3–5 Geräte), baue einen deactivate-Weg ein und wisse, dass du Geräte auch selbst in der Lizenzliste freigeben kannst. activate ist idempotent — mehrfach aufrufen mit derselben device_id schadet nicht.
In Logs, Analytics und Fehlerberichten gehören valid und reason, nie der Schlüssel selbst. Wenn du ihn referenzieren musst, nimm die ersten 7 Zeichen (MM-A7K2).
Trim Leerzeichen, wandle in Großbuchstaben um, erlaube Einfügen mit und ohne Bindestriche. Die meisten Support-Tickets zu Lizenzen sind Tippfehler.
Auf der Eingabemaske gehört ein Link auf deine MoneMee-Produktseite. Wer die App ohne Schlüssel öffnet, ist ein warmer Lead.
Er verhindert, dass jemand deine App nutzt, ohne gekauft zu haben, solange die Prüfung nicht umgangen wird. Er gibt dir die Kontrolle, Zugang nach Rückerstattung oder Missbrauch zu entziehen — ein Klick im Dashboard. Und er verbindet jeden Zugang mit einem Kauf, einer Rechnung und einem Käufer.
Code, der im Browser läuft, ist kopierbar. Wer sich auskennt, kann in einer reinen Frontend-App die Prüfung entfernen oder die Antwort fälschen. Ein Lizenzschlüssel ist eine Zahlschranke für ehrliche Nutzer und eine Hürde für Gelegenheits-Teiler, kein Kopierschutz. Das gilt für jede Online-Lizenzprüfung ohne signierte Antworten — auch die von Gumroad, Lemon Squeezy oder Polar.
Sobald deine App etwas Wertvolles auf einem Server tut (KI-Aufrufe, die dich Geld kosten; Datenexporte; Zugriff auf eine Datenbank), prüfe die Lizenz dort, bevor der Server arbeitet. Der Browser kann dann nichts umgehen, was er nicht selbst ausführt. Für rein lokale Tools (Rechner, Formatter, Generatoren im Browser) reicht die Frontend-Prüfung — der Aufwand für ein Backend lohnt sich hier selten.
Der Schlüssel selbst ist der Nachweis. Ein zusätzliches API-Secret im Frontend wäre ebenso lesbar wie alles andere und würde nichts gewinnen. Die Pflichtangabe product_id sorgt dafür, dass ein Schlüssel für Produkt A nicht Produkt B freischaltet (reason: product_mismatch). Deine Verwaltungs-Endpunkte (Lizenzen auflisten, sperren, neu ausstellen, Geräte freigeben) laufen getrennt über die Public API mit deinem persönlichen API-Key — der gehört nie in eine ausgelieferte App.
Er kann die Software so nutzen wie der Käufer, bis zum Gerätelimit. Er kann keine Dateien herunterladen (Download-Links sind separat und E-Mail-verifiziert), keine Käuferdaten lesen, den Schlüssel nicht sperren und keine anderen Produkte prüfen. Du siehst in der Lizenzliste alle Aktivierungen mit Zeitpunkt und kannst sperren und neu ausstellen; der Käufer bekommt den neuen Schlüssel automatisch per Mail.
Schlüssel haben 80 Bit Entropie (16 Zeichen aus einem 32er-Alphabet). Die Endpunkte sind auf 60 Anfragen pro Minute und IP sowie 30 pro Minute und Schlüssel begrenzt, und die Antwort unterscheidet nicht zwischen „nie existiert“ und „gesperrt“ per Statuscode. Durchprobieren ist praktisch aussichtslos. MoneMee speichert Schlüssel nur als Hash plus verschlüsselt; ein Datenbank-Dump liefert keine Klartextschlüssel.
Der Validate-Aufruf enthält nur key, product_id und optional eine von dir erzeugte device_id. Keine E-Mail, kein Name. Die Antwort enthält keinerlei Käuferdaten — nur Lizenzstatus, Plan, Ablaufdatum und Aktivierungszähler. Deine App erfährt also nie, wer gekauft hat, und du musst für die Prüfung keine personenbezogenen Daten verarbeiten. Zum Vergleich: Gumroads Verify-Endpunkt liefert E-Mail und Namen des Käufers im Klartext an jede App, die den Schlüssel kennt. Wenn du eine device_id sendest, erzeuge sie als Hash (siehe CLI/Desktop) — ein Klartext-Hostname wie macbook-von-anna ist bereits personenbezogen; der optionale device_name ist für die Geräteliste des Creators gedacht und sollte vom Nutzer bewusst vergeben werden. Wer gekauft hat, siehst nur du als Creator in deinem Dashboard — maskiert in Listen, vollständig in der Kaufbenachrichtigung.
Mit dem Verkauf über MoneMee erhält der Käufer eine ordentliche Rechnung mit USt-Ausweis oder Kleinunternehmer-Hinweis (bei gewerblichen Verkäufern). Die Lizenzbedingungen (Einzelnutzer, Geräteanzahl, Weitergabeverbot) legst du in der Produktbeschreibung fest; MoneMee stellt dafür eine Vorlage bereit.
Details zu Vertrag und Datenverarbeitung:AGBDatenschutz
Angaben zu Drittanbietern: Stand Okt. 2026, ohne Gewähr. Gebühren und Funktionen der Anbieter ändern sich — bitte vor einer Entscheidung auf den offiziellen Seiten prüfen.
| Kriterium | MoneMee | Lemon Squeezy | Polar.sh | Gumroad |
|---|---|---|---|---|
| License-API (validate) | Ja, ohne Secret, CORS für Browser, immer HTTP 200 mit reason-Code | Ja (/v1/licenses/validate), ohne Auth, 60 Req/min | Ja; Customer-Portal-Endpunkt ohne Auth, braucht organization_id; Server-Endpunkt mit Token | Ja (/v2/licenses/verify), ohne Auth |
| Aktivierung / Gerätelimit | Ja (activate/deactivate, Limit pro Produkt, idempotent) | Ja (Instances, Limit pro Produkt) | Ja (Activations, Limit pro Benefit) | Nur Zähler uses; erhöht sich bei jedem Verify, wenn nicht increment_uses_count=false |
| Sperren bei Rückerstattung | Automatisch (revoked), auch bei Chargeback; manuell + Neu-ausstellen per Klick | Dashboard; per API nicht deaktivierbar | Status revoked | Felder refunded/disputed selbst prüfen |
| Käuferdaten in der Validate-Antwort | Keine | Kunden-E-Mail im Klartext (meta.customer_email) | Kunden-Objekt | E-Mail und Name im Klartext |
| Rechnung nach deutschem Recht | Automatisch für gewerbliche Verkäufer: USt-Ausweis oder Kleinunternehmer-Hinweis (§ 19 UStG); UI, AGB und Support auf Deutsch. Reverse Charge/OSS musst du selbst abwickeln | Merchant of Record: Rechnung kommt von Lemon Squeezy (Stripe) | Merchant of Record: Rechnung kommt von Polar | Rechnung von Gumroad; MoR-Status je nach Quelle unterschiedlich beschrieben |
| Wer ist Vertragspartner des Käufers? | Du (Stripe Connect, Auszahlung direkt aufs Konto) | Lemon Squeezy (führt USt/VAT ab) | Polar (führt USt/VAT ab) | Gumroad |
| Affiliates | Eingebaut, Creator-Netzwerk, Provision pro Produkt frei wählbar | Affiliate-Programm vorhanden | Kein natives Affiliate-System (Stand Okt. 2026) | Affiliate-Programm vorhanden |
| Gebühren | 0 € monatlich, Gebühr nur bei Verkauf (plus Stripe-Gebühr) | 5 % + 0,50 $ pro Transaktion (+ Zusatz für Nicht-US-Zahlungen) — Stand Okt. 2026, ohne Gewähr | 4 % + 0,40 $ pro Transaktion — Stand Okt. 2026, ohne Gewähr | 10 % pro Verkauf — Stand Okt. 2026, ohne Gewähr |
| Eignung für Laien (kein Code-Hintergrund) | Copy-Paste-Prompt für Lovable/Bolt/Cursor im Dashboard, deutsche Anleitung | Entwickler-Doku, Englisch | Entwickler-Doku, Englisch, SDKs | Einfach, aber increment_uses_count-Falle bei App-Start-Prüfung |
| MCP-Server für Claude/Cursor | Ja (@monemee/mcp-server) | Nein | Ja | Nein |
Bei den reinen Transaktionsgebühren können Lemon Squeezy und Polar günstiger sein, besonders am Anfang. Sie sind Merchant of Record und übernehmen damit die Umsatzsteuer weltweit — wer vor allem international verkauft, sollte sich das anschauen. MoneMee ist die richtige Wahl, wenn du in Deutschland/EU verkaufst, Rechnung und AGB auf Deutsch brauchst, Affiliates nutzen willst, Hilfe auf Deutsch erwartest und die Lizenzprüfung ohne Entwickler-Hintergrund einbauen möchtest. Die Verkaufsgebühr sinkt mit deinem Umsatz automatisch. Ausführlicher Vergleich: Gumroad-Alternative
Offizielle Dokumentation der Anbieter: Lemon SqueezyPolar.shGumroad
Ein Lizenzschlüssel ist eine eindeutige Zeichenfolge, die ein Käufer nach dem Kauf erhält und in deiner App eingibt. Deine App prüft ihn per API und schaltet sich frei. So verkaufst du eine gehostete App, Extension oder CLI, ohne Nutzerkonten, Zahlungsintegration oder Rechnungslogik selbst zu bauen.
Ja. Der Validate-Endpunkt erlaubt Browser-Aufrufe (CORS) und braucht kein Secret. Du speicherst den Schlüssel im localStorage oder im Nutzerprofil und prüfst ihn beim Start. Beachte: Reiner Frontend-Code ist kopierbar — für Server-Funktionen, die dich Geld kosten, prüfe zusätzlich im Backend.
Automatisch. Direkt nach dem Checkout steht der Schlüssel auf der Bestätigungsseite und in der Kauf-E-Mail, zusammen mit der Rechnung. Eingeloggte Käufer sehen ihn jederzeit unter „Meine Käufe“. Du musst nichts verschicken und keine Schlüssel vorab erzeugen; MoneMee generiert pro Kauf einen eigenen.
Nein. Der Lizenzschlüssel selbst ist der Nachweis, dazu kommt nur deine öffentliche product_id. Ein Secret im Frontend wäre ohnehin für jeden lesbar. Deinen persönlichen MoneMee-API-Key nutzt du nur serverseitig für Verwaltungsaufgaben, nie in einer ausgelieferten App.
Der Schlüssel wird gesperrt, und die nächste Prüfung liefert valid: false mit reason revoked. Prüft deine App bei jedem Start, greift die Sperre sofort; ein Backend-Cache verzögert sie um höchstens 24 Stunden. Du kannst Schlüssel auch manuell im Dashboard sperren oder neu ausstellen, etwa bei Weitergabe.
Ja. Du legst pro Produkt ein Aktivierungslimit fest (z. B. 3 Geräte). Deine App ruft beim ersten Start activate mit einer selbst erzeugten device_id auf und deactivate, wenn der Nutzer das Gerät wechselt; du kannst Geräte auch selbst in der Lizenzliste freigeben. Für reine Browser-Apps empfehlen wir kein Limit, weil jeder Browser als Gerät zählen würde.
Deine App sollte die letzte erfolgreiche Prüfung zwischenspeichern und für eine Karenzzeit weiterlaufen — 72 Stunden bei Web-Apps, bis zu 7 Tage bei Desktop-Tools. Die Code-Beispiele auf dieser Seite machen genau das. Ein Netzwerkfehler ist keine ungültige Lizenz und sollte auch nicht so gemeldet werden.
Zeitlich begrenzte Lizenzen ja: Du legst pro Produkt eine Laufzeit in Tagen fest, die API liefert expires_at und meldet danach reason expired. Ein nativer Abo-Flow mit automatischer Verlängerung steht auf der Roadmap; aktuell bildest du Laufzeiten über Einmalkäufe mit Ablaufdatum ab.
Der Validate-Aufruf überträgt nur den Schlüssel, die product_id und optional eine gehashte device_id. Keine E-Mail, kein Name. Die Antwort enthält keinerlei Käuferdaten — nur Status, Plan, Ablaufdatum und Aktivierungszähler. Deine App muss für die Prüfung also keine personenbezogenen Daten verarbeiten; Rechnung und Kaufabwicklung laufen über MoneMee nach deutschem Recht.
Keine Monatsgebühr, keine Kosten für API-Aufrufe. Du zahlst nur eine prozentuale Gebühr pro Verkauf, die mit deinem Umsatz automatisch sinkt, jeweils plus Stripe-Transaktionsgebühr. Die aktuellen Stufen findest du in der Hilfe.
Kostenlos registrieren — Produkt anlegen dauert etwa fünf Minuten.
Verwandte Themen: