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

# get watermark check

> Returns the current state of a watermark check created with Create a watermark check. Poll about every 2 seconds until `status` is `done`, `rejected` or `failed`. The API key needs read access to watermark checks.

Store the terminal response. The validator deletes a finished result 60 seconds after it is first fetched, or 1 hour after finishing if it is never fetched; later requests return 404 `not_found`.

A check whose file is never uploaded stays `awaiting_upload` until its upload link expires, then returns 404 `not_found` about 10.5 minutes after it was created. Create a new check to try again.




## OpenAPI

````yaml https://api.anam.ai/swagger.json get /v1/watermark/checks/{id}
openapi: 3.1.0
info:
  title: Anam AI API
  version: '1.0'
servers:
  - url: https://api.anam.ai
    description: Anam API
security:
  - BearerAuth: []
tags:
  - name: Sessions
  - name: Avatar Videos
  - name: Meetings
  - name: Watermark Checks
  - name: Personas
  - name: Avatars
  - name: Voices
  - name: Pronunciation Dictionaries
  - name: LLMs
  - name: Knowledge
  - name: Tools
  - name: Share Links
  - name: Engine
paths:
  /v1/watermark/checks/{id}:
    get:
      tags:
        - Watermark Checks
      summary: Get a watermark check
      description: >
        Returns the current state of a watermark check created with Create a
        watermark check. Poll about every 2 seconds until `status` is `done`,
        `rejected` or `failed`. The API key needs read access to watermark
        checks.


        Store the terminal response. The validator deletes a finished result 60
        seconds after it is first fetched, or 1 hour after finishing if it is
        never fetched; later requests return 404 `not_found`.


        A check whose file is never uploaded stays `awaiting_upload` until its
        upload link expires, then returns 404 `not_found` about 10.5 minutes
        after it was created. Create a new check to try again.
      operationId: getWatermarkCheck
      parameters:
        - in: path
          name: id
          required: true
          schema:
            type: string
            pattern: ^chk_[0-9a-z]{26}$
      responses:
        '200':
          description: Current status or terminal result.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WatermarkCheckStatusResponse'
              examples:
                done:
                  $ref: '#/components/examples/WatermarkCheckDoneMarked'
        '401':
          description: Missing or invalid API key
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WatermarkCheckError'
        '403':
          description: API key lacks watermark-check read access
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WatermarkCheckError'
        '404':
          description: >-
            Check not found, owned by another organization, its upload link
            expired without an upload, or its result has expired
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WatermarkCheckError'
        '500':
          description: Unexpected server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WatermarkCheckError'
        '502':
          description: Validator unavailable
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WatermarkCheckError'
        '503':
          description: Service temporarily unavailable; retry after `Retry-After` seconds.
          headers:
            Retry-After:
              description: Seconds to wait before retrying.
              schema:
                type: integer
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WatermarkCheckError'
components:
  schemas:
    WatermarkCheckStatusResponse:
      description: >-
        Current state of a watermark check. Keep polling while `status` is
        `awaiting_upload`, `uploading`, `queued` or `running`.
      oneOf:
        - $ref: '#/components/schemas/WatermarkCheckPending'
        - $ref: '#/components/schemas/WatermarkCheckDone'
        - $ref: '#/components/schemas/WatermarkCheckRejected'
        - $ref: '#/components/schemas/WatermarkCheckFailed'
      discriminator:
        propertyName: status
        mapping:
          awaiting_upload: '#/components/schemas/WatermarkCheckPending'
          uploading: '#/components/schemas/WatermarkCheckPending'
          queued: '#/components/schemas/WatermarkCheckPending'
          running: '#/components/schemas/WatermarkCheckPending'
          done: '#/components/schemas/WatermarkCheckDone'
          rejected: '#/components/schemas/WatermarkCheckRejected'
          failed: '#/components/schemas/WatermarkCheckFailed'
    WatermarkCheckError:
      type: object
      required:
        - error
        - code
      properties:
        error:
          type: string
          description: Human-readable message.
        code:
          $ref: '#/components/schemas/WatermarkCheckErrorCode'
    WatermarkCheckPending:
      type: object
      additionalProperties: false
      required:
        - check_id
        - status
      properties:
        check_id:
          type: string
        status:
          type: string
          enum:
            - awaiting_upload
            - uploading
            - queued
            - running
          description: >-
            `awaiting_upload` until the validator starts receiving the file,
            then `uploading`, `queued` and `running`.
    WatermarkCheckDone:
      type: object
      additionalProperties: false
      required:
        - check_id
        - status
        - result
        - report
      properties:
        check_id:
          type: string
        status:
          type: string
          enum:
            - done
        result:
          $ref: '#/components/schemas/WatermarkCheckResult'
        report:
          type: string
          description: >-
            Signed report as a compact JWS (EdDSA, Ed25519). Its payload is
            `result` plus `iss` (the detector URL) and `iat`. Verify it with the
            key whose `kid` matches the JWS header, published at
            https://watermark-eu.anam.ai/v1/watermark/jwks.json. Store it; Anam
            keeps no copy.
    WatermarkCheckRejected:
      type: object
      additionalProperties: false
      required:
        - check_id
        - status
        - error_code
      properties:
        check_id:
          type: string
        status:
          type: string
          enum:
            - rejected
        error_code:
          type: string
          enum:
            - unsupported_format
            - undecodable
            - too_short
            - unsupported_media
          description: >-
            The file was not analysed. `unsupported_format` - not an MP4, MOV,
            WebM or MKV video with a video track. `undecodable` - the file could
            not be read. `too_short` - shorter than 10 seconds.
            `unsupported_media` - unsupported codec, more than 4096 px on a side
            or 4K pixel count, more than 120 fps, or too many streams or
            channels.
    WatermarkCheckFailed:
      type: object
      additionalProperties: false
      required:
        - check_id
        - status
        - error_code
      properties:
        check_id:
          type: string
        status:
          type: string
          enum:
            - failed
        error_code:
          type: string
          enum:
            - timeout
            - internal_error
          description: The check could not finish. Create a new check to try again.
    WatermarkCheckErrorCode:
      type: string
      enum:
        - invalid_request
        - file_too_large
        - rate_limited
        - too_many_running
        - validator_unavailable
        - not_found
        - internal_error
        - service_unavailable
        - unauthorized
        - forbidden
    WatermarkCheckResult:
      type: object
      additionalProperties: false
      required:
        - check_id
        - verdict
        - audio
        - video
        - based_on
        - key_id
        - validator_version
        - thresholds_version
        - file_sha256
        - media_duration_s
        - analysed_duration_s
        - analysed_truncated
        - checked_at
        - detector
      properties:
        check_id:
          type: string
        verdict:
          type: string
          enum:
            - marked
            - not_marked
            - inconclusive
          description: >-
            Overall verdict. `marked` when either medium is marked. `not_marked`
            only when every medium present in the file is `not_marked`.
            Otherwise `inconclusive`.
        audio:
          $ref: '#/components/schemas/WatermarkMediumResult'
        video:
          $ref: '#/components/schemas/WatermarkMediumResult'
        based_on:
          type: string
          enum:
            - watermark
          description: >-
            The verdict is based on the invisible watermark in the media, not on
            file metadata.
        key_id:
          type: string
          description: Identifier of the watermark key the detector checked against.
        validator_version:
          type: string
        thresholds_version:
          type: string
          description: Version of the detection thresholds used.
        file_sha256:
          type: string
          description: SHA-256 of the uploaded file
          as lowercase hex.: null
        media_duration_s:
          type:
            - number
            - 'null'
          description: Duration of the file in seconds, or null when unknown.
        analysed_duration_s:
          type: number
          description: >-
            Seconds analysed from the start of the file: at most 300 for videos
            up to 720p, and less at higher resolutions (about 166 at 1080p and
            48 at 4K).
        analysed_truncated:
          type: boolean
          description: True when the file was longer than the analysed part.
        checked_at:
          type: string
          format: date-time
        detector:
          type: string
          format: uri
          description: URL identifying the detector that produced the result.
    WatermarkMediumResult:
      type: object
      additionalProperties: false
      required:
        - verdict
        - reason
      properties:
        verdict:
          type: string
          enum:
            - marked
            - not_marked
            - not_present
            - inconclusive
          description: >-
            `marked` - the Anam watermark was found. `not_marked` - it was
            checked and not found. `not_present` - the file has no track of this
            medium. `inconclusive` - there was not enough signal to decide; see
            `reason`.
        reason:
          type:
            - string
            - 'null'
          enum:
            - too_little_speech
            - corrupted
            - too_few_frames_with_face
            - face_too_small
            - no_face
            - undetermined
            - null
          description: >-
            Set only when `verdict` is `inconclusive`. `too_little_speech` - not
            enough avatar speech in the audio. `corrupted` - part of the media
            could not be decoded reliably. `too_few_frames_with_face` - too few
            frames showed the avatar's face. `face_too_small` - the face was too
            small in the frame, as in a small screen capture. `no_face` - no
            face was found. `undetermined` - the detector could not reach a
            reliable conclusion.
  examples:
    WatermarkCheckDoneMarked:
      summary: Watermark found
      value:
        check_id: chk_0123456789abcdefghijklmnop
        status: done
        result:
          check_id: chk_0123456789abcdefghijklmnop
          verdict: marked
          audio:
            verdict: marked
            reason: null
          video:
            verdict: inconclusive
            reason: face_too_small
          based_on: watermark
          key_id: 7c1e9b42
          validator_version: '1'
          thresholds_version: v3
          file_sha256: 9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08
          media_duration_s: 760.4
          analysed_duration_s: 300
          analysed_truncated: true
          checked_at: '2026-11-20T10:15:00Z'
          detector: https://watermark-eu.anam.ai/v1/watermark
        report: >-
          eyJhbGciOiJFZERTQSIsImtpZCI6ImIwNGQyZTYxYTljMzVmMTciLCJ0eXAiOiJKV1QifQ.eyJjaGVja19pZCI6ImNoa18wMTIzNDU2Nzg5YWJjZGVmZ2hpamtsbW5vcCIsInZlcmRpY3QiOiJtYXJrZWQiLCJhdWRpbyI6eyJ2ZXJkaWN0IjoibWFya2VkIiwicmVhc29uIjpudWxsfSwidmlkZW8iOnsidmVyZGljdCI6ImluY29uY2x1c2l2ZSIsInJlYXNvbiI6ImZhY2VfdG9vX3NtYWxsIn0sImJhc2VkX29uIjoid2F0ZXJtYXJrIiwia2V5X2lkIjoiN2MxZTliNDIiLCJ2YWxpZGF0b3JfdmVyc2lvbiI6IjEiLCJ0aHJlc2hvbGRzX3ZlcnNpb24iOiJ2MyIsImZpbGVfc2hhMjU2IjoiOWY4NmQwODE4ODRjN2Q2NTlhMmZlYWEwYzU1YWQwMTVhM2JmNGYxYjJiMGI4MjJjZDE1ZDZjMTViMGYwMGEwOCIsIm1lZGlhX2R1cmF0aW9uX3MiOjc2MC40LCJhbmFseXNlZF9kdXJhdGlvbl9zIjozMDAsImFuYWx5c2VkX3RydW5jYXRlZCI6dHJ1ZSwiY2hlY2tlZF9hdCI6IjIwMjYtMTEtMjBUMTA6MTU6MDBaIiwiZGV0ZWN0b3IiOiJodHRwczovL3dhdGVybWFyay1ldS5hbmFtLmFpL3YxL3dhdGVybWFyayIsImlzcyI6Imh0dHBzOi8vd2F0ZXJtYXJrLWV1LmFuYW0uYWkvdjEvd2F0ZXJtYXJrIiwiaWF0IjoxNzk1MTY5NzAwfQ.aO3M6JhxFLMRYaBK5qfCiZD5bp-MMwLrePVqcs5jujg_dOLf944E4NPEAGLCs0DOWmE8emxxYBG4h7NKbIAf0A
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer

````

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