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

# Altersschätzung API: Altersverifizierung per Selfie

> Didit Altersschätzung per POST /v3/age-estimation/: KI-gestützt mit passiver Liveness-Erkennung, ohne Ausweis, Inferenz unter 2s, Preise pro Nutzung.



## OpenAPI

````yaml de/openapi-25.json POST /v3/age-estimation/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API für Ausweisverifizierung. Authentifizierung über den x-api-key-Header.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/age-estimation/:
    post:
      tags:
        - Standalone APIs
      summary: Altersschätzung (Gesichtsalter + passive Liveness)
      description: >-
        Schätzen Sie das Alter einer Person anhand eines einzelnen Gesichtsfotos
        und führen Sie im selben Aufruf eine passive Liveness-Prüfung durch —
        gibt die vom Modell vorhergesagte `age_estimation` (in Jahren), einen
        Liveness-`score` (0–100) und einen `status` von `Approved`/`Declined`
        zurück. Das Alter wird **vom Modell anhand des Gesichts vorhergesagt und
        nicht anhand eines Dokuments verifiziert** — nutzen Sie es für
        Altersgrenzen und reibungsarme Prüfungen, nicht als rechtlichen
        Altersnachweis.


        **So funktioniert es.** Das Bild wird auf Gesichter analysiert (setzen
        Sie `rotate_image=true`, falls Aufnahmen seitlich oder auf dem Kopf
        stehen können); jedes erkannte Gesicht erhält ein geschätztes Alter, und
        das größte Gesicht im Bildausschnitt bestimmt `age_estimation`. Parallel
        dazu bewertet ein passives Liveness-Modell, ob das Foto eine lebende
        Person zeigt (keine Benutzerinteraktion erforderlich), und erkennt
        Präsentationsangriffe (Fotos von Fotos, Bildschirme, Masken). Reichen
        Sie für optimale Ergebnisse ein klares, nach vorne gerichtetes und gut
        beleuchtetes Gesicht pro Bild ein.


        **Entscheidungslogik.** Jede Warnung führt zu einer Ablehnung: `status`
        ist nur dann `Approved`, wenn das Array `warnings` leer ist. Ein
        Liveness-`score` bei oder unter `face_liveness_score_decline_threshold`
        (Standardwert `30`) fügt `LOW_LIVENESS_SCORE` hinzu; ein erkannter
        Angriff fügt `LIVENESS_FACE_ATTACK` hinzu; wird vom Liveness-Modell kein
        Gesicht gefunden, wird `NO_FACE_DETECTED` hinzugefügt; kann kein
        Gesichtsalter geschätzt werden, wird `AGE_NOT_DETECTED` hinzugefügt
        (`age_estimation` ist `null`); ein geschätztes Alter unter
        `age_estimation_decline_threshold` (Standardwert `18`) fügt
        `AGE_BELOW_MINIMUM` hinzu. Bei Grenzwerten nahe Ihrem Schwellenwert
        empfiehlt sich ein Fallback auf eine dokumentenbasierte Verifizierung —
        die Fehlerrate des Modells steigt bei Gesichtern nahe der Grenze.


        **Abrechnung.** Jede `200`-Antwort verbraucht einen API-Credit für die
        Altersschätzung (abgerechnet über Ihren Tarif-Credit oder Ihr
        Aufladeguthaben). Reicht das Guthaben der Organisation nicht aus, um den
        Aufruf zu decken, gibt der Endpoint vor jeglicher Bildverarbeitung den
        Fehler `403` für unzureichendes Guthaben zurück.


        **Sitzungspersistenz (`save_api_request`, Standardwert `true`).** Wenn
        `true`, wird der Aufruf als Sitzung vom Typ API gespeichert: Er
        erscheint in der Business Console, die zurückgegebene `request_id` ist
        eine echte Sitzungs-ID, die Sie an `GET
        /v3/session/{sessionId}/decision/` übergeben können (das Ergebnis wird
        dort in `liveness_checks[]` mit `features: ["AGE_ESTIMATION"]`
        bereitgestellt), der Gesichtsausschnitt und das Referenzbild werden
        gespeichert, das Gesichts-Embedding wird zum Gesichtsindex Ihrer
        Anwendung hinzugefügt (genutzt für die Gesichtssuche und
        Duplikaterkennung) und ein `status.updated`-Webhook wird ausgelöst. Wenn
        `false`, wird nichts gespeichert und `request_id` ist eine einmalige
        Korrelations-UUID, die später nicht abgerufen werden kann.


        **Sandbox.** Sandbox-API-Schlüssel überspringen jegliche Verarbeitung
        und Abrechnung: Nach der Validierung der Anfrage (fehlerhafte Eingaben
        geben weiterhin `400` zurück) gibt der Endpoint eine statische
        `Approved`-Mock-Payload zurück (`age_estimation: 30`, keine Warnungen),
        es wird keine Sitzung gespeichert und es werden keine Credits
        verbraucht.


        **Authentifizierung.** Senden Sie den API-Schlüssel Ihrer Anwendung im
        `x-api-key`-Header. Fehlende oder ungültige Anmeldedaten geben `403`
        zurück (`{"detail": "You do not have permission to perform this
        action."}`) — diese API gibt niemals `401` zurück.


        **Rate-Limit.** Geteiltes Schreibkontingent von 300 Anfragen/Min pro
        API-Schlüssel über alle POST/PATCH/DELETE-Endpoints hinweg; bei
        Überschreitung wird `429` zurückgegeben.
      operationId: post_v3age-estimation
      parameters: []
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              type: object
              required:
                - user_image
              properties:
                user_image:
                  type: string
                  format: binary
                  description: >-
                    Zu analysierendes Gesichtsfoto (z. B. ein Selfie). Reichen
                    Sie ein einzelnes Foto von vorne ein, auf dem das Gesicht
                    der Person deutlich sichtbar und gut ausgeleuchtet ist.
                    Zulässige Dateiendungen: `tiff`, `jpg`, `jpeg`, `png`,
                    `webp` (kein PDF). Maximale Upload-Größe: **5 MB** (größere
                    Dateien werden mit `400` abgelehnt). Bilder werden vor der
                    Verarbeitung automatisch auf ca. 0,3 MB komprimiert, sodass
                    sehr hohe Auflösungen die Genauigkeit nicht verbessern.
                face_liveness_score_decline_threshold:
                  type: number
                  format: float
                  default: 30
                  minimum: 0
                  maximum: 100
                  description: >-
                    Liveness-Schwellenwert (0–100). Ein Liveness-`score` **bei
                    oder unter** diesem Wert fügt eine
                    `LOW_LIVENESS_SCORE`-Warnung hinzu und lehnt ab. Erhöhen Sie
                    ihn für eine strengere Spoofing-Abwehr; Werte außerhalb von
                    0–100 geben `400` zurück.
                  example: 30
                age_estimation_decline_threshold:
                  type: integer
                  default: 18
                  minimum: 0
                  maximum: 100
                  description: >-
                    Mindestwert für das geschätzte Alter in Jahren. Ein
                    geschätztes Alter **unter** diesem Wert fügt eine
                    `AGE_BELOW_MINIMUM`-Warnung hinzu und führt zur Ablehnung.
                    Setzen Sie den Wert auf `0`, um die Altersprüfung zu
                    deaktivieren (der Aufruf führt dann nur Liveness-Erkennung +
                    Altersschätzung ohne altersbasierte Entscheidung durch).
                  example: 18
                rotate_image:
                  type: boolean
                  default: false
                  description: >-
                    Wenn `true`, testet der Dienst das Eingabebild in
                    90-Grad-Schritten (0, 90, 180, 270) und verwendet die
                    Ausrichtung, die die beste Gesichtserkennung liefert –
                    nützlich für mobile Aufnahmen mit fehlender
                    EXIF-Ausrichtung. Erhöht die Latenz, aktivieren Sie dies
                    also nur, wenn Sie aufrechte Bilder nicht garantieren
                    können.
                  example: false
                save_api_request:
                  type: boolean
                  default: true
                  description: >-
                    Wenn `true` (Standard), wird der Aufruf als Sitzung vom Typ
                    API persistent gespeichert — sichtbar in der Business
                    Console, abrufbar über `GET
                    /v3/session/{sessionId}/decision/` unter Verwendung der
                    zurückgegebenen `request_id`, angekündigt über einen
                    `status.updated`-Webhook und mit dem erkannten Gesicht zum
                    Gesichtsindex Ihrer Anwendung hinzugefügt. Wenn `false`,
                    wird nichts gespeichert und `request_id` ist eine flüchtige
                    UUID, die nur der Antwortkorrelation dient.
                  example: true
                vendor_data:
                  type: string
                  description: >-
                    Optionale opake Zeichenfolge (Ihre interne Benutzer-ID,
                    E-Mail, UUID…), die in der gespeicherten Sitzung hinterlegt
                    und in der Antwort zurückgegeben wird. Verwenden Sie sie, um
                    API-Aufrufe mit Ihren eigenen Datensätzen abzugleichen und
                    Sitzungen später zu filtern.
                  example: user-123
                metadata:
                  type: object
                  additionalProperties: true
                  description: >-
                    Optionales JSON-Objekt, das mit der Sitzung gespeichert
                    (wenn `save_api_request=true`) und in der Antwort
                    zurückgegeben wird. Senden Sie es bei Multipart-Anfragen als
                    JSON-codiertes String-Feld (z. B.
                    `metadata={"flow":"age-gate"}`) – es wird in ein Objekt
                    geparst.
                  example:
                    flow: age-gate
            example:
              user_image: (binary JPEG/PNG of the selfie)
              face_liveness_score_decline_threshold: 30
              age_estimation_decline_threshold: 18
              rotate_image: false
              save_api_request: true
              vendor_data: user-123
              metadata:
                flow: age-gate
      responses:
        '200':
          description: >-
            Altersschätzung und passive Liveness abgeschlossen.
            `age_estimation.age_estimation` ist das vom Modell vorhergesagte
            Alter in Jahren des größten erkannten Gesichts (`null`, falls keines
            vorhanden); `age_estimation.score` ist der Score für passive
            Liveness (0–100); `status` ist nur dann `Approved`, wenn `warnings`
            leer ist. Eine Erfassung einer minderjährigen Person oder ein
            Spoofing gibt dennoch `200` mit `status: "Declined"` zurück – prüfen
            Sie den Body, nicht nur den HTTP-Code. Wenn `save_api_request=true`,
            ist `request_id` die persistierte Sitzungs-ID.
          content:
            application/json:
              examples:
                Approved:
                  summary: Live-Gesicht eines Erwachsenen – beide Prüfungen bestanden
                  value:
                    request_id: 0c40ba43-64ab-4e2e-b4b8-7d1f12f81bc1
                    age_estimation:
                      status: Approved
                      method: PASSIVE
                      score: 97.5
                      user_image:
                        entities:
                          - age: 27.33
                            bbox:
                              - 40
                              - 40
                              - 100
                              - 100
                            confidence: 0.7177750468254089
                            gender: male
                        best_angle: 0
                      age_estimation: 27.33
                      warnings: []
                    vendor_data: user-123
                    metadata:
                      flow: age-gate
                    created_at: '2026-06-12T02:24:11.512941+00:00'
                Declined - age below threshold:
                  summary: Geschätztes Alter unter `age_estimation_decline_threshold`
                  value:
                    request_id: 9be41a6f-2f4e-4f57-92f4-b3a4f6f0a1c2
                    age_estimation:
                      status: Declined
                      method: PASSIVE
                      score: 95
                      user_image:
                        entities:
                          - age: 16.5
                            bbox:
                              - 40
                              - 40
                              - 100
                              - 100
                            confidence: 0.7177750468254089
                            gender: female
                        best_angle: 0
                      age_estimation: 16.5
                      warnings:
                        - risk: AGE_BELOW_MINIMUM
                          feature: LIVENESS
                          additional_data: null
                          log_type: error
                          short_description: Age below minimum
                          long_description: >-
                            The age of the face is below the minimum age
                            threshold for the application.
                    vendor_data: user-123
                    metadata: null
                    created_at: '2026-06-12T02:26:40.118332+00:00'
                Declined - liveness too low:
                  summary: >-
                    Liveness-Score liegt bei oder unter dem
                    Ablehnungsschwellenwert (möglicher Spoof)
                  value:
                    request_id: 5f6f2f1f-7c4f-43b9-8d62-0a8f4c2d9e77
                    age_estimation:
                      status: Declined
                      method: PASSIVE
                      score: 5
                      user_image:
                        entities:
                          - age: 25
                            bbox:
                              - 40
                              - 40
                              - 100
                              - 100
                            confidence: 0.7177750468254089
                            gender: male
                        best_angle: 0
                      age_estimation: 25
                      warnings:
                        - risk: LOW_LIVENESS_SCORE
                          feature: LIVENESS
                          additional_data: null
                          log_type: error
                          short_description: Low liveness score
                          long_description: >-
                            The liveness check resulted in a low score,
                            indicating potential use of non-live facial
                            representations or poor-quality biometric data.
                    vendor_data: user-123
                    metadata: null
                    created_at: '2026-06-12T02:27:02.901547+00:00'
              schema:
                type: object
                properties:
                  request_id:
                    type: string
                    format: uuid
                    description: >-
                      Beibehaltene Sitzungs-ID, wenn `save_api_request=true`
                      (verwendbar mit `GET /v3/session/{sessionId}/decision/`);
                      andernfalls eine vorübergehende Korrelations-UUID.
                  age_estimation:
                    type: object
                    properties:
                      status:
                        type: string
                        enum:
                          - Approved
                          - Declined
                        description: >-
                          `Approved`, wenn keine Warnungen ausgegeben wurden;
                          andernfalls `Declined` (jede Warnung, die dieser
                          Endpoint erzeugt, führt zu einer Ablehnung).
                      method:
                        type: string
                        enum:
                          - PASSIVE
                        description: >-
                          Liveness-Methode. An diesem Endpoint immer `PASSIVE`
                          (Einzelbild, keine Benutzeraufforderung).
                      score:
                        type: number
                        format: float
                        nullable: true
                        minimum: 0
                        maximum: 100
                        description: >-
                          Passiver Liveness-Score von 0 bis 100 – der
                          Konfidenzwert des Modells, dass das Foto eine lebende
                          Person zeigt. Wird mit
                          `face_liveness_score_decline_threshold` verglichen;
                          bei oder unter diesem Wert wird der Aufruf mit
                          `LOW_LIVENESS_SCORE` abgelehnt. `null`, wenn das
                          Liveness-Modell keinen Konfidenzwert zurückgibt – der
                          Aufruf wird dennoch mit `LOW_LIVENESS_SCORE`
                          abgelehnt, da null beim Schwellenwertvergleich wie 0
                          behandelt wird.
                        example: 97.5
                      user_image:
                        type: object
                        description: Gesichtserkennungsergebnisse für das analysierte Bild.
                        properties:
                          entities:
                            type: array
                            description: >-
                              Ein Eintrag pro erkanntem Gesicht. Leer, wenn kein
                              Gesicht gefunden wurde (dann ist `age_estimation`
                              gleich `null` und es wird eine
                              `AGE_NOT_DETECTED`-Warnung hinzugefügt).
                            items:
                              type: object
                              properties:
                                age:
                                  type: number
                                  format: float
                                  description: >-
                                    Vom Modell geschätztes Alter dieses Gesichts
                                    in Jahren.
                                  example: 27.33
                                bbox:
                                  type: array
                                  items:
                                    type: integer
                                  minItems: 4
                                  maxItems: 4
                                  description: >-
                                    Bounding-Box des erkannten Gesichts als
                                    Pixelkoordinaten `[x_min, y_min, x_max,
                                    y_max]` im verarbeiteten Bild.
                                  example:
                                    - 40
                                    - 40
                                    - 100
                                    - 100
                                confidence:
                                  type: number
                                  format: float
                                  minimum: 0
                                  maximum: 1
                                  description: Konfidenz der Gesichtserkennung (0–1).
                                  example: 0.7177750468254089
                                gender:
                                  type: string
                                  description: >-
                                    Vom Modell vorhergesagtes Geschlecht des
                                    erkannten Gesichts (`male` oder `female`).
                                    Dient nur zur Information.
                                  example: male
                          best_angle:
                            type: integer
                            nullable: true
                            description: >-
                              Drehung (Grad: 0, 90, 180 oder 270), die die beste
                              Gesichtserkennung lieferte. Nur ungleich null,
                              wenn `rotate_image=true` die Ausrichtung
                              korrigiert hat.
                            example: 0
                      age_estimation:
                        type: number
                        format: float
                        nullable: true
                        description: >-
                          Vom Modell vorhergesagtes Alter des **größten**
                          erkannten Gesichts in Jahren. `null`, wenn kein
                          Gesichtsalter geschätzt werden konnte (eine
                          `AGE_NOT_DETECTED`-Warnung wird hinzugefügt und der
                          Aufruf wird abgelehnt).
                        example: 27.33
                      warnings:
                        type: array
                        description: >-
                          Leer bei einer fehlerfreien Genehmigung. Jeder Eintrag
                          setzt `status` auf `Declined`.
                        items:
                          type: object
                          properties:
                            risk:
                              type: string
                              enum:
                                - NO_FACE_DETECTED
                                - LOW_LIVENESS_SCORE
                                - LIVENESS_FACE_ATTACK
                                - AGE_NOT_DETECTED
                                - AGE_BELOW_MINIMUM
                              description: >-
                                Maschinenlesbarer Risiko-Code.
                                `NO_FACE_DETECTED` — das Liveness-Modell hat
                                kein Gesicht gefunden; `LOW_LIVENESS_SCORE` —
                                Liveness-`score` liegt bei oder unter
                                `face_liveness_score_decline_threshold`;
                                `LIVENESS_FACE_ATTACK` — ein
                                Präsentationsangriff (Foto/Bildschirm/Maske)
                                wurde erkannt; `AGE_NOT_DETECTED` — das Alter
                                konnte nicht geschätzt werden;
                                `AGE_BELOW_MINIMUM` — geschätztes Alter liegt
                                unter `age_estimation_decline_threshold`.
                                `NO_FACE_DETECTED` und `LOW_LIVENESS_SCORE`
                                schließen sich gegenseitig aus — wenn kein
                                Gesicht gefunden wird, wird nur
                                `NO_FACE_DETECTED` ausgegeben.
                            feature:
                              type: string
                              enum:
                                - LIVENESS
                              description: >-
                                Funktion, die die Warnung ausgelöst hat. An
                                diesem Endpoint immer `LIVENESS`.
                            additional_data:
                              type: object
                              nullable: true
                              additionalProperties: true
                              description: Für Warnungen zur Altersschätzung immer `null`.
                            log_type:
                              type: string
                              enum:
                                - error
                              description: >-
                                Schweregrad. Jede Warnung, die dieser Endpoint
                                erzeugt, ist ein `error` und setzt `status` auf
                                `Declined`.
                            short_description:
                              type: string
                              description: >-
                                Für Menschen lesbare einzeilige Zusammenfassung
                                des Risikos.
                            long_description:
                              type: string
                              description: Lesbare Erklärung des Risikos.
                  vendor_data:
                    type: string
                    nullable: true
                    description: >-
                      Rückgabe der von Ihnen gesendeten `vendor_data` oder
                      `null`.
                  metadata:
                    type: object
                    nullable: true
                    additionalProperties: true
                    description: >-
                      Rückgabe des von Ihnen gesendeten `metadata`-Objekts oder
                      `null`.
                  created_at:
                    type: string
                    format: date-time
                    description: >-
                      ISO 8601-Zeitstempel (UTC), wann die Antwort generiert
                      wurde.
        '400':
          description: >-
            Validierungsfehler. Wird zurückgegeben, wenn `user_image` fehlt, 5
            MB überschreitet, eine nicht unterstützte Dateiendung hat oder ein
            Schwellenwert außerhalb des zulässigen Bereichs liegt. Der Body ist
            die standardmäßige Feld-Fehler-Envelope von DRF: ein Array von
            Meldungen pro betroffenem Feld.
          content:
            application/json:
              examples:
                Missing user image:
                  summary: '`user_image` ist nicht in den Formulardaten enthalten'
                  value:
                    user_image:
                      - No file was submitted.
                Unsupported file extension:
                  summary: Dateiendung außerhalb von tiff/jpg/jpeg/png/webp
                  value:
                    user_image:
                      - >-
                        File extension “txt” is not allowed. Allowed extensions
                        are: tiff, jpg, jpeg, png, webp.
                File too large:
                  summary: Der Upload überschreitet das Limit von 5 MB
                  value:
                    user_image:
                      - File size should not exceed 5 MB
                Threshold out of range:
                  summary: >-
                    `face_liveness_score_decline_threshold` liegt außerhalb von
                    0–100
                  value:
                    face_liveness_score_decline_threshold:
                      - Ensure this value is less than or equal to 100.
        '403':
          description: >-
            Zugriff verweigert. Wird zurückgegeben, wenn der Header `x-api-key`
            fehlt sowie wenn das Guthaben der aufrufenden Organisation den
            Aufruf nicht decken kann; ein falscher, widerrufener oder
            abgelaufener Schlüssel gibt `401` zurück. Ein fehlender Schlüssel
            gibt `403` mit `{"detail": ...}` zurück; ein falscher, widerrufener
            oder abgelaufener Schlüssel gibt `401` zurück. Unzureichende Credits
            geben `403` mit `{"error": ...}` zurück, bevor eine Bildverarbeitung
            stattfindet.
          content:
            application/json:
              examples:
                Missing or invalid API key:
                  summary: >-
                    Kein `x-api-key`-Header, oder der Schlüssel ist
                    ungültig/widerrufen
                  value:
                    detail: You do not have permission to perform this action.
                Not enough credits:
                  summary: >-
                    Das Guthaben der Organisation reicht für den Aufruf nicht
                    aus
                  value:
                    error: >-
                      You don't have enough credits to perform this request.
                      Please top up at https://business.didit.me
        '429':
          description: >-
            Rate-Limit überschritten. POST/PATCH/DELETE-Endpoints teilen sich
            ein Budget von 300 Schreibanfragen pro Minute pro API-Schlüssel
            (Transaktionserstellungen und Ereignis-Ingestion haben ein separates
            Budget von 600). Die Antwort enthält die Header `X-RateLimit-Limit`,
            `X-RateLimit-Remaining`, `X-RateLimit-Reset` und `Retry-After`.
          content:
            application/json:
              examples:
                Write rate limit exceeded:
                  summary: Mehr als 300 Schreibanfragen in der aktuellen Minute
                  value:
                    detail: >-
                      Write request rate limit exceeded. You can make up to 300
                      requests per minute.
              schema:
                type: object
                properties:
                  detail:
                    type: string
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |-
            curl -X POST 'https://verification.didit.me/v3/age-estimation/' \
              -H 'x-api-key: YOUR_API_KEY' \
              -F 'user_image=@./selfie.jpg' \
              -F 'age_estimation_decline_threshold=18' \
              -F 'face_liveness_score_decline_threshold=30' \
              -F 'save_api_request=true' \
              -F 'vendor_data=user-123'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.age_estimation.estimate(
                user_image=open("user_image.jpg", "rb"),
                face_liveness_score_decline_threshold=30.0,
                age_estimation_decline_threshold=18,
                rotate_image=False,
                save_api_request=True,
                vendor_data="user-123",
                metadata={"flow": "age-gate"},
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit, { fileFromPath } from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY.
            const didit = new Didit();

            const result = await didit.ageEstimation.estimate({
              user_image: await fileFromPath("user_image.jpg"),
              face_liveness_score_decline_threshold: 30.0,
              age_estimation_decline_threshold: 18,
              rotate_image: false,
              save_api_request: true,
              vendor_data: "user-123",
              metadata: { flow: "age-gate" },
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.AgeEstimation.Estimate(ctx, didit.AgeEstimationEstimateParams{\n\tUserImage:                         didit.FileFromPath(\"user_image.jpg\"),\n\tFaceLivenessScoreDeclineThreshold: didit.Float(30.0),\n\tAgeEstimationDeclineThreshold:     didit.Int(18),\n\tRotateImage:                       didit.Bool(false),\n\tSaveAPIRequest:                    didit.Bool(true),\n\tVendorData:                        didit.String(\"user-123\"),\n\tMetadata:                          didit.Some(map[string]any{\"flow\": \"age-gate\"}),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.nio.file.Path;

            import java.util.Map;

            import me.didit.Didit;

            import me.didit.types.AgeEstimationEstimateParams;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.ageEstimation().estimate(AgeEstimationEstimateParams.builder()
                    .userImage(Path.of("user_image.jpg"))
                    .faceLivenessScoreDeclineThreshold(30.0)
                    .ageEstimationDeclineThreshold(18L)
                    .rotateImage(false)
                    .saveApiRequest(true)
                    .vendorData("user-123")
                    .metadata(Map.of("flow", "age-gate"))
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;
            use Didit\File;

            // Reads DIDIT_API_KEY.
            $didit = new DiditClient();

            $result = $didit->ageEstimation->estimate([
                'user_image' => File::fromPath('user_image.jpg'),
                'face_liveness_score_decline_threshold' => 30.0,
                'age_estimation_decline_threshold' => 18,
                'rotate_image' => false,
                'save_api_request' => true,
                'vendor_data' => 'user-123',
                'metadata' => ['flow' => 'age-gate'],
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Reads DIDIT_API_KEY.
            didit = Didit::Client.new

            result = didit.age_estimation.estimate(
              user_image: Pathname("user_image.jpg"),
              face_liveness_score_decline_threshold: 30.0,
              age_estimation_decline_threshold: 18,
              rotate_image: false,
              save_api_request: true,
              vendor_data: "user-123",
              metadata: { flow: "age-gate" }
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Collections.Generic;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await client.AgeEstimation.EstimateAsync(new
            AgeEstimationEstimateParams

            {
                UserImage = FileUpload.FromPath("user_image.jpg"),
                FaceLivenessScoreDeclineThreshold = 30.0,
                AgeEstimationDeclineThreshold = 18,
                RotateImage = false,
                SaveApiRequest = true,
                VendorData = "user-123",
                Metadata = new Dictionary<string, object> { ["flow"] = "age-gate" },
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        Der API-Schlüssel Ihrer Anwendung, aus Entwickler -> API-Schlüssel in
        der Business Console. Der Primärschlüssel hat Vollzugriff. Ein benannter
        Schlüssel kann im Geltungsbereich eingeschränkt werden: keine, Lese-
        oder Schreibberechtigung pro Ressource, beschränkt auf bestimmte
        Workflows oder genehmigte Sitzungen, auf eine Liste von IP-Adressen und
        auf ein Ablaufdatum. 401 bedeutet, dass der Schlüssel falsch, widerrufen
        oder abgelaufen ist; 403 bedeutet, dass kein Schlüssel gesendet wurde,
        der Schlüssel keinen Zugriff auf diese Ressource oder Aktion hat oder
        die Anfrage von einer Adresse außerhalb seiner IP-Liste stammte; 404 bei
        einer Sitzungsroute bedeutet, dass die Sitzung außerhalb der Workflows
        oder Status des Schlüssels liegt. Ein Schlüssel ohne Medienzugriff
        erhält Bild-, Video- und PDF-URLs als null, und ein Schlüssel ohne
        Schreibberechtigung für Sitzungen erhält Sitzungslinks und Token als
        null. Siehe https://docs.didit.me/console/api-keys.

````

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