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

# Get watermark order details

> Get the status, upload URLs, embed outputs, extract result, and report status of a watermark order created with the v3 API. You can always call this endpoint, whatever the order status.

This endpoint returns only watermark orders created with `POST /api/v3/orders/wtr-embed` or `wtr-extract`. Other orders, including Anti-AI and AI Detection orders, return `404 ORDER_NOT_FOUND`; use [`GET /api/v2/orders/{orderId}`](/api-reference/orders/get-order) for them.

- `files[].uploadUrl` is issued only while the order `status` is `pending`, the retention period has not ended, and the file is still waiting for upload. Otherwise it is `null`
- `result` contains only `detectionStatus`, `reportSupported`, and `watermarkText`. It is `null` for embed orders and before an extract result is ready
- `result.watermarkText` returns the embedded text only when your account embedded the detected watermark and exactly one issuance record matches. Otherwise it is `null`




## OpenAPI

````yaml api-reference/openapi.yaml GET /api/v3/orders/{orderId}
openapi: 3.0.0
info:
  title: BIZ MORI API
  version: 2.0.0
  description: >
    BIZ MORI API provides four core services for digital content protection:

    - **Anti-AI**: Protect images from AI training

    - **Watermark Embed**: Embed invisible digital watermarks into images

    - **Watermark Extract**: Extract and verify watermarks from images

    - **AI Detection**: Detect whether an image is AI-generated

    - **Test API keys**: Keys with the `sk_test_` prefix use the same Bearer
    authentication and support order-lifecycle testing with mock responses
    without running processing services or consuming credits; test uploads
    discard file contents and do not create result files
  contact:
    name: BIZ MORI Support
    email: support@bizmori.com
  license:
    name: Proprietary
    url: https://docs.bizmori.com/legal/terms
servers:
  - url: https://api.bizmori.com
    description: Production
security: []
tags:
  - name: Anti-AI
    description: Anti-AI image protection orders
  - name: Watermark Embed
    description: Watermark embedding orders
  - name: Watermark Extract
    description: Watermark extraction orders
  - name: AI Detection
    description: AI-generated image detection orders
  - name: Orders
    description: Order query and management
  - name: Webhooks
    description: Webhook configuration and events
  - name: Reports
    description: PDF analysis reports for watermark extract and AI Detection orders
paths:
  /api/v3/orders/{orderId}:
    get:
      tags:
        - Orders
      summary: Get watermark order details
      description: >
        Get the status, upload URLs, embed outputs, extract result, and report
        status of a watermark order created with the v3 API. You can always call
        this endpoint, whatever the order status.


        This endpoint returns only watermark orders created with `POST
        /api/v3/orders/wtr-embed` or `wtr-extract`. Other orders, including
        Anti-AI and AI Detection orders, return `404 ORDER_NOT_FOUND`; use [`GET
        /api/v2/orders/{orderId}`](/api-reference/orders/get-order) for them.


        - `files[].uploadUrl` is issued only while the order `status` is
        `pending`, the retention period has not ended, and the file is still
        waiting for upload. Otherwise it is `null`

        - `result` contains only `detectionStatus`, `reportSupported`, and
        `watermarkText`. It is `null` for embed orders and before an extract
        result is ready

        - `result.watermarkText` returns the embedded text only when your
        account embedded the detected watermark and exactly one issuance record
        matches. Otherwise it is `null`
      operationId: getWatermarkV1Order
      parameters:
        - in: path
          name: orderId
          required: true
          schema:
            type: string
          description: Order ID
      responses:
        '200':
          description: Order details
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WatermarkV1OrderResponse'
              example:
                data:
                  orderId: '1234567891'
                  status: complete
                  processingDelayed: false
                  expiresAt: '2026-10-08T03:00:00.000Z'
                  files:
                    - fileId: '601'
                      uploadUrl: null
                    - fileId: '602'
                      uploadUrl: null
                  outputs: []
                  result:
                    detectionStatus: detected
                    reportSupported: true
                    watermarkText: MORI-2026-001
                  reports:
                    - locale: en-US
                      status: completed
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '404':
          description: The order does not exist or belongs to another account
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                code: ORDER_NOT_FOUND
        '500':
          $ref: '#/components/responses/InternalError'
      security:
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |
            curl -X GET https://api.bizmori.com/api/v3/orders/ORDER_ID \
              -H "Authorization: Bearer YOUR_API_KEY"
        - lang: javascript
          label: JavaScript
          source: >
            const orderId = 'ORDER_ID';

            const response = await
            fetch(`https://api.bizmori.com/api/v3/orders/${orderId}`, {
              headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
            });

            const { data } = await response.json();
        - lang: python
          label: Python
          source: |
            import requests

            order_id = 'ORDER_ID'
            response = requests.get(
                f'https://api.bizmori.com/api/v3/orders/{order_id}',
                headers={'Authorization': 'Bearer YOUR_API_KEY'}
            )
            data = response.json()['data']
