> ## 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

> Granska prompts och bilder innan din AI-produkt genererar innehåll och få ett tillåt, flagga eller neka-besked med ett poängvärde för 17 innehållskategorier.

<CardGroup cols={2}>
  <Card title="Screen a Prompt" icon="shield-check" href="/api-reference/moderation/screen">
    Skicka text, en bild eller båda och få ett besked.
  </Card>

  <Card title="Get Moderation Usage" icon="chart-column" href="/api-reference/moderation/get-usage">
    Se dina debiterbara granskningar och din nästa debitering.
  </Card>
</CardGroup>

## Översikt

Moderation API granskar användarinmatning innan din AI-produkt genererar innehåll från den. Du skickar promptens text, en bild eller båda, och Dodo Payments returnerar ett besked på `allow`, `flag` eller `deny`, tillsammans med ett poängvärde för varje innehållskategori.

Använd det framför alla modeller för bild-, video- eller textgenerering som tar emot indata från dina användare. Moderation API är aktiverat för alla företag som standard och körs med din befintliga Dodo Payments API-nyckel, så du behöver inte registrera dig separat. Dodo Payments kan inaktivera det för ett enskilt företag, och anrop returnerar då `403` med `MODERATION_DISABLED`.

## Varför vi byggde Moderation API

En produkt för AI-generering skapar nytt innehåll utifrån vad användarna skriver. Du kan inte granska varje prompt manuellt, och ett skadligt resultat kan utsätta ditt företag för risk.

Som din Merchant of Record är Dodo Payments juridiskt och anseendemässigt ansvarigt för det som säljs via plattformen. [Merchant Acceptance Policy](/miscellaneous/merchant-acceptance) granskar verktyg för AI-innehållsgenerering och tillåter inte identitetsmissbruk, deepfakes eller explicit innehåll, inklusive AI-genererat innehåll. Ett konto som genererar skadligt innehåll, orsakar många chargebacks eller får flaggningar från betalningspartners kan bli föremål för granskning eller stängas av.

Vi byggde Moderation API så att du kan stoppa sådant innehåll innan modellen skapar det:

* **Granska innan du genererar.** En blockerad prompt når aldrig modellen, så inget skadligt resultat skapas och du förbrukar ingen beräkningskapacitet på det.
* **Täcker de kategorier som är viktiga för generering.** Granskningen poängsätter 17 kategorier, inklusive likhet med en verklig person, intima bilder utan samtycke, ålderskodade uttryck som antyder att personen är minderårig samt kombinationen av en verklig person och sexuellt innehåll som kännetecknar en sexuell deepfake.
* **Integrera utan en ytterligare leverantör.** API:t körs med din Dodo Payments API-nyckel och avgiften dras från ditt saldo. Det finns inget separat avtal, ingen separat faktura och inget separat konto.
* **Håll användarinnehåll privat.** Dodo Payments lagrar eller loggar inte texten och bilderna du granskar.

<Note>
  Moderation API är ett verktyg för din egen policytillämpning. Det ersätter inte Merchant Acceptance Policy, och du förblir ansvarig för det som din produkt genererar.
</Note>

## Så fungerar det

Anropa Moderation API från din backend efter att användaren skickat en prompt och innan modellen körs:

```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
```

Varje anrop är en **granskning**. Text och en bild som skickas i samma anrop räknas som en granskning.

### Besked

Fältet `decision` innehåller beskedet:

| Besked  | Betydelse                                                                                      | Åtgärd                                                                            |
| ------- | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| `allow` | Innehållet godkändes.                                                                          | Generera.                                                                         |
| `flag`  | Innehållet överskred en kategoritröskel som kräver en bedömning. Det är inte ett mjukt avslag. | Tillämpa din egen policy. Du kan blockera, skicka till granskning eller generera. |
| `deny`  | Innehållet får inte genereras.                                                                 | Blockera begäran och visa användaren ett fel.                                     |

<Warning>
  Generera inte när du inte får något besked. Ett `503` betyder att Dodo Payments inte kunde skapa ett besked, och en timeout eller ett nätverksfel innebär att du saknar ett besked. Behandla alla dessa som en blockering och be användaren försöka igen.
</Warning>

## Granska en prompt

För att granska en prompt skickar du en `POST`-begäran till `/moderation/screen` med minst ett av `text` och `image`. Begäran accepterar tre fält:

| Fält         | Typ    | Beskrivning                                                                                                                                                   |
| ------------ | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `text`       | string | Texten som ska granskas, högst 8 000 tecken.                                                                                                                  |
| `image`      | string | Bilden som ska granskas, som base64, med eller utan prefixet `data:image/...;base64,`.                                                                        |
| `request_id` | string | Valfritt. Din identifierare för denna granskning, till exempel ett genererings-ID, på högst 128 tecken utan kontrolltecken. Svaret returnerar den oförändrad. |

TypeScript- och Python-SDK:erna exponerar endpointen som `client.moderation.screen()`. Detta exempel blockerar generering vid `deny`, vid `flag` och vid alla fel:

<Note>
  Exemplen anropar live mode, eftersom endast live mode kör modereringsmodellen. Test mode returnerar [simulerade besked](#testing-your-integration) och granskar aldrig innehållet. Granskningar i live mode debiteras.
</Note>

<CodeGroup>
  ```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"
    }'
  ```
</CodeGroup>

Exemplet behandlar `flag` som `deny`. Om din produkt tillåter visst flaggat innehåll kan du kontrollera `triggered` för att fatta beslut per kategori i stället.

<Tip>
  Granska texten som användaren skrev, inte promptmallen som du omsluter den med. Din egen mall är densamma vid varje anrop och tillför inget till granskningen.
</Tip>

### Granska bilder

Skicka en bild för att granska en uppladdad referensbild eller en genererad bild innan du visar den. Bilden måste uppfylla följande krav:

* Formatet är JPEG, PNG, WebP, GIF eller BMP.
* Base64-strängen är högst 6 991 530 tecken och den avkodade bilden är högst 5 MiB.
* Bilden är en enda stillbild. Animerade GIF- och WebP-bilder avvisas.
* Den längsta kanten är minst 32 pixlar.

En bild som inte klarar någon av dessa kontroller returnerar `400` med `MODERATION_INVALID_IMAGE`, eller `413` med `MODERATION_INPUT_TOO_LARGE` när den är för stor.

För att granska en bild läser du filen, kodar den som base64 och skickar den i `image`. Om du vill granska en bild och dess prompt tillsammans skickar du både `text` och `image` i samma anrop. Det räknas som en granskning. Detta exempel använder `client` från föregående exempel:

<CodeGroup>
  ```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 @-
  ```
</CodeGroup>

Hantera fel från en bildgranskning på samma sätt som från en textgranskning: om anropet misslyckas ska du inte generera.

## Läsa svaret

Svaret returnerar beskedet och bevisen bakom det:

| Fält                 | Beskrivning                                                                                                                                                     |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `decision`           | Beskedet: `allow`, `flag` eller `deny`.                                                                                                                         |
| `triggered`          | Kategorierna vars poäng överskred kategorins tröskel. Det kan vara tomt vid `flag` från den allmänna kontrollen.                                                |
| `compound_triggered` | `true` när likhet med en verklig person och sexuellt innehåll tillsammans överskred sin kombinerade tröskel, vilket motsvarar mönstret för en sexuell deepfake. |
| `categories`         | Sannolikheten, från 0 till 1, att innehållet hör till varje kategori.                                                                                           |
| `provenance`         | Hur varje poäng mättes: `targeted` genom en kontroll av den kategorin, eller `broad` genom den allmänna kontrollen som omfattar alla kategorier.                |
| `notes`              | Begripliga orsaker till beslutet. Formuleringen kan ändras, så tolka den inte programmatiskt.                                                                   |
| `normalized_applied` | `true` när texten även granskades efter att förvrängning tagits bort, till exempel osynliga tecken eller tecken som liknar andra tecken.                        |
| `passes`             | Antalet ja/nej-frågor som modellen besvarade för denna granskning.                                                                                              |
| `latency_ms`         | Tiden som granskningen tog, i millisekunder.                                                                                                                    |
| `request_id`         | `request_id` som du skickade, eller `null`.                                                                                                                     |

Basera logiken på `decision` och `triggered`. Varje kategori har sin egen tröskel, så en enda poänggräns i koden motsvarar inte beskedet.

### Kategorier

Varje svar poängsätter innehållet mot 17 kategorier:

| Kategori                          | Omfattar                                                                   |
| --------------------------------- | -------------------------------------------------------------------------- |
| `violent_crimes`                  | Våldsbrott.                                                                |
| `sex_related_crimes`              | Sexrelaterade brott.                                                       |
| `child_sexual_exploitation`       | Sexuell exploatering av barn.                                              |
| `suicide_and_self_harm`           | Självmord och självskada.                                                  |
| `indiscriminate_weapons`          | Kemiska, biologiska, radiologiska och nukleära vapen samt explosiva vapen. |
| `intellectual_property`           | Intrång i upphovsrätt eller varumärke.                                     |
| `defamation`                      | Falsk framställning som sannolikt skadar en verklig persons anseende.      |
| `non_violent_crimes`              | Icke-våldsamma brott.                                                      |
| `hate`                            | Förnedring av personer på grund av en skyddad egenskap.                    |
| `privacy`                         | Känslig privat information om en person.                                   |
| `specialized_advice`              | Okvalificerade ekonomiska, medicinska, juridiska eller valrelaterade råd.  |
| `sexual_content`                  | Sexuellt explicit eller pornografiskt innehåll.                            |
| `non_consensual_intimate_imagery` | Avklädning, nakenframställning eller sexualisering av en verklig person.   |
| `minor_coded_language`            | Ålderskodade uttryck som antyder att personen är minderårig.               |
| `real_person_likeness`            | En verklig, identifierbar och namngiven persons utseende.                  |
| `living_artist_style`             | Efterlikning av en specifik nu levande konstnärs signaturstil.             |
| `prompt_injection`                | Ett försök att åsidosätta eller manipulera systemets instruktioner.        |

## Hantera fel

Fel returnerar Dodo Payments standardfelkropp med en `code` och en `message`. Inget fel är ett besked, så inget av dem tillåter generering:

| Status | `code`                       | Orsak                                                                                          | Åtgärd                                                                            |
| ------ | ---------------------------- | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| `400`  | `INVALID_REQUEST_PARAMETERS` | Begäran är felaktigt formaterad eller saknar både `text` och `image`.                          | Korrigera begäran.                                                                |
| `400`  | `MODERATION_INVALID_IMAGE`   | Bilden kan inte avkodas, är animerad eller är för liten.                                       | Skicka en stödd stillbild.                                                        |
| `403`  | `MODERATION_DISABLED`        | Dodo Payments har inaktiverat Moderation API för ditt företag.                                 | Kontakta supporten för att ta reda på varför.                                     |
| `413`  | `MODERATION_INPUT_TOO_LARGE` | `text` innehåller mer än 8 000 tecken eller `image` överskrider storleksgränsen.               | Korta texten eller minska bilden.                                                 |
| `429`  | `MODERATION_OVERLOADED`      | Modereringstjänsten har nått sin kapacitet. Detta är en genomströmningsgräns, inte ett besked. | Vänta det antal sekunder som anges i huvudet `Retry-After` och försök sedan igen. |
| `503`  | `MODERATION_UNAVAILABLE`     | Inget besked är tillgängligt.                                                                  | Generera inte. Försök igen senare.                                                |

SDK:erna försöker som standard igen två gånger vid `429` eller `503` och väntar på `Retry-After` mellan försöken. När försöken är slut utlöser SDK:t ett fel, och din kod måste blockera begäran.

## Testa din integration

Test mode returnerar simulerade besked och anropar aldrig modereringsmodellen, så du kan testa din routning utan kostnad. Skicka begäranden till `https://test.dodopayments.com` med en API-nyckel för test mode.

Det simulerade standardbeskedet är `allow`. Om du vill få ett annat resultat placerar du någon av dessa strängar var som helst i `text`:

| Sträng i `text`        | Svar                                               |
| ---------------------- | -------------------------------------------------- |
| `dodo_mock_flag`       | `200` med `decision` satt till `flag`              |
| `dodo_mock_deny`       | `200` med `decision` satt till `deny`              |
| `dodo_mock_overloaded` | `429` `MODERATION_OVERLOADED` med `Retry-After: 1` |
| `dodo_mock_not_ready`  | `503` `MODERATION_UNAVAILABLE`                     |

Ett simulerat besked innehåller en anteckning som anger att det är simulerat, och alla dess kategoripoäng är `0`. Test mode tillämpar samma validering av begäran som live mode. För bilder kontrolleras base64-kodningen och formatet, men inte antalet bildrutor eller måtten.

Innan du går live ska du bekräfta att din integration hanterar varje fall:

<Steps>
  <Step title="Deny Blocks Generation">
    Skicka `dodo_mock_deny` och bekräfta att din modell inte anropas.
  </Step>

  <Step title="Flag Follows Your Policy">
    Skicka `dodo_mock_flag` och bekräfta att din produkt gör det som din policy anger.
  </Step>

  <Step title="Overload Retries">
    Skicka `dodo_mock_overloaded` och bekräfta att koden väntar på `Retry-After` och inte genererar utan ett besked.
  </Step>

  <Step title="An Outage Blocks Generation">
    Skicka `dodo_mock_not_ready` och bekräfta att din modell inte anropas.
  </Step>

  <Step title="Every Generation Path Screens">
    Kontrollera att varje kodväg som når din modell först anropar Moderation API.
  </Step>
</Steps>

## Prissättning och debitering

Moderation API kostar **0,30 USD per 1 000 debiterbara granskningar**. Det finns ingen kostnadsfri nivå och ingen minimiavgift.

En debiterbar granskning är en granskning i live mode som returnerar ett besked. Följande granskningar är kostnadsfria och räknas inte med:

* Granskningar i test mode.
* Granskningar som returnerar ett fel, inklusive `429` och `503`.

Dodo Payments debiterar i hela block om 1 000 granskningar. Varje helt block debiteras inom en timme, och granskningar som inte fyller ett block förblir obelastade tills de gör det. Avgiften dras från ditt USD-saldo och visas i din [saldojournal](/api-reference/balance-ledger/list-ledger-entries) med händelsetypen `moderation_fees`. Utbetalningar visar den under **Moderation Fees**.

### Spåra användning

Om du vill se din användning anropar du `GET /moderation/usage`. Svaret returnerar:

| Fält                    | Beskrivning                                                                                               |
| ----------------------- | --------------------------------------------------------------------------------------------------------- |
| `unbilled_screens`      | Debiterbara granskningar som Dodo Payments ännu inte har debiterat.                                       |
| `screens_to_next_block` | Debiterbara granskningar som fortfarande krävs för att fylla nästa block om 1 000.                        |
| `daily`                 | Dina debiterbara granskningar per UTC-dag under de senaste 30 dagarna. Dagar utan granskningar utelämnas. |

<CodeGroup>
  ```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)
  ```
</CodeGroup>

Test mode registrerar inga granskningar, så användningsendpointen returnerar ingen aktivitet från test mode.

## Åtkomst och integritet

Granskning kräver en API-nyckel med skrivåtkomst. Alla API-nycklar, inklusive skrivskyddade nycklar, kan läsa användning. Se [Authentication](/api-reference/introduction#authentication) för information om hur du skapar en nyckel och anger dess åtkomstnivå.

Dodo Payments lagrar inte texten eller bilderna du granskar och skriver inte heller dessa till loggar. För varje granskning i live mode sparas tiden, beskedet och ditt `request_id` för debiterings- och användningsrapportering.

<CardGroup cols={2}>
  <Card title="Usage-Based Billing" icon="arrow-trend-up" href="/features/usage-based-billing/introduction">
    Debitera dina egna kunder för varje generering.
  </Card>

  <Card title="Credit-Based Billing" icon="coins" href="/features/credit-based-billing">
    Sälj genereringskrediter och dra av dem vid varje användning.
  </Card>
</CardGroup>
