> ## Documentation Index
> Fetch the complete documentation index at: https://docs.didit.me/llms.txt
> Use this file to discover all available pages before exploring further.

# Monitoring-Token erstellen | Didit Authentication API

> Didit: POST /monitoring-token/ tauscht ein Access-Token gegen eine 15-Minuten-Geräte-Credential, gebunden an vendor_data und Browser-Origin.

> [!WARNING]
>
> Authentifizierung ist neu, und dieser Endpoint bleibt deaktiviert, bis Didit ihn aktiviert: Bis dahin antwortet er mit `503 monitoring_unavailable`.

Die Browser-SDKs und nativen SDKs rufen diesen Endpoint vom Gerät der Person aus auf; Ihr Server muss dies nicht tun. Jedes Ereignis, das mit den Zugangsdaten gesendet wird, wird im `vendor_data`-Feld der Person aufgezeichnet, unabhängig davon, was das Gerät angibt.


## OpenAPI

````yaml de/openapi-authentication.json POST /monitoring-token/
openapi: 3.0.3
info:
  title: Didit Authentication API
  version: 1.0.0
  description: >-
    Die serverseitigen Endpoints von Didit Authentication, dem Anmeldeprodukt
    für die Endbenutzer Ihrer Anwendung. Authentication ist **neu** und geht mit
    dem Release 2026-11-01 in Produktion.


    ## Basis-URL


    Jede Anwendung ist ihr eigener OpenID Connect Issuer, und jeder unten
    aufgeführte Endpoint wird unter dem Stamm dieses Issuers bereitgestellt:


    - `https://<name>.auth.didit.me` für eine Live-Anwendung oder
    `https://<name>.sandbox.auth.didit.me` für eine Sandbox-Anwendung.

    - Ihre eigene benutzerdefinierte Domain, sobald sie aktiv ist. Sie ersetzt
    dann den Standard-Host als Issuer: Neue Token geben sie in `iss` an,
    Discovery verweist auf sie und der veröffentlichbare Schlüssel ändert sich.
    Zugriffstoken, die unter dem Standard-Host ausgestellt wurden, schlagen bei
    `/session/`, `/step-up/` und `/monitoring-token/` fehl, bis sie aktualisiert
    werden.


    Live und Sandbox sind separate Anwendungen, also separate Issuer mit
    separaten Schlüsseln. Der veröffentlichbare Schlüssel lautet `pk_live_`
    (Live) oder `pk_test_` (Sandbox), gefolgt von der Base64url-Codierung ohne
    Padding des Issuers ohne abschließenden Schrägstrich: Decodieren Sie ihn, um
    den Issuer zu ermitteln. Es handelt sich um eine öffentliche Kennung, nicht
    um Anmeldedaten.


    Dieselben JSON-Endpoints werden auch unter
    `https://apx.didit.me/auth/v2/authentication/{application_id}/`
    bereitgestellt. Token geben immer den obigen Issuer an, unabhängig davon,
    welche Adresse sie ausgestellt hat.


    ## Anmeldedaten


    Diese Endpoints akzeptieren niemals Ihren Didit-API-Schlüssel oder ein
    Konsolen-Token.


    - Discovery, das JWKS und `POST /token/` erfordern keine Anmeldedaten.
    Clients sind öffentlich: Es gibt kein Client-Secret, und ein
    Autorisierungscode ist an seinen PKCE-Verifier (`S256`) gebunden.
    `client_id` ist Ihre Anwendungs-ID.

    - `/session/`, `/step-up/` und `/monitoring-token/` erfordern das
    Zugriffstoken der Person: `Authorization: Bearer <access_token>`. Jeder
    erfolgreiche Aufruf zählt als Aktivität in der Sitzung und setzt daher den
    Inaktivitäts-Timeout der Sitzung zurück.


    ## Request-Bodys


    Jeder Endpoint, der einen Body akzeptiert, unterstützt JSON-, form-codierte
    und multipart-Bodys. Dieses Dokument führt JSON sowie form-codierte Anfragen
    für `POST /token/` auf, wie es von OAuth-Clients gesendet wird. Ein Feld,
    das der Endpoint nicht akzeptiert, führt zu `400 {"<field>":
    "unknown_field"}`.


    ## Token


    - **Access-Token**: ein ES256-JWT mit dem Header `typ: at+jwt`, maximal 5
    Minuten gültig und niemals länger als seine Sitzung. Claims:
    `AccessTokenClaims`.

    - **ID-Token**: ein ES256-JWT mit dem Header `typ: JWT`. Claims:
    `IDTokenClaims`. Es wird niemals als Zugriffstoken akzeptiert.

    - **Refresh-Token**: eine zufällige Zeichenfolge, die bei jeder Verwendung
    rotiert. Das erneute Senden eines bereits verwendeten Refresh-Tokens
    widerruft die Sitzung.


    Verifizieren Sie ein Token mit den Schlüsseln aus `GET
    /.well-known/jwks.json`: Der Algorithmus muss `ES256` sein, `typ` muss mit
    dem Token-Typ übereinstimmen, `iss` muss dem von Ihnen konfigurierten Issuer
    entsprechen und `aud` Ihrer Anwendungs-ID. Eine Offline-Verifizierung
    erkennt eine widerrufene Sitzung erst nach Ablauf ihres Zugriffstokens; `GET
    /session/` ist die sofortige Prüfung.


    ## Fehler


    | Body | Wann |

    | --- | --- |

    | `{"error": "<code>"}` | Fehler von `POST /token/`, alle mit Status `400`,
    im Body-Format von [RFC 6749 Abschnitt
    5.2](https://www.rfc-editor.org/rfc/rfc6749#section-5.2): `invalid_grant`,
    `invalid_client` und Didits `mfa_required`. Dienstfehler:
    `temporarily_unavailable`, `monitoring_unavailable`, `monitoring_disabled`.
    |

    | `{"<field>": ["<message>"]}` oder `{"<field>": "<code>"}` | Ein
    Anfragefeld hat die Validierung nicht bestanden. `non_field_errors` benennt
    eine feldübergreifende Regel und `unknown_field` ein Feld, das der Endpoint
    nicht akzeptiert. |

    | `{"detail": "<message>"}` | `401` (`invalid_token`), `403`
    (`origin_not_allowed`), `404` (unbekannte Anwendung oder Step-Up) und `429`
    (Rate-Limit). Außerdem `400` für einen Body, der nicht geparst werden kann
    (`JSON parse error - ...`), `405` für eine Methode, die der Endpoint nicht
    bedient, und `415` für einen nicht unterstützten `Content-Type`. |


    Ein `401` enthält außerdem `WWW-Authenticate: Bearer`, und ein `429` enthält
    `Retry-After` in Sekunden.


    Zwei Ablehnungen erfolgen nicht als JSON. Eine Adresse, die kein Issuer ist,
    wird abgelehnt, bevor sie diese Endpoints erreicht, beispielsweise mit einer
    leeren `404`-Antwort für einen ungenutzten `*.auth.didit.me`-Namen. Eine
    `step_up_id`, die keine UUID ist, erhält eine `404`-Seite.


    ## Rate-Limits


    Eine Anfrage muss zwei Ebenen durchlaufen.


    **Endpoint-Limits**, gezählt pro Client-IP-Adresse, pro Anwendung und pro
    Endpoint:


    - Discovery und das JWKS: 1.200 Anfragen pro Minute und 12.000 pro Stunde.

    - Jeder andere Endpoint: 30 Anfragen pro Minute und 300 pro Stunde. `GET`
    und `DELETE /session/` teilen sich eine Zählung.


    Bei Überschreitung eines Limits: `429 {"detail": "Too many requests from
    this IP address. Please wait before trying again. Expected available in 60
    seconds."}`, oder `3600 seconds` für das stündliche Limit.


    **Bot-Schutz**, bei jedem `POST` und `DELETE`. Seine Buckets werden von
    allen `POST`- und `DELETE`-Anfragen der Anwendung geteilt, einschließlich
    der gehosteten Anmeldeschritte, und füllen sich kontinuierlich wieder auf:


    - 60 Anfragen pro Minute pro Client-IP-Adresse.

    - 30 Anfragen pro Minute pro Gerät für Anfragen, die ihr Gerät
    identifizieren, wie dies bei Browsern und nativen SDKs der Fall ist.

    - 3.000 Anfragen pro Minute für die gesamte Anwendung über alle IP-Adressen
    hinweg. Token-Aktualisierungen (`POST /token/` mit
    `grant_type=refresh_token`) greifen stattdessen auf einen eigenen Bucket zu:
    6.000 pro Minute für die gesamte Anwendung.


    Bei Überschreitung eines Buckets: `429 {"detail": "rate_limited Expected
    available in N seconds."}` (`1 second.` wenn N gleich 1 ist). Der Bucket pro
    IP erstreckt sich über alle Endpoints, sodass eine einzelne Adresse, die
    Token-, Step-Up- und Abmeldeaufrufe mischt, ihn leeren kann, bevor sie ein
    Endpoint-Limit erreicht. Der Anwendungs-Bucket zählt jeden Client der
    Anwendung, einschließlich Browsern.


    Beide Ebenen antworten, bevor der Endpoint ausgeführt wird. Eine Anfrage,
    die `429` erhalten hat, wurde also nicht ausgeführt: Wiederholen Sie sie
    nach `Retry-After`, einschließlich einer Token-Aktualisierung.


    ## Browser-Anfragen


    Eine Anfrage, die einen `Origin`-Header enthält, muss von einem der
    anwendungseigenen Origins oder ihren erlaubten Origins stammen, andernfalls
    erhält sie `403 origin_not_allowed`. Server-zu-Server-Anfragen senden keinen
    `Origin`-Header.


    ## Hier nicht behandelt


    Diese Routen bedienen die gehosteten Seiten, die Browser- und nativen SDKs
    sowie KI-Agenten. Sie sind nicht Teil des Serververtrags und werden von
    Server-SDKs nicht aufgerufen:


    - Anmeldeschritte: `POST /authorize/`, `POST /password/`, `/email/*`,
    `/phone/*`, `/password-reset/*`, `/passkeys/*`, `/mfa/*`, `/social/*` und
    `/protection/complete/`.

    - Gehostete Seiten und Callbacks: `/sign-in`, `/magic`, `/invite`, `/reset`,
    `/verify/`, `/sso/*`, `/wallet/callback/`, `/logo/` und die nativen
    App-Zuordnungsdateien unter `/.well-known/`.

    - Agentenzugriff: `/agents/*` und `/grants/`, einschließlich `GET
    /agents/session/`, der Live-Prüfung für das Zugriffstoken eines KI-Agenten.
    Agentenzugriff ist nicht Teil dieser Version des Vertrags.

    - Die Konsolen-Verwaltungs-API für Authentication, die Konsolensitzungen
    verwendet.


    Authentication-Ereignisse werden derzeit noch nicht als Webhooks zugestellt,
    daher definiert dieses Dokument keinen Webhook.
servers:
  - url: https://{issuer}
    description: 'Der Aussteller Ihrer Anwendung: ihr Anmeldeursprung.'
    variables:
      issuer:
        default: your-app.auth.didit.me
        description: >-
          Der Host des Ausstellers: `<name>.auth.didit.me` (Produktion),
          `<name>.sandbox.auth.didit.me` (Sandbox) oder Ihre aktive
          benutzerdefinierte Domain.
security: []
tags:
  - name: Issuer
    description: Discovery- und Signaturschlüssel zur Überprüfung von Tokens.
  - name: Tokens
    description: Der Autorisierungscode und Refresh-Grants.
  - name: Sessions
    description: Die Sitzung hinter einem Zugriffstoken prüfen und beenden.
  - name: Step-ups
    description: Verifizierung vor einer sensiblen Aktion.
  - name: Monitoring
    description: Geräte-Anmeldedaten für Transaktionsüberwachungs-Ereignisse.
paths:
  /monitoring-token/:
    post:
      tags:
        - Monitoring
      summary: Erstellen Sie ein Monitoring-Token
      description: >-
        Tauscht das Access-Token der Person gegen kurzlebige Geräte-Anmeldedaten
        aus, damit der Browser oder die App der Person Aktivitätsereignisse ohne
        Ihr Backend an die Transaktionsüberwachung senden kann. Die Anmeldedaten
        sind an die `vendor_data` der Person und den `Origin` der Anfrage
        gebunden.


        Die Browser- und nativen SDKs rufen diesen Endpoint auf; Server-SDKs tun
        dies nicht. Er ist deaktiviert, bis Didit ihn aktiviert, und antwortet
        bis dahin mit `503 monitoring_unavailable`.
      operationId: authentication_create_monitoring_token
      requestBody:
        required: false
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/MonitoringTokenRequest'
            example: {}
      responses:
        '201':
          description: Gerätezugangsdaten für die Person.
          headers:
            Cache-Control:
              description: 'Immer `no-store`: Diese Antwort niemals zwischenspeichern.'
              schema:
                type: string
                example: no-store
            Pragma:
              description: Immer `no-cache`.
              schema:
                type: string
                example: no-cache
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MonitoringToken'
              examples:
                MonitoringToken:
                  summary: Zugangsdaten für den Browser der Person
                  value:
                    monitoring_token: mt_2f8c1d9e7b6a5f4e3d2c1b0a
                    expires_at: '2026-10-17T10:56:14Z'
                    allowed_event_categories:
                      - session
                      - gameplay
                      - bonus
                      - affiliate
                      - payment
                      - dispute
                      - responsible_gambling
                      - custom
                    max_uses: 1000
                    bind_to_origin: https://app.example.com
                    vendor_data: user-42
        '400':
          description: Der Body enthielt ein Feld. Senden Sie ein leeres Objekt.
          headers:
            Cache-Control:
              description: 'Immer `no-store`: Diese Antwort niemals zwischenspeichern.'
              schema:
                type: string
                example: no-store
            Pragma:
              description: Immer `no-cache`.
              schema:
                type: string
                example: no-cache
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FieldErrors'
              examples:
                UnknownField:
                  summary: Ein Feld im Body
                  value:
                    vendor_data: unknown_field
        '401':
          $ref: '#/components/responses/InvalidToken'
        '403':
          $ref: '#/components/responses/OriginNotAllowed'
        '404':
          $ref: '#/components/responses/ApplicationNotFound'
        '409':
          description: >-
            Die Ereignisüberwachung ist für die Anwendung deaktiviert.
            Aktivieren Sie die Ereigniserfassung in den Einstellungen zur
            Transaktionsüberwachung.
          headers:
            Cache-Control:
              description: 'Immer `no-store`: Diese Antwort niemals zwischenspeichern.'
              schema:
                type: string
                example: no-store
            Pragma:
              description: Immer `no-cache`.
              schema:
                type: string
                example: no-cache
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OAuthError'
              examples:
                MonitoringDisabled:
                  summary: Ereigniserfassung deaktiviert
                  value:
                    error: monitoring_disabled
        '429':
          $ref: '#/components/responses/RateLimited'
        '503':
          description: >-
            Überwachungs-Token sind nicht aktiviert, oder die Überwachung konnte
            keines ausstellen (`monitoring_unavailable`), oder ein Dienst, von
            dem die Anfrage abhängt, ist kurzzeitig nicht verfügbar
            (`temporarily_unavailable`). Versuchen Sie es später erneut.
          headers:
            Cache-Control:
              description: 'Immer `no-store`: Diese Antwort niemals zwischenspeichern.'
              schema:
                type: string
                example: no-store
            Pragma:
              description: Immer `no-cache`.
              schema:
                type: string
                example: no-cache
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OAuthError'
              examples:
                MonitoringUnavailable:
                  summary: Nicht verfügbar
                  value:
                    error: monitoring_unavailable
                TemporarilyUnavailable:
                  summary: Später erneut versuchen
                  value:
                    error: temporarily_unavailable
      security:
        - AccessToken: []
components:
  schemas:
    MonitoringTokenRequest:
      type: object
      description: 'Leer: Das Access-Token benennt die Person.'
      additionalProperties: false
      properties: {}
    MonitoringToken:
      type: object
      description: >-
        Ein kurzlebiges Geräte-Credential zum Senden der Aktivitätsereignisse
        der Person von ihrem Gerät an die Transaktionsüberwachung. Es ist nicht
        an die Sitzung gebunden: Es bleibt bis `expires_at` nutzbar, selbst nach
        dem Abmelden.
      required:
        - monitoring_token
        - expires_at
        - allowed_event_categories
        - max_uses
        - bind_to_origin
        - vendor_data
      properties:
        monitoring_token:
          type: string
          description: Das Geräte-Credential. Behandeln Sie es als Geheimnis.
          example: mt_2f8c1d9e7b6a5f4e3d2c1b0a
        expires_at:
          type: string
          format: date-time
          description: Höchstens 15 Minuten nach der Ausstellung.
          example: '2026-10-17T10:56:14Z'
        allowed_event_categories:
          type: array
          items:
            type: string
          description: >-
            Die Ereigniskategorien, die es senden darf. Authentifizierungs- und
            Sicherheitsereignisse stammen immer von Didit, niemals vom Gerät.
          example:
            - session
            - gameplay
            - bonus
            - affiliate
            - payment
            - dispute
            - responsible_gambling
            - custom
        max_uses:
          type: integer
          example: 1000
        bind_to_origin:
          type: string
          nullable: true
          description: >-
            Der Browser-Origin, von dem aus der Credential funktioniert: der
            `Origin` der Anfrage oder `null`, wenn keiner vorhanden war.
          example: https://app.example.com
        vendor_data:
          type: string
          description: >-
            Die Person, für die jedes Ereignis erfasst wird, unabhängig davon,
            was das Gerät übermittelt.
          example: user-42
    FieldErrors:
      title: Field errors
      type: object
      description: >-
        Validierungsfehler nach Feld. Ein Wert ist eine Liste von Meldungen oder
        ein einzelner Code (`unknown_field`, `invalid_redirect_uri`).
        `non_field_errors` enthält feldübergreifende Regeln.
      additionalProperties:
        oneOf:
          - type: string
          - type: array
            items:
              type: string
    OAuthError:
      title: OAuth error
      type: object
      description: Ein OAuth-Fehler (RFC 6749 Abschnitt 5.2) oder ein Dienstfehler.
      required:
        - error
      properties:
        error:
          type: string
          example: invalid_grant
    Detail:
      type: object
      required:
        - detail
      properties:
        detail:
          type: string
          example: invalid_token
  responses:
    InvalidToken:
      description: >-
        Das Zugriffstoken fehlt, ist fehlerhaft, abgelaufen, von einem anderen
        Aussteller oder Schlüssel signiert, ein ID-Token, ein Agent-Token oder
        wurde durch einen Refresh ersetzt; oder seine Sitzung wurde widerrufen,
        ist wegen Inaktivität abgelaufen, hat ihre Lebensdauer überschritten
        oder erfüllt Ihre MFA-Richtlinie nicht mehr, oder die Person wurde
        gesperrt bzw. ihre E-Mail ist nicht mehr verifiziert. Leiten Sie die
        Person erneut durch die Anmeldung.
      headers:
        WWW-Authenticate:
          description: '`Bearer`.'
          schema:
            type: string
            example: Bearer
        Cache-Control:
          description: 'Immer `no-store`: Diese Antwort niemals zwischenspeichern.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Immer `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            InvalidToken:
              summary: Abgelehntes Zugriffstoken
              value:
                detail: invalid_token
    OriginNotAllowed:
      description: >-
        Die Anfrage enthielt einen `Origin`, der weder der anwendungseigene ist
        noch zu den zulässigen Origins gehört. Server-Anfragen senden keinen
        `Origin`.
      headers:
        Cache-Control:
          description: 'Immer `no-store`: Diese Antwort niemals zwischenspeichern.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Immer `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            OriginNotAllowed:
              summary: Origin nicht zulässig
              value:
                detail: origin_not_allowed
    ApplicationNotFound:
      description: >-
        Die Adresse gehört zu einer Anwendung, aber Authentication ist für sie
        nicht aktiv; bei der Adresse `apx.didit.me` ist die Anwendungs-ID
        unbekannt. Eine Adresse, die zu keiner Anwendung gehört, wird
        abgewiesen, bevor sie den Endpoint erreicht, und diese Antwort ist kein
        JSON.
      headers:
        Cache-Control:
          description: 'Immer `no-store`: Diese Antwort niemals zwischenspeichern.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Immer `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            ApplicationNotFound:
              summary: Unbekannte Anwendung
              value:
                detail: No Configuration matches the given query.
    RateLimited:
      description: >-
        Zu viele Anfragen von dieser IP-Adresse für diesen Endpoint, oder bei
        einem `POST` oder `DELETE` ist ein Bot-Schutz-Bucket leer. Es wurde
        nichts ausgeführt: Warten Sie `Retry-After` Sekunden und versuchen Sie
        es dann erneut.
      headers:
        Retry-After:
          description: Sekunden, die vor einem Wiederholungsversuch gewartet werden müssen.
          schema:
            type: integer
            example: 60
        Cache-Control:
          description: 'Immer `no-store`: Diese Antwort niemals zwischenspeichern.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Immer `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            RateLimited:
              summary: Endpoint-Limit
              value:
                detail: >-
                  Too many requests from this IP address. Please wait before
                  trying again. Expected available in 60 seconds.
            BotProtection:
              summary: Bot-Schutz-Limit (POST und DELETE)
              value:
                detail: rate_limited Expected available in 2 seconds.
  securitySchemes:
    AccessToken:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: >-
        Das Access Token der Person von `POST /token/`: ein ES256-JWT mit dem
        Header `typ: at+jwt`, gültig für maximal 5 Minuten. Nicht Ihr
        Didit-API-Schlüssel.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.