> ## Documentation Index > Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt > Use this file to discover all available pages before exploring further. # Moderation API > Prüfe Prompts und Bilder, bevor dein AI-Produkt sie generiert, und erhalte ein Urteil – zulassen, markieren oder ablehnen – mit einem Score für 17 Inhaltskategorien. Sende Text, ein Bild oder beides und erhalte ein Urteil. Sieh deine abrechenbaren Prüfungen und deine nächste Belastung ein. ## Überblick Die Moderation API prüft Benutzereingaben, bevor dein AI-Produkt daraus Inhalte generiert. Du sendest den Text eines Prompts, ein Bild oder beides, und Dodo Payments gibt zusammen mit einem Score für jede Inhaltskategorie ein Urteil zurück: `allow`, `flag` oder `deny`. Verwende sie vor jedem Modell zur Bild-, Video- oder Textgenerierung, das Eingaben deiner Benutzer verarbeitet. Die Moderation API ist standardmäßig für jedes Unternehmen aktiviert und läuft mit deinem bestehenden Dodo Payments API-Schlüssel. Du musst dich also nicht separat registrieren. Dodo Payments kann sie für ein einzelnes Unternehmen deaktivieren; Anfragen geben dann `403` mit `MODERATION_DISABLED` zurück. ## Warum wir die Moderation API entwickelt haben Ein AI-Generierungsprodukt erstellt aus den Eingaben seiner Benutzer neue Inhalte. Du kannst nicht jeden Prompt manuell prüfen, und bereits eine schädliche Ausgabe kann dein Unternehmen gefährden. Als dein Merchant of Record trägt Dodo Payments die rechtliche und reputationsbezogene Verantwortung für das, was über die Plattform verkauft wird. Die [Merchant Acceptance Policy](/miscellaneous/merchant-acceptance) prüft Tools zur AI-Inhaltsgenerierung und erlaubt keine Identitätstäuschung, Deepfakes oder expliziten Inhalte, einschließlich AI-generierter Inhalte. Ein Konto, das schädliche Inhalte oder übermäßig viele Rückbuchungen erzeugt oder von Zahlungspartnern gemeldet wird, kann überprüft oder gesperrt werden. Wir haben die Moderation API entwickelt, damit du solche Inhalte stoppen kannst, bevor dein Modell sie erstellt: * **Vor der Generierung prüfen.** Ein blockierter Prompt erreicht dein Modell nie. Dadurch entsteht keine schädliche Ausgabe und du verbrauchst dafür keine Rechenleistung. * **Die für die Generierung relevanten Kategorien abdecken.** Die Prüfung bewertet 17 Kategorien, darunter die Ähnlichkeit mit einer realen Person, nicht einvernehmliche intime Bilder, auf Minderjährige hindeutende Sprache sowie die Kombination einer realen Person mit sexuellen Inhalten, die einen sexuellen Deepfake kennzeichnet. * **Ohne weiteren Anbieter integrieren.** Die API läuft mit deinem Dodo Payments API-Schlüssel und ihre Gebühr wird von deinem Guthaben abgezogen. Es gibt keinen separaten Vertrag, keine separate Rechnung und kein separates Konto. * **Benutzerinhalte privat halten.** Dodo Payments speichert und protokolliert weder den geprüften Text noch die geprüften Bilder. Die Moderation API ist ein Tool für deine eigene Durchsetzung. Sie ersetzt nicht die Merchant Acceptance Policy, und du bleibst für die von deinem Produkt generierten Inhalte verantwortlich. ## Funktionsweise Rufe die Moderation API von deinem Backend aus auf, nachdem der Benutzer einen Prompt gesendet hat und bevor dein Modell ausgeführt wird: ```mermaid theme={null} flowchart LR A[User submits a prompt] --> B[Your backend calls POST /moderation/screen] B -->|allow| C[Generate] B -->|flag| D[Apply your own policy] B -->|deny| E[Block the request] B -->|error, no verdict| E ``` Jeder Aufruf ist eine **Prüfung**. Text und ein Bild, die im selben Aufruf gesendet werden, zählen als eine Prüfung. ### Urteile Das Feld `decision` enthält das Urteil: | Urteil | Bedeutung | Was zu tun ist | | ------- | ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | | `allow` | Der Inhalt wurde akzeptiert. | Generieren. | | `flag` | Der Inhalt hat einen Kategorieschwellenwert überschritten, der eine Beurteilung erfordert. Dies ist keine vorläufige Ablehnung. | Wende deine eigene Richtlinie an. Du kannst blockieren, zur Prüfung weiterleiten oder generieren. | | `deny` | Der Inhalt darf nicht generiert werden. | Blockiere die Anfrage und zeige dem Benutzer einen Fehler. | Generiere nicht, wenn du kein Urteil erhältst. Ein `503` bedeutet, dass Dodo Payments kein Urteil erstellen konnte; auch bei einem Timeout oder Netzwerkfehler liegt kein Urteil vor. Behandle all diese Fälle als Blockierung und fordere den Benutzer auf, es erneut zu versuchen. ## Einen Prompt prüfen Um einen Prompt zu prüfen, sende eine `POST`-Anfrage an `/moderation/screen` mit mindestens einem der Felder `text` und `image`. Die Anfrage akzeptiert drei Felder: | Feld | Typ | Beschreibung | | ------------ | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `text` | string | Der zu prüfende Text mit bis zu 8.000 Zeichen. | | `image` | string | Das zu prüfende Bild als Base64, mit oder ohne Präfix `data:image/...;base64,`. | | `request_id` | string | Optional. Deine Kennung für diese Prüfung, z. B. eine Generierungs-ID, mit bis zu 128 Zeichen und ohne Steuerzeichen. Die Antwort gibt sie unverändert zurück. | Die TypeScript- und Python-SDKs stellen den Endpunkt als `client.moderation.screen()` bereit. Dieses Beispiel blockiert die Generierung bei `deny`, bei `flag` und bei jedem Fehler: Die Beispiele rufen den Live-Modus auf, da nur der Live-Modus das Moderationsmodell ausführt. Der Testmodus gibt [simulierte Urteile](#testing-your-integration) zurück und prüft die Inhalte nie. Prüfungen im Live-Modus werden abgerechnet. ```typescript Node.js expandable theme={null} import DodoPayments from 'dodopayments'; const client = new DodoPayments({ bearerToken: process.env.DODO_PAYMENTS_API_KEY, environment: 'live_mode', }); async function generateImage(prompt: string, generationId: string) { let verdict; try { verdict = await client.moderation.screen({ text: prompt, request_id: generationId, }); } catch (err) { // No verdict: do not generate. throw new Error('Moderation is unavailable. Try again in a moment.'); } if (verdict.decision !== 'allow') { throw new Error('This prompt cannot be generated. Revise it and try again.'); } return myModel.generate(prompt); } ``` ```python Python expandable theme={null} import os from dodopayments import DodoPayments, APIError client = DodoPayments( bearer_token=os.environ["DODO_PAYMENTS_API_KEY"], environment="live_mode", ) def generate_image(prompt: str, generation_id: str): try: verdict = client.moderation.screen(text=prompt, request_id=generation_id) except APIError: # No verdict: do not generate. raise RuntimeError("Moderation is unavailable. Try again in a moment.") if verdict.decision != "allow": raise ValueError("This prompt cannot be generated. Revise it and try again.") return my_model.generate(prompt) ``` ```bash cURL theme={null} curl -X POST https://live.dodopayments.com/moderation/screen \ -H "Authorization: Bearer $DODO_PAYMENTS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "text": "a watercolor painting of a lighthouse at sunset", "request_id": "gen_7Hc2k9" }' ``` Das Beispiel behandelt `flag` wie `deny`. Wenn dein Produkt bestimmte markierte Inhalte zulässt, prüfe stattdessen `triggered`, um die Entscheidung nach Kategorie zu treffen. Prüfe den Text, den dein Benutzer geschrieben hat, nicht die Prompt-Vorlage, die du darum herumlegst. Deine eigene Vorlage ist bei jedem Aufruf gleich und trägt nichts zur Prüfung bei. ### Bilder prüfen Sende ein Bild, um ein hochgeladenes Referenzbild oder ein generiertes Bild zu prüfen, bevor du es anzeigst. Das Bild muss folgende Anforderungen erfüllen: * Das Format ist JPEG, PNG, WebP, GIF oder BMP. * Die Base64-Zeichenfolge hat höchstens 6.991.530 Zeichen und das dekodierte Bild ist höchstens 5 MiB groß. * Das Bild ist ein einzelnes Standbild. Animierte GIF- und WebP-Bilder werden abgelehnt. * Die längste Kante ist mindestens 32 Pixel lang. Ein Bild, das eine dieser Prüfungen nicht besteht, gibt `400` mit `MODERATION_INVALID_IMAGE` zurück oder – wenn es zu groß ist – `413` mit `MODERATION_INPUT_TOO_LARGE`. Um ein Bild zu prüfen, lies die Datei ein, kodiere sie als Base64 und sende sie in `image`. Um ein Bild zusammen mit seinem Prompt zu prüfen, sende `text` und `image` im selben Aufruf. Dies zählt als eine Prüfung. Dieses Beispiel verwendet `client` aus dem vorherigen Beispiel: ```typescript Node.js expandable theme={null} import { readFile } from 'node:fs/promises'; async function screenImage(path: string, prompt: string, generationId: string) { const image = (await readFile(path)).toString('base64'); const verdict = await client.moderation.screen({ image, // or `data:image/png;base64,${image}` text: prompt, // optional: screen the prompt with the image request_id: generationId, }); return verdict.decision === 'allow'; } ``` ```python Python expandable theme={null} import base64 def screen_image(path: str, prompt: str, generation_id: str) -> bool: with open(path, "rb") as f: image = base64.b64encode(f.read()).decode("ascii") verdict = client.moderation.screen( image=image, # or f"data:image/png;base64,{image}" text=prompt, # optional: screen the prompt with the image request_id=generation_id, ) return verdict.decision == "allow" ``` ```bash cURL expandable theme={null} # Builds the JSON body with jq, so a large image does not hit the shell argument limit. base64 < reference.png | tr -d '\n' \ | jq -Rs '{image: ., text: "turn this photo into a watercolor painting", request_id: "gen_7Hc2k9"}' \ | curl -X POST https://live.dodopayments.com/moderation/screen \ -H "Authorization: Bearer $DODO_PAYMENTS_API_KEY" \ -H "Content-Type: application/json" \ --data @- ``` Behandle Fehler bei einer Bildprüfung genauso wie bei einer Textprüfung: Wenn der Aufruf einen Fehler auslöst, darfst du nicht generieren. ## Die Antwort auswerten Die Antwort gibt das Urteil und die zugrunde liegenden Belege zurück: | Feld | Beschreibung | | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `decision` | Das Urteil: `allow`, `flag` oder `deny`. | | `triggered` | Die Kategorien, deren Score den Schwellenwert der Kategorie überschritten hat. Bei einem `flag` aus der allgemeinen Prüfung kann dieses Feld leer sein. | | `compound_triggered` | `true`, wenn die Ähnlichkeit mit einer realen Person und sexuelle Inhalte zusammen ihren kombinierten Schwellenwert überschritten haben – das Muster eines sexuellen Deepfakes. | | `categories` | Die Wahrscheinlichkeit von 0 bis 1, dass der Inhalt in die jeweilige Kategorie fällt. | | `provenance` | Wie jeder Score gemessen wurde: `targeted` durch eine Prüfung dieser einzelnen Kategorie oder `broad` durch die allgemeine Prüfung, die alle Kategorien abdeckt. | | `notes` | Für Menschen lesbare Gründe für die Entscheidung. Die Formulierung kann sich ändern; analysiere sie daher nicht. | | `normalized_applied` | `true`, wenn der Text zusätzlich mit entfernter Verschleierung geprüft wurde, etwa mit unsichtbaren oder ähnlich aussehenden Zeichen. | | `passes` | Die Anzahl der Ja/Nein-Fragen, die das Modell für diese Prüfung beantwortet hat. | | `latency_ms` | Die Dauer der Prüfung in Millisekunden. | | `request_id` | Die von dir gesendete `request_id` oder `null`. | Stütze deine Logik auf `decision` und `triggered`. Jede Kategorie hat ihren eigenen Schwellenwert. Ein einzelner Score-Grenzwert in deinem Code entspricht daher nicht dem Urteil. ### Kategorien Jede Antwort bewertet den Inhalt anhand von 17 Kategorien: | Kategorie | Umfasst | | --------------------------------- | ------------------------------------------------------------------------------------------------------------------ | | `violent_crimes` | Gewaltverbrechen. | | `sex_related_crimes` | Sexualbezogene Straftaten. | | `child_sexual_exploitation` | Sexuelle Ausbeutung von Kindern. | | `suicide_and_self_harm` | Suizid und Selbstverletzung. | | `indiscriminate_weapons` | Chemische, biologische, radiologische oder nukleare Waffen sowie Explosivwaffen. | | `intellectual_property` | Urheberrechts- oder Markenverletzungen. | | `defamation` | Eine falsche Darstellung, die wahrscheinlich den Ruf einer realen Person schädigt. | | `non_violent_crimes` | Gewaltlose Straftaten. | | `hate` | Herabwürdigung von Menschen aufgrund eines geschützten Merkmals. | | `privacy` | Sensible private Informationen über eine Person. | | `specialized_advice` | Nicht qualifizierte Finanz-, Medizin-, Rechts- oder Wahlberatung. | | `sexual_content` | Sexuell explizite oder pornografische Inhalte. | | `non_consensual_intimate_imagery` | Das Entkleiden, Nackt-Darstellen oder Sexualisieren einer realen Person. | | `minor_coded_language` | Auf das Alter hindeutende Sprache, die nahelegt, dass es sich bei der Person um eine minderjährige Person handelt. | | `real_person_likeness` | Die Ähnlichkeit einer realen, identifizierbaren und namentlich genannten Person. | | `living_artist_style` | Nachahmung des charakteristischen Stils eines bestimmten lebenden Künstlers. | | `prompt_injection` | Ein Versuch, die Anweisungen des Systems zu überschreiben oder zu manipulieren. | ## Fehler behandeln Fehler geben den standardmäßigen Dodo Payments-Fehlertext mit `code` und `message` zurück. Kein Fehler ist ein Urteil; daher erlaubt keiner von ihnen die Generierung: | Status | `code` | Ursache | Was zu tun ist | | ------ | ---------------------------- | -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | | `400` | `INVALID_REQUEST_PARAMETERS` | Die Anfrage ist fehlerhaft formatiert oder enthält weder `text` noch `image`. | Korrigiere die Anfrage. | | `400` | `MODERATION_INVALID_IMAGE` | Das Bild kann nicht dekodiert werden, ist animiert oder zu klein. | Sende ein unterstütztes Standbild. | | `403` | `MODERATION_DISABLED` | Dodo Payments hat die Moderation API für dein Unternehmen deaktiviert. | Wende dich an den Support, um den Grund zu erfahren. | | `413` | `MODERATION_INPUT_TOO_LARGE` | `text` enthält mehr als 8.000 Zeichen oder `image` überschreitet die Größenbeschränkung. | Kürze den Text oder verkleinere das Bild. | | `429` | `MODERATION_OVERLOADED` | Die Moderation hat ihre Kapazitätsgrenze erreicht. Dies ist eine Durchsatzbegrenzung, kein Urteil. | Warte die in der Kopfzeile `Retry-After` angegebene Anzahl Sekunden und versuche es erneut. | | `503` | `MODERATION_UNAVAILABLE` | Es ist kein Urteil verfügbar. | Generiere nicht. Versuche es später erneut. | Die SDKs wiederholen einen `429` oder `503` standardmäßig zweimal und warten zwischen den Versuchen `Retry-After`. Wenn keine Wiederholungen mehr verfügbar sind, löst das SDK einen Fehler aus, und dein Code muss die Anfrage blockieren. ## Deine Integration testen Der Testmodus gibt simulierte Urteile zurück und ruft das Moderationsmodell nie auf. So kannst du dein Routing kostenlos testen. Sende Anfragen mit einem API-Schlüssel für den Testmodus an `https://test.dodopayments.com`. Das standardmäßige simulierte Urteil ist `allow`. Um ein anderes Ergebnis zu erhalten, füge eine dieser Zeichenfolgen an beliebiger Stelle in `text` ein: | Zeichenfolge in `text` | Antwort | | ---------------------- | -------------------------------------------------- | | `dodo_mock_flag` | `200` mit `decision` auf `flag` gesetzt | | `dodo_mock_deny` | `200` mit `decision` auf `deny` gesetzt | | `dodo_mock_overloaded` | `429` `MODERATION_OVERLOADED` mit `Retry-After: 1` | | `dodo_mock_not_ready` | `503` `MODERATION_UNAVAILABLE` | Ein simuliertes Urteil enthält einen Hinweis, dass es simuliert ist, und alle Kategoriescores sind `0`. Der Testmodus wendet dieselbe Anfragevalidierung wie der Live-Modus an. Bei Bildern prüft er die Base64-Kodierung und das Format, nicht jedoch die Anzahl der Einzelbilder oder die Abmessungen. Bevor du live gehst, bestätige, dass deine Integration jeden Fall verarbeitet: Sende `dodo_mock_deny` und bestätige, dass dein Modell nicht aufgerufen wird. Sende `dodo_mock_flag` und bestätige, dass dein Produkt das tut, was deine Richtlinie vorgibt. Sende `dodo_mock_overloaded` und bestätige, dass dein Code auf `Retry-After` wartet und ohne Urteil nicht generiert. Sende `dodo_mock_not_ready` und bestätige, dass dein Modell nicht aufgerufen wird. Prüfe, dass jeder Codepfad, der dein Modell erreicht, zuerst die Moderation API aufruft. ## Preise und Abrechnung Die Moderation API kostet **0,30 USD pro 1.000 abrechenbare Prüfungen**. Es gibt kein kostenloses Kontingent und keine Mindestmenge. Eine abrechenbare Prüfung ist eine Prüfung im Live-Modus, die ein Urteil zurückgibt. Diese Prüfungen sind kostenlos und werden nicht gezählt: * Prüfungen im Testmodus. * Prüfungen, die einen Fehler zurückgeben, einschließlich `429` und `503`. Dodo Payments rechnet in vollständigen Blöcken von 1.000 Prüfungen ab. Jeder vollständige Block wird innerhalb einer Stunde berechnet. Prüfungen, die einen Block noch nicht füllen, bleiben unberechnet, bis dies der Fall ist. Die Gebühr wird von deinem USD-Guthaben abgezogen und erscheint mit dem Ereignistyp `moderation_fees` in deinem [Guthabenbuch](/api-reference/balance-ledger/list-ledger-entries). Auszahlungen weisen sie unter **Moderationsgebühren** aus. ### Nutzung verfolgen Um deine Nutzung anzuzeigen, rufe `GET /moderation/usage` auf. Die Antwort gibt Folgendes zurück: | Feld | Beschreibung | | ----------------------- | ------------------------------------------------------------------------------------------------------ | | `unbilled_screens` | Abrechenbare Prüfungen, für die Dodo Payments bisher noch keine Gebühr berechnet hat. | | `screens_to_next_block` | Abrechenbare Prüfungen, die noch benötigt werden, um den nächsten Block von 1.000 zu füllen. | | `daily` | Deine abrechenbaren Prüfungen pro UTC-Tag der letzten 30 Tage. Tage ohne Prüfungen werden ausgelassen. | ```bash cURL theme={null} curl https://live.dodopayments.com/moderation/usage \ -H "Authorization: Bearer $DODO_PAYMENTS_API_KEY" ``` ```typescript Node.js theme={null} const usage = await client.moderation.retrieveUsage(); console.log(usage.unbilled_screens, usage.screens_to_next_block); ``` ```python Python theme={null} usage = client.moderation.retrieve_usage() print(usage.unbilled_screens, usage.screens_to_next_block) ``` Der Testmodus erfasst keine Prüfungen. Daher gibt der Nutzungsendpunkt keine Aktivitäten des Testmodus zurück. ## Zugriff und Datenschutz Für Prüfungen ist ein API-Schlüssel mit Schreibzugriff erforderlich. Jeder API-Schlüssel, einschließlich eines schreibgeschützten Schlüssels, kann die Nutzung auslesen. Unter [Authentication](/api-reference/introduction#authentication) erfährst du, wie du einen Schlüssel erstellst und seine Zugriffsebene festlegst. Dodo Payments speichert weder den von dir geprüften Text noch die geprüften Bilder und schreibt sie auch nicht in Logs. Für jede Prüfung im Live-Modus werden die Zeit, das Urteil und deine `request_id` für Abrechnung und Nutzungsberichte gespeichert. Stelle deinen eigenen Kunden jede Generierung in Rechnung. Verkaufe Generierungsguthaben und ziehe sie pro Nutzung ab.