components:
  schemas:
    WatermarkV1OrderResponse:
      type: object
      required:
        - data
      properties:
        data:
          $ref: '#/components/schemas/WatermarkV1Order'
    ErrorResponse:
      type: object
      properties:
        code:
          type: string
          description: Error code
    WatermarkV1Order:
      type: object
      description: Invisible watermark order created with the v3 API
      required:
        - orderId
        - status
        - processingDelayed
        - files
        - outputs
        - result
        - reports
      properties:
        orderId:
          type: string
          description: Order ID
        status:
          type: string
          enum:
            - pending
            - inProgress
            - complete
            - failed
            - expired
          description: >
            Order processing status


            * `pending` - Waiting for file uploads

            * `inProgress` - Processing

            * `complete` - Processing finished. For extract orders, read the
            outcome from `result`

            * `failed` - Processing failed, or files were not uploaded within 12
            hours

            * `expired` - The retention period has ended and files were deleted
        processingDelayed:
          type: boolean
          description: >-
            `true` when automatic retries are exhausted and the order is waiting
            for manual recovery. The order stays `inProgress`
        expiresAt:
          type: string
          format: date-time
          nullable: true
          description: >-
            When the order files are deleted. Downloads and reports return
            `ORDER_EXPIRED` afterwards
        files:
          type: array
          description: >-
            Uploaded input files, in request order. Extract orders return the
            original first and the file to inspect second
          items:
            $ref: '#/components/schemas/WatermarkV1UploadFile'
        outputs:
          type: array
          description: >-
            Embed outputs. One entry per watermark text. Empty for extract
            orders
          items:
            $ref: '#/components/schemas/WatermarkV1Output'
        result:
          $ref: '#/components/schemas/WatermarkV1DetectionResult'
        reports:
          type: array
          description: Reports requested for this order
          items:
            type: object
            required:
              - locale
              - status
            properties:
              locale:
                type: string
                enum:
                  - ko-KR
                  - en-US
                  - ja-JP
              status:
                type: string
                enum:
                  - queued
                  - processing
                  - completed
                  - failed
    WatermarkV1UploadFile:
      type: object
      required:
        - fileId
        - uploadUrl
      properties:
        fileId:
          type: string
          description: Input file ID
        uploadUrl:
          type: string
          format: uri
          nullable: true
          description: >
            Presigned `PUT` URL for uploading the file, valid for 900 seconds.
            Issued only while the order `status` is `pending`, the retention
            period has not ended, and the file is waiting for upload.

            It is `null` for files given by `originalFileUrl`, files already
            uploaded, orders that became `failed` after the 12-hour upload
            window, and expired orders.
    WatermarkV1Output:
      type: object
      required:
        - fileId
        - inputFileId
        - outputIndex
        - watermarkText
        - status
        - mediaKind
      properties:
        fileId:
          type: string
          description: >-
            Output file ID in `{inputFileId}-{ordinal}` format, from
            `outputs[].fileId`
        inputFileId:
          type: string
          description: ID of the input file this output was created from
        outputIndex:
          type: integer
          minimum: 0
          description: Position of the watermark text within the input file's `watermarks`
        watermarkText:
          type: string
          description: The embedded watermark text
        status:
          type: string
          enum:
            - pending
            - queued
            - processing
            - completed
            - failed
            - retry_required
          description: Processing status of this output
        mediaKind:
          type: string
          enum:
            - image
            - pdf
    WatermarkV1DetectionResult:
      type: object
      nullable: true
      description: >-
        Extract result summary. `null` for embed orders and until the result is
        ready. Contains only the fields below
      required:
        - detectionStatus
        - reportSupported
        - watermarkText
      additionalProperties: false
      properties:
        detectionStatus:
          type: string
          enum:
            - detected
            - not_detected
            - inconclusive
            - unsupported
            - error
          description: >
            * `detected` - A watermark was found

            * `not_detected` - The file was fully checked and no watermark was
            found

            * `inconclusive` - A candidate was found but did not meet the
            confidence threshold

            * `unsupported` - The input cannot be processed (credit refunded)

            * `error` - Detection failed. This is not the same as no watermark
            (credit refunded)
        reportSupported:
          type: boolean
          description: >-
            Whether a report can be created from this result. `false` for images
            captured from a PDF
        watermarkText:
          type: string
          nullable: true
          description: >
            Embedded text of the detected watermark. Returned only when
            `detectionStatus` is `detected`, your account embedded the
            watermark, and exactly one issuance record matches.

            Otherwise `null`, for example when another account embedded the
            watermark.
  responses:
    BadRequest:
      description: Bad request
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            code: VALIDATION_FAILED
    Unauthorized:
      description: Authentication failed
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            code: AUTH_NOT_AUTHENTICATED
    InternalError:
      description: Internal server error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            code: SERVER_INTERNAL_ERROR
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: >-
        Bearer API key for external client access. Live keys use the `sk_`
        prefix; test keys use the `sk_test_` prefix and support order-lifecycle
        testing with mock responses without processing or credit usage.

````

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