MoneMee MoneMeeAnmelden
Für Lovable, Bolt, Replit, v0, Claude Code & Cursor

Lizenzschlüssel in deine App einbauen — und sie verkaufen, ohne Zahlungs-Backend.

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.

Zum Copy-Paste-Prompt

Keine Monatsgebühr. Ein Request pro Prüfung. Funktioniert im Browser, auf dem Server und auf dem Gerät.

Mit dem Monemee SDK in einem Befehl eingebaut

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 init

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

So funktioniert's — in 4 Schritten

Ein Lizenzschlüssel ist der Kaufnachweis, den deine App selbst prüfen kann. Du brauchst dafür weder Nutzerkonten noch eine Zahlungsintegration.

  1. Produkt anlegen

    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.

  2. Käufer erhält den Schlüssel

    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.

  3. Prüfung in die App einbauen

    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.

  4. Verkaufen

    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.

Die API in 30 Sekunden

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.

Einbau-Anleitung nach Stack

Browser-App, React, Lovable, v0, Bolt

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.

Copy-Paste-Prompt für Lovable, Bolt, Claude Code und Cursor

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

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

Das prüfst du danach — fünf Punkte, zwei Minuten:

  1. Ohne Schlüssel: App im Inkognito-Fenster öffnen. Du musst die Eingabemaske sehen, nicht die App.
  2. Falscher Schlüssel: MM-TEST-0000-0000-0000 eingeben. Es muss „Schlüssel unbekannt“ erscheinen, die App bleibt zu.
  3. Echter Schlüssel: Kauf dein Produkt einmal selbst (du kannst den Testkauf in MoneMee danach erstatten — dann wird der Schlüssel gesperrt, ideal für Test 4). Die App muss aufgehen.
  4. Gesperrter Schlüssel: Nach der Erstattung Seite neu laden (oder „Lizenz entfernen“ und erneut eingeben). Jetzt muss „Schlüssel wurde gesperrt“ erscheinen.
  5. Netzwerktab: In den Browser-DevTools unter „Netzwerk“ den Aufruf an 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.“

Best Practices

  • Prüfe beim Start, nicht bei jedem Klick.

    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.

  • Sei offline-tolerant.

    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.

  • Zeige pro reason eine eigene Meldung.

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

  • Hardcode nie einen Lizenzschlüssel.

    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.

  • Behandle revoked als endgültig.

    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.

  • Nutze Gerätebindung nur, wo sie Sinn ergibt.

    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.

  • Logge den Status, nicht den Schlüssel.

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

  • Mach die Eingabe verzeihend.

    Trim Leerzeichen, wandle in Großbuchstaben um, erlaube Einfügen mit und ohne Bindestriche. Die meisten Support-Tickets zu Lizenzen sind Tippfehler.

  • Verlinke den Kauf direkt.

    Auf der Eingabemaske gehört ein Link auf deine MoneMee-Produktseite. Wer die App ohne Schlüssel öffnet, ist ein warmer Lead.

Sicherheit — ehrlich erklärt

  • Was ein Lizenzschlüssel schützt

    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.

  • Was er nicht schützt

    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.

  • Wann ein Backend-Check sinnvoll ist

    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.

  • Warum kein Secret nötig ist

    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.

  • Was jemand mit einem abgefangenen Schlüssel kann — und was nicht

    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.

  • Brute-Force

    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.

  • Datenschutz

    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.

  • Rechtliches

    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.

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

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.

KriteriumMoneMeeLemon SqueezyPolar.shGumroad
License-API (validate)Ja, ohne Secret, CORS für Browser, immer HTTP 200 mit reason-CodeJa (/v1/licenses/validate), ohne Auth, 60 Req/minJa; Customer-Portal-Endpunkt ohne Auth, braucht organization_id; Server-Endpunkt mit TokenJa (/v2/licenses/verify), ohne Auth
Aktivierung / GerätelimitJa (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ückerstattungAutomatisch (revoked), auch bei Chargeback; manuell + Neu-ausstellen per KlickDashboard; per API nicht deaktivierbarStatus revokedFelder refunded/disputed selbst prüfen
Käuferdaten in der Validate-AntwortKeineKunden-E-Mail im Klartext (meta.customer_email)Kunden-ObjektE-Mail und Name im Klartext
Rechnung nach deutschem RechtAutomatisch für gewerbliche Verkäufer: USt-Ausweis oder Kleinunternehmer-Hinweis (§ 19 UStG); UI, AGB und Support auf Deutsch. Reverse Charge/OSS musst du selbst abwickelnMerchant of Record: Rechnung kommt von Lemon Squeezy (Stripe)Merchant of Record: Rechnung kommt von PolarRechnung 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
AffiliatesEingebaut, Creator-Netzwerk, Provision pro Produkt frei wählbarAffiliate-Programm vorhandenKein natives Affiliate-System (Stand Okt. 2026)Affiliate-Programm vorhanden
Gebühren0 € 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ähr4 % + 0,40 $ pro Transaktion — Stand Okt. 2026, ohne Gewähr10 % 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 AnleitungEntwickler-Doku, EnglischEntwickler-Doku, Englisch, SDKsEinfach, aber increment_uses_count-Falle bei App-Start-Prüfung
MCP-Server für Claude/CursorJa (@monemee/mcp-server)NeinJaNein

Ehrliche Einordnung

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

Häufige Fragen

Was ist ein Lizenzschlüssel und wozu brauche ich ihn für meine App?

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.

Funktioniert das auch, wenn meine App nur im Browser läuft (Lovable, v0, Bolt)?

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.

Wie bekommt der Käufer seinen Lizenzschlüssel?

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.

Brauche ich einen API-Key oder ein Secret in meiner App?

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.

Was passiert bei einer Rückerstattung?

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.

Kann ich die Lizenz auf eine bestimmte Anzahl Geräte begrenzen?

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.

Was ist, wenn mein Nutzer offline ist oder MoneMee nicht erreichbar ist?

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.

Kann ich Abos oder zeitlich begrenzte Lizenzen verkaufen?

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.

Ist das datenschutzkonform? Welche Daten gehen an MoneMee?

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.

Was kostet das?

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.

Bereit, deine App zu verkaufen?

Kostenlos registrieren — Produkt anlegen dauert etwa fünf Minuten.