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

> ## Agent Instructions
> The OpenAPI document at /api-reference/openapi.yaml defines the target contract. Its x-reflections-availability field and each operation's availability notice identify supported test and live forms. Do not infer implementation from a schema or code sample. Live keys support account details, reads of the licenses the calling account holds as licensee or issued as talent (GET /v1/licenses?role=issuer), and GET /v1/generations?license=… for the state of outputs under such a license (summaries only: no prompt, reference, bytes or metadata). Live image checks, submissions and receipts are built but not activated: until activation, a live POST /v1/checks or /v1/generations returns 403 live_not_activated, which must not be retried. Discovery and JWKS are at the origin root (https://app.reflections.ai/.well-known/...), not under /v1.
> Three rules hold everywhere: a decision is never an error (deny and escalate are 200 responses, and a live check still evaluating is a 202 with status checking); generate nothing for a named talent without an allow; deliver nothing until the generation is allow.
> The sandbox accepts personal rk_test_ keys. Persist a separate Idempotency-Key and body for each logical /v1 POST; retry an unknown outcome with the same key and body. OAuth and Talent API MCP remain planned.

# Resolve an escalation

> **Planned contract — unavailable in test and live modes.** This operation is a protocol reference, not a callable endpoint. Start with the [working sandbox quickstart](/quickstart).

Allows or denies an escalated check, or releases or declines a held output, on a person's
decision. When the escalation's `reviewer` is `talent`, needs a mandate with
`review_outputs` for the talent. `decided_by` names that person, and the decision is
recorded on the talent's audit record with your account. An allow covers exactly the request that was escalated,
bound by its `request_digest`; for a held output, it releases those bytes and issues their
receipt. The platform receives `check.resolved`, `generation.released` or
`generation.denied`.

When a check invokes several talent, each escalated talent's side decides their own
escalation. The check resolves to `allow` only when every one allows, and to `deny` as
soon as one denies or expires; `check.resolved` is sent then, and the other open
escalations become `cancelled`.

Do not resolve escalations with an automated rule. To answer a kind of request the same
way every time, change the license, so the answer becomes a checked term that every check
applies.

Restricted keys need `escalations:write`.




## OpenAPI

````yaml /api-reference/openapi.yaml post /escalations/{escalation_id}/resolve
openapi: 3.1.0
info:
  title: Reflections Talent API
  version: '2026-10-15'
  summary: The license server for a person's name, likeness and voice in generative AI.
  description: >
    This document defines the target Talent API contract. Each operation
    declares its current

    test and live availability. Test mode serves a limited fictional sandbox.
    Live keys support

    account details and reading the caller's own licenses. The initial live
    image check,

    submission and receipt implementation is deployed, but requires separate
    live signing

    activation and production acceptance. Start at
    https://docs.reflections.ai/quickstart for test mode.


    The target API lets any product that can generate a real person check
    whether a use is licensed,

    verify the output it made, prove that verification to anyone downstream,
    report usage, and

    honor revocations.


    Protected requests use a secret key in the `Authorization` header. The
    target contract defines test keys

    (`rk_test_…`) and live keys (`rk_live_…`) use the same base URL; the key
    decides the mode.


    A decision is never an error. `deny` and `escalate` are `200` responses that
    carry a decision.

    Errors use RFC 9457 problem details.
  contact:
    name: Reflections developer support
    url: https://docs.reflections.ai/production/support
    email: developers@reflections.ai
servers:
  - url: https://app.reflections.ai/v1
    description: >-
      Fictional test sandbox and conditional live support; availability and
      activation are separate
security:
  - SecretKey: []
tags:
  - name: Account
    description: The account that owns the calling key.
  - name: Talent
    description: >-
      People whose name, likeness and voice are protected and licensed through
      Reflections.
  - name: Facets
    description: >-
      The parts of a talent's identity a license can cover, such as a voice or a
      likeness.
  - name: Resolutions
    description: Find which talent a prompt, image or voice sample invokes.
  - name: Licenses
    description: Signed licenses and their revisions.
  - name: License requests
    description: Ask a talent for a new license or a wider one.
  - name: Connections
    description: A licensee's permission for a platform to use its licenses.
  - name: Files
    description: References and outputs uploaded for checks and generations.
  - name: Checks
    description: Decide whether a use may proceed, before anything is generated.
  - name: Generations
    description: Check an output against the license its check relied on.
  - name: Sessions
    description: Authorize live voice and video with short-lived tokens and sampled checks.
  - name: Receipts
    description: Signed, portable proof of a decision.
  - name: Verifications
    description: Verify a file, manifest or receipt.
  - name: Revocations
    description: Every narrowing of consent, and the platform's acknowledgement of it.
  - name: Usage records
    description: Report usage for settlement and audit.
  - name: Statements
    description: Monthly amounts owed under a license, reconciled against observed usage.
  - name: Mandates
    description: A representative's authority to act for a talent, and its powers.
  - name: Escalations
    description: >-
      The review queue. Checks and held outputs waiting for the talent's side to
      decide.
  - name: License drafts
    description: Terms prepared for a talent's signature. Only a person signs.
  - name: Webhook endpoints
    description: Where Reflections sends events.
  - name: Events
    description: The record of everything that happened to your objects.
  - name: Test helpers
    description: Act as a talent or reviewer in test mode.
  - name: Discovery
    description: The public discovery document and signing keys. Neither needs a key.
  - name: OAuth
    description: >
      Authorization for connections, MCP clients and RSL clients, and the
      metadata that describes it.
paths:
  /escalations/{escalation_id}/resolve:
    post:
      tags:
        - Escalations
      summary: Resolve an escalation
      description: >
        **Planned contract — unavailable in test and live modes.** This
        operation is a protocol reference, not a callable endpoint. Start with
        the [working sandbox quickstart](/quickstart).


        Allows or denies an escalated check, or releases or declines a held
        output, on a person's

        decision. When the escalation's `reviewer` is `talent`, needs a mandate
        with

        `review_outputs` for the talent. `decided_by` names that person, and the
        decision is

        recorded on the talent's audit record with your account. An allow covers
        exactly the request that was escalated,

        bound by its `request_digest`; for a held output, it releases those
        bytes and issues their

        receipt. The platform receives `check.resolved`, `generation.released`
        or

        `generation.denied`.


        When a check invokes several talent, each escalated talent's side
        decides their own

        escalation. The check resolves to `allow` only when every one allows,
        and to `deny` as

        soon as one denies or expires; `check.resolved` is sent then, and the
        other open

        escalations become `cancelled`.


        Do not resolve escalations with an automated rule. To answer a kind of
        request the same

        way every time, change the license, so the answer becomes a checked term
        that every check

        applies.


        Restricted keys need `escalations:write`.
      operationId: resolveEscalation
      parameters:
        - $ref: '#/components/parameters/ReflectionsVersion'
        - $ref: '#/components/parameters/IdempotencyKey'
        - $ref: '#/components/parameters/EscalationId'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/EscalationResolve'
            examples:
              allow_check:
                summary: Allow an escalated check
                value:
                  decision: allow
                  note: Fine as long as the cups hold coffee.
                  decided_by:
                    name: Lena Brooks
              decline_held_output:
                summary: Decline a held output
                value:
                  decision: deny
                  note: Another brand's logo shows on her jacket.
                  decided_by:
                    name: Lena Brooks
      responses:
        '200':
          description: The resolved escalation.
          headers:
            Request-Id:
              $ref: '#/components/headers/RequestId'
            RateLimit:
              $ref: '#/components/headers/RateLimit'
            RateLimit-Policy:
              $ref: '#/components/headers/RateLimitPolicy'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/EscalationDetail'
              examples:
                allowed:
                  $ref: '#/components/examples/EscalationAllowed'
                declined:
                  summary: A held output declined by the talent's manager
                  value:
                    id: esc_czjcwnr6p65hakf55easq1aqa6
                    object: escalation
                    livemode: true
                    reason: release_review
                    reviewer: talent
                    status: denied
                    expires_at: '2026-10-24T18:08:53Z'
                    resolved_at: '2026-10-17T19:44:30Z'
                    note: Another brand's logo shows on her jacket.
                    subject:
                      object: generation
                      id: gen_estxjc1sw4d0fbyra0jfd7x184
                    talent: tal_9t0wxyhk5zba2q8v1m3n7p4r6s
                    license: lic_k5zba2q8v1m3n7p4r6s9t0wxyh
                    license_revision: lrv_p4r6s9t0wxyhk5zba2q8v1m3n7
                    licensee: acct_2q8v1m3n7p4r6s9t0wxyhk5zba
                    licensee_name: Ridgeline
                    platform: acct_7p4r6s9t0wxyhk5zba2q8v1m3n
                    platform_name: Northlight
                    use:
                      modality: image
                      kind: depiction
                      purpose: advertising
                      commercial: true
                      channels:
                        - social
                        - web
                      territories:
                        - US
                        - CA
                    inputs:
                      - role: prompt
                        text: >-
                          Maya Okafor holding our new trail shoe on a rocky
                          ridge at sunrise
                      - role: reference
                        sha256: >-
                          5e0b7c2d9f4a1e6b3c8d0f2a4e6b8c0d2f4a6e8b0c2d4f6a8e0b2c4d6f8a0b2c
                        media_type: image/jpeg
                        url: >-
                          https://files.reflections.ai/esc_czjcwnr6p65hakf55easq1aqa6/inputs/1?expires=1792267170&signature=7DI25dYadMimwXWoRAuqBrI_2Fy6zpBW7vDSvnwbqr0
                    reasons: []
                    findings:
                      - term: >-
                          license:lic_k5zba2q8v1m3n7p4r6s9t0wxyh/terms.requiredAttributes
                        attribute: identity.samePerson
                        result: preserved
                      - term: >-
                          license:lic_k5zba2q8v1m3n7p4r6s9t0wxyh/terms.adjustments
                        attribute: appearance.wardrobe
                        result: preserved
                      - term: >-
                          license:lic_k5zba2q8v1m3n7p4r6s9t0wxyh/terms.neverExtras
                        rule: Do not show alcohol or tobacco.
                        result: preserved
                    artifact:
                      sha256: >-
                        85ccdc0c8087515ce6685fb5a44f0ac2f6e628919fa9b9b0256611712e973342
                      media_type: image/png
                      url: >-
                        https://files.reflections.ai/esc_czjcwnr6p65hakf55easq1aqa6/artifact?expires=1792267170&signature=q1fpBpzR8R0ouCmOA8wxr0hf6OFOT2qyMWmi7qf_wOQ
                    request_digest: >-
                      sha256:bf94817766d56d92211d12f5ff51a3dc1a6d5cb4be2877417b08251fe38c386a
                    review_url: null
                    decision: deny
                    decided_by:
                      party: representative
                      account: acct_6m8n0p2q4r6s8t0v2w4x6y8z0b
                      name: Lena Brooks
                    created_at: '2026-10-17T18:08:53Z'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/MandateRequired'
        '404':
          $ref: '#/components/responses/NotFound'
        '409':
          $ref: '#/components/responses/Conflict'
        '422':
          $ref: '#/components/responses/Unprocessable'
        '429':
          $ref: '#/components/responses/RateLimited'
        '500':
          $ref: '#/components/responses/ServerError'
        '503':
          $ref: '#/components/responses/Unavailable'
      security:
        - SecretKey:
            - escalations:write
      x-codeSamples:
        - lang: bash
          label: cURL
          source: >
            # Set a unique key once per new action; persist it and reuse it for
            every retry.

            : "${REFLECTIONS_KEY:?Set REFLECTIONS_KEY before running this
            example}"

            : "${REFLECTIONS_RESOLVE_ESCALATION_IDEMPOTENCY_KEY:?Set
            REFLECTIONS_RESOLVE_ESCALATION_IDEMPOTENCY_KEY before running this
            example}"


            curl --fail-with-body --max-time 30 -X POST
            'https://app.reflections.ai/v1/escalations/esc_t0wxyhk5zba2q8v1m3n7p4r6s9/resolve'
            \
              -H "Authorization: Bearer $REFLECTIONS_KEY" \
              -H "Reflections-Version: 2026-10-15" \
              -H "Idempotency-Key: $REFLECTIONS_RESOLVE_ESCALATION_IDEMPOTENCY_KEY" \
              -H "Content-Type: application/json" \
              --data-raw '{
              "decision": "allow",
              "note": "Fine as long as the cups hold coffee.",
              "decided_by": {
                "name": "Lena Brooks"
              }
            }'
        - lang: typescript
          label: TypeScript
          source: >
            import { env, exit } from "node:process";


            // Set a unique key once per new action; persist it and reuse it for
            every retry.

            const apiKey = env.REFLECTIONS_KEY;

            if (!apiKey) throw new Error("Set REFLECTIONS_KEY before running
            this example");

            const idempotencyKey =
            env.REFLECTIONS_RESOLVE_ESCALATION_IDEMPOTENCY_KEY;

            if (!idempotencyKey) throw new Error("Set
            REFLECTIONS_RESOLVE_ESCALATION_IDEMPOTENCY_KEY before running this
            example");


            const response = await
            fetch("https://app.reflections.ai/v1/escalations/esc_t0wxyhk5zba2q8v1m3n7p4r6s9/resolve",
            {
              method: "POST",
              headers: {
                Authorization: `Bearer ${apiKey}`,
                "Reflections-Version": "2026-10-15",
                "Idempotency-Key": idempotencyKey,
                "Content-Type": "application/json",
              },
              body: JSON.stringify({
                "decision": "allow",
                "note": "Fine as long as the cups hold coffee.",
                "decided_by": {
                  "name": "Lena Brooks"
                }
              }),
              signal: AbortSignal.timeout(30_000),
            });

            const responseBody = await response.text();

            if (!response.ok) {
              console.error(`HTTP ${response.status}: ${responseBody}`);
              exit(1);
            }

            console.log(responseBody);
        - lang: python
          label: Python
          source: >
            import json

            import os

            from urllib.error import HTTPError

            from urllib.request import Request, urlopen


            # Set a unique key once per new action; persist it and reuse it for
            every retry.

            apiKey = os.environ["REFLECTIONS_KEY"]

            if not apiKey:
                raise ValueError("Set REFLECTIONS_KEY before running this example")
            idempotencyKey =
            os.environ["REFLECTIONS_RESOLVE_ESCALATION_IDEMPOTENCY_KEY"]

            if not idempotencyKey:
                raise ValueError("Set REFLECTIONS_RESOLVE_ESCALATION_IDEMPOTENCY_KEY before running this example")

            headers = {
                "Authorization": f"Bearer {apiKey}",
                "Reflections-Version": "2026-10-15",
                "Idempotency-Key": idempotencyKey,
                "Content-Type": "application/json",
            }

            data = json.dumps({
                "decision": "allow",
                "note": "Fine as long as the cups hold coffee.",
                "decided_by": {"name": "Lena Brooks"},
            }).encode("utf-8")

            request =
            Request("https://app.reflections.ai/v1/escalations/esc_t0wxyhk5zba2q8v1m3n7p4r6s9/resolve",
                              method="POST", headers=headers, data=data)
            try:
                with urlopen(request, timeout=30) as response:
                    print(response.read().decode("utf-8"))
            except HTTPError as error:
                error_body = error.read().decode("utf-8")
                raise RuntimeError(f"HTTP {error.code}: {error_body}") from error
        - lang: go
          label: Go
          source: |
            package main

            import (
                "fmt"
                "io"
                "net/http"
                "os"
                "strings"
                "time"
            )

            func main() {
                // Set a unique key once per new action; persist it and reuse it for every retry.
                apiKey := os.Getenv("REFLECTIONS_KEY")
                if apiKey == "" {
                    panic("Set REFLECTIONS_KEY before running this example")
                }
                idempotencyKey := os.Getenv("REFLECTIONS_RESOLVE_ESCALATION_IDEMPOTENCY_KEY")
                if idempotencyKey == "" {
                    panic("Set REFLECTIONS_RESOLVE_ESCALATION_IDEMPOTENCY_KEY before running this example")
                }

                body := strings.NewReader(`{
                  "decision": "allow",
                  "note": "Fine as long as the cups hold coffee.",
                  "decided_by": {
                    "name": "Lena Brooks"
                  }
                }`)
                request, err := http.NewRequest("POST", "https://app.reflections.ai/v1/escalations/esc_t0wxyhk5zba2q8v1m3n7p4r6s9/resolve", body)
                if err != nil {
                    panic(err)
                }
                request.Header.Set("Authorization", "Bearer " + apiKey)
                request.Header.Set("Reflections-Version", "2026-10-15")
                request.Header.Set("Idempotency-Key", idempotencyKey)
                request.Header.Set("Content-Type", "application/json")
                client := &http.Client{Timeout: 30 * time.Second}
                response, err := client.Do(request)
                if err != nil {
                    panic(err)
                }
                defer response.Body.Close()
                responseBody, err := io.ReadAll(response.Body)
                if err != nil {
                    panic(err)
                }
                if response.StatusCode < 200 || response.StatusCode >= 300 {
                    panic(fmt.Sprintf("HTTP %d: %s", response.StatusCode, responseBody))
                }
                fmt.Print(string(responseBody))
            }
components:
  parameters:
    ReflectionsVersion:
      name: Reflections-Version
      in: header
      required: false
      description: >-
        The dated API version. Defaults to the version your account is pinned
        to.
      schema:
        type: string
        example: '2026-10-15'
    IdempotencyKey:
      name: Idempotency-Key
      in: header
      required: false
      description: >
        A unique key for this operation, up to 255 characters. In test mode,
        POST keys are scoped

        to your account and mode and bind the endpoint and body for 24 hours. A
        different endpoint

        or body with the same key is refused.


        Initial live check and generation creation require a nonempty key. Each
        operation has a

        separate account-scoped namespace; retain the same API key, body and
        idempotency key for

        retries within 24 hours of creation. A pending check returns `202` with
        `status: "checking"`.

        Completed checks replay their sealed response; successful generation
        POSTs replay the

        original accepted `202`, so use GET for current state. Live verification
        is a read-only

        query that returns a fresh verification ID on each call, without exact
        response caching.


        The broader delegated-account contract also scopes keys to
        `Reflections-Account`;

        delegated requests and the other planned live POST operations remain
        unsupported.
      schema:
        type: string
        maxLength: 255
    EscalationId:
      name: escalation_id
      in: path
      required: true
      description: The escalation's ID.
      example: esc_t0wxyhk5zba2q8v1m3n7p4r6s9
      schema:
        type: string
        pattern: ^esc_[0-9a-hjkmnp-tv-z]{26}$
  schemas:
    EscalationResolve:
      type: object
      required:
        - decision
        - decided_by
      properties:
        decision:
          type: string
          enum:
            - allow
            - deny
          description: For a held output, `allow` releases it and `deny` declines it.
        note:
          type: string
          maxLength: 500
          description: Shown to the platform as `escalation.note`.
        decided_by:
          type: object
          description: >-
            The person who made the decision. Recorded on the talent's audit
            record.
          required:
            - name
          properties:
            name:
              type: string
              maxLength: 200
              description: >
                The full name of the person who decided, as it appears on the
                talent's audit record.
    EscalationDetail:
      title: Escalation
      description: An escalation with the request, use and findings a reviewer needs.
      allOf:
        - $ref: '#/components/schemas/Escalation'
        - type: object
          required:
            - object
            - livemode
            - subject
            - talent
            - license
            - licensee
            - platform
            - use
            - request_digest
            - created_at
          properties:
            object:
              type: string
              const: escalation
              description: Always `escalation`.
            livemode:
              type: boolean
              description: '`true` in live mode, `false` in test mode.'
            subject:
              type: object
              description: What waits on the decision.
              required:
                - object
                - id
              properties:
                object:
                  type: string
                  enum:
                    - check
                    - generation
                  description: >-
                    `check` for an escalated check, `generation` for a held
                    output.
                id:
                  type: string
                  description: The check (`chk_…`) or generation (`gen_…`) ID.
            talent:
              type: string
              pattern: ^tal_[0-9a-hjkmnp-tv-z]{26}$
              description: >
                The talent whose side decides. When a check escalates for
                several talent, each has

                their own escalation.
            license:
              type: string
              pattern: ^lic_[0-9a-hjkmnp-tv-z]{26}$
              description: The license the request was checked under.
            license_revision:
              type: string
              pattern: ^lrv_[0-9a-hjkmnp-tv-z]{26}$
              description: The revision of `license` the request was checked against.
            licensee:
              type: string
              pattern: ^acct_[0-9a-hjkmnp-tv-z]{26}$
              description: The account that holds `license`.
            licensee_name:
              type: string
              description: The licensee's account name.
            platform:
              type: string
              pattern: ^acct_[0-9a-hjkmnp-tv-z]{26}$
              description: The platform that ran the check or submitted the output.
            platform_name:
              type: string
              description: The platform's account name.
            use:
              $ref: '#/components/schemas/Use'
              description: The use the platform asked for on the check.
            inputs:
              type: array
              description: >
                The request as the platform sent it. Media inputs carry a `url`
                that opens for 15

                minutes. Text sent withheld appears as `role` and `sha256` only.
              items:
                $ref: '#/components/schemas/Input'
            reasons:
              type: array
              description: What raised the question, with the talent's term.
              items:
                $ref: '#/components/schemas/Reason'
            findings:
              type: array
              description: For a held output, what Reflections recorded on its bytes.
              items:
                $ref: '#/components/schemas/Finding'
            artifact:
              type:
                - object
                - 'null'
              description: For a held output, the clean bytes to review.
              properties:
                sha256:
                  $ref: '#/components/schemas/Sha256Hex'
                  description: >
                    SHA-256 of the held output's bytes, as on the generation's
                    `artifact`.
                media_type:
                  type: string
                  description: The output's media type, such as `image/png`.
                url:
                  type: string
                  format: uri
                  description: Opens for 15 minutes.
            request_digest:
              $ref: '#/components/schemas/Digest'
              description: >
                The `request_digest` of the check. Allowing an escalated check
                covers exactly this

                request.
            review_url:
              type:
                - string
                - 'null'
              format: uri
              description: >-
                The Talent Portal page where a person with authority reviews it
                and decides. Present while `open`.
            decision:
              type:
                - string
                - 'null'
              enum:
                - allow
                - deny
                - null
              description: >
                The decision a person recorded, `allow` or `deny`. `null` until
                one is recorded.
            decided_by:
              type:
                - object
                - 'null'
              description: Who resolved it.
              properties:
                party:
                  type: string
                  enum:
                    - talent
                    - representative
                    - reflections
                  description: >
                    `talent` when the talent decided, `representative` when a
                    representative

                    recorded the decision, `reflections` for an escalation under
                    a platform license.
                account:
                  type:
                    - string
                    - 'null'
                  pattern: ^acct_[0-9a-hjkmnp-tv-z]{26}$
                  description: >
                    The representative's account. `null` when the talent or
                    Reflections decided.
                name:
                  type: string
                  description: >-
                    The person who decided, as recorded on the talent's audit
                    record.
            created_at:
              type: string
              format: date-time
              description: When the check escalated or the output was held.
    Escalation:
      type: object
      required:
        - id
        - reason
        - reviewer
        - status
        - expires_at
      properties:
        id:
          type: string
          pattern: ^esc_[0-9a-hjkmnp-tv-z]{26}$
          description: The escalation's ID, `esc_` followed by 26 characters.
        reason:
          type: string
          enum:
            - judgment
            - unverifiable
            - evaluation_unavailable
            - release_review
          description: >
            `judgment`: a rule needs a person to read it. `unverifiable`: a
            protected attribute

            could not be confirmed. `evaluation_unavailable`: the check could
            not finish.

            `release_review`: every output under this license is released by a
            person.
        reviewer:
          type: string
          enum:
            - talent
            - representative
            - reflections
          description: >
            `talent`: the talent, or a representative whose mandate has
            `review_outputs`.

            `representative`: only the talent's representatives. `reflections`:
            Reflections trust

            and safety, under a platform license.
        status:
          type: string
          enum:
            - open
            - allowed
            - denied
            - expired
            - cancelled
          description: >
            `open` until it closes: `allowed` or `denied` by the reviewer,
            `expired` at

            `expires_at`, or `cancelled` when you cancel the check, withdraw the
            output, or another

            talent's escalation decides the check.
        expires_at:
          type: string
          format: date-time
          description: >
            When an unanswered escalation becomes `deny`: 7 days after it opens,
            or the license's

            shorter `escalation_window`.
        resolved_at:
          type:
            - string
            - 'null'
          format: date-time
          description: >-
            When the escalation was decided, expired or cancelled. Null while
            `open`.
        note:
          type:
            - string
            - 'null'
          maxLength: 500
          description: The reviewer's note, if they wrote one.
    Use:
      type: object
      required:
        - modality
        - kind
        - purpose
        - commercial
      properties:
        modality:
          $ref: '#/components/schemas/Modality'
          description: What will be generated.
        kind:
          $ref: '#/components/schemas/UseKind'
          description: How the talent appears in the output.
        purpose:
          $ref: '#/components/schemas/Purpose'
          description: What the output is for.
        commercial:
          type: boolean
          description: >-
            Whether anyone earns money from the output, including through
            advertising.
        channels:
          type: array
          items:
            $ref: '#/components/schemas/Channel'
          maxItems: 20
          description: Required when `commercial` is true.
        territories:
          type: array
          items:
            $ref: '#/components/schemas/Territory'
          maxItems: 50
          description: Required when `commercial` is true.
    Input:
      type: object
      description: >
        One part of the request a model receives, in order. Send text inline;
        send media as a

        file ID, or as `sha256` with a `url` Reflections can fetch.
      required:
        - role
      properties:
        role:
          type: string
          enum:
            - prompt
            - system
            - negative_prompt
            - rewritten_prompt
            - script
            - reference
            - voice_sample
            - mask
            - context
          description: >
            `prompt`: the user's words. `system`: instructions you add.
            `rewritten_prompt`: your

            expansion of the prompt, if the model receives that instead.
            `script`: words to be

            spoken. `reference`, `voice_sample`, `mask`: media the model
            receives. `context`:

            conversation history the model receives.
        text:
          type: string
          maxLength: 32000
          description: >-
            The text, for every role except `reference`, `voice_sample` and
            `mask`.
        file:
          type: string
          pattern: ^file_[0-9a-hjkmnp-tv-z]{26}$
          description: >
            A file ID from `POST /v1/files`, for a `reference`, `voice_sample`
            or `mask` input.
        url:
          type: string
          format: uri
          description: >
            A URL Reflections can fetch the media from. Send `sha256` and
            `media_type` with it.
        sha256:
          $ref: '#/components/schemas/Sha256Hex'
          description: >
            SHA-256 of the bytes, in hex: of the media at `url`, or of a text
            input's UTF-8 bytes

            when `prompt_handling.mode` is `withheld`.
        media_type:
          type: string
          example: image/png
          description: >
            The MIME type of the media at `url`, or `text/plain` for a withheld
            text input.
    Reason:
      type: object
      required:
        - code
        - stage
        - sentence
      properties:
        code:
          $ref: '#/components/schemas/ReasonCode'
          description: A stable reason code. Branch on it.
        stage:
          type: string
          enum:
            - check
            - generation
            - session
          description: 'Where it was decided: `check`, `generation` or `session`.'
        talent:
          type: string
          pattern: ^tal_[0-9a-hjkmnp-tv-z]{26}$
          description: The talent the reason concerns.
        term:
          $ref: '#/components/schemas/Address'
          description: >-
            The license term or standing rule the reason rests on, as an
            address.
        sentence:
          type: string
          description: >-
            The reason in the license's own words. Show it to your user as
            written.
    Finding:
      type: object
      required:
        - term
        - result
      properties:
        term:
          $ref: '#/components/schemas/Address'
          description: The term's address, such as `license:lic_…/terms.neverExtras`.
        attribute:
          type: string
          description: A protected attribute, such as `identity.samePerson`.
        rule:
          type: string
          description: A rule the talent wrote, as written.
        result:
          type: string
          enum:
            - preserved
            - violated
            - unchecked
          description: >-
            `unchecked`: the check could not read this rule. Talent-written
            rules that are unchecked are delivered and recorded; protected
            attributes never are.
        detail:
          type: string
          description: What the check saw, for a `violated` result.
    Sha256Hex:
      type: string
      description: A SHA-256 digest of bytes, as 64 lowercase hex characters.
      pattern: ^[0-9a-f]{64}$
    Digest:
      type: string
      description: A SHA-256 digest, `sha256:` followed by 64 lowercase hex characters.
      pattern: ^sha256:[0-9a-f]{64}$
    Problem:
      type: object
      description: An RFC 9457 problem detail. Every error has this shape.
      required:
        - type
        - title
        - status
        - code
        - request_id
      properties:
        type:
          type: string
          format: uri
          description: A URL for this error, under `https://docs.reflections.ai/errors/`.
        title:
          type: string
          description: A short summary of the error.
        status:
          type: integer
          description: The HTTP status.
        detail:
          type: string
          description: What happened in this request.
        code:
          $ref: '#/components/schemas/ErrorCode'
          description: The stable error code. Branch on it, then on `status`.
        param:
          type: string
          description: The field at fault, as a path such as `use.territories[1]`.
        request_id:
          type: string
          description: >
            `req_…`, the same value as the `Request-Id` header. Include it when
            you contact support.
        doc_url:
          type: string
          format: uri
          description: A link to the documentation for this error.
    Modality:
      type: string
      description: >-
        What will be generated. `speech` is a voice speaking words; `audio` is
        any other sound.
      enum:
        - image
        - video
        - speech
        - audio
        - text
    UseKind:
      type: string
      description: >
        How the talent appears. `depiction`: shown or heard. `impersonation`:
        speaks or writes as

        the talent. `endorsement`: implies the talent approves something.
        `reference`: talked

        about, without synthesis; needs no license.
      enum:
        - depiction
        - impersonation
        - endorsement
        - reference
    Purpose:
      type: string
      enum:
        - advertising
        - branded_content
        - entertainment
        - editorial
        - personal
        - education
        - political
    Channel:
      type: string
      description: Where the output will appear.
      enum:
        - social
        - web
        - in_app
        - streaming
        - tv
        - cinema
        - out_of_home
        - print
        - audio
        - email
        - retail
        - games
        - private
    Territory:
      type: string
      description: An ISO 3166-1 alpha-2 country code, or `WW` for worldwide.
      pattern: ^([A-Z]{2})$
      example: US
    ReasonCode:
      type: string
      description: >-
        Why a use was denied or escalated, or a session terminated. See the
        reason code catalog.
      enum:
        - no_license
        - license_pending_acceptance
        - license_revoked
        - license_suspended
        - window_not_started
        - window_ended
        - terms_unreadable
        - account_not_licensee
        - material_unavailable
        - adjustment_not_licensed
        - facet_not_licensed
        - kind_not_licensed
        - modality_not_licensed
        - purpose_not_licensed
        - channel_not_licensed
        - territory_not_licensed
        - commercial_use_not_licensed
        - platform_not_licensed
        - delivery_limit_reached
        - monthly_limit_reached
        - talent_prohibits
        - prohibited_appearance_change
        - prohibited_endorsement
        - prohibited_custom_term
        - identity_not_preserved
        - prohibited_speech
        - prohibited_motion
        - narration_mismatch
        - voice_rule
        - unsupported_rule
        - attribute_unverifiable
        - output_unverifiable
        - ambiguous_talent
        - review_required
        - unverifiable_request
        - evaluation_unavailable
        - authority_changed
        - provenance_failed
        - hold_expired
        - review_declined
        - review_expired
        - session_not_permitted
        - renewal_missed
        - sample_missed
    Address:
      type: string
      description: >
        Where a reason or finding rests, written as an address:
        `license:<id>/terms.<key>` for a

        term, `talent:<id>` for a talent's standing boundary.
      example: license:lic_k5zba2q8v1m3n7p4r6s9t0wxyh/terms.channels
    ErrorCode:
      type: string
      description: A stable error code. See the error code catalog.
      enum:
        - invalid_request
        - parameter_missing
        - parameter_invalid
        - unsupported_modality
        - unsupported_media_type
        - media_unreadable
        - version_unsupported
        - authorization_code_invalid
        - authentication_required
        - invalid_api_key
        - token_invalid
        - insufficient_scope
        - account_not_connected
        - mandate_required
        - livemode_mismatch
        - live_not_activated
        - platform_not_permitted
        - resource_not_found
        - idempotency_key_in_use
        - generation_already_submitted
        - authorization_consumed
        - check_not_allowed
        - check_expired
        - escalation_closed
        - license_draft_closed
        - invalid_state_transition
        - session_not_active
        - payload_too_large
        - idempotency_key_reused
        - artifact_digest_mismatch
        - rate_limited
        - internal_error
        - service_unavailable
        - evaluation_timeout
  headers:
    RequestId:
      description: Identifies this request. Include it when you contact support.
      schema:
        type: string
        example: req_8f2k4m6p8r0t2v4x6z8b0d2f4h
    RateLimit:
      description: >-
        Remaining quota and seconds until it resets, as IETF RateLimit header
        fields.
      schema:
        type: string
        example: '"checks";r=184;t=1'
    RateLimitPolicy:
      description: The policy the RateLimit field reports against.
      schema:
        type: string
        example: '"checks";q=200;w=1'
    RetryAfter:
      description: Seconds to wait before retrying.
      schema:
        type: integer
  examples:
    EscalationAllowed:
      summary: Allowed by the talent's manager
      value:
        id: esc_t0wxyhk5zba2q8v1m3n7p4r6s9
        object: escalation
        livemode: true
        reason: judgment
        reviewer: talent
        status: allowed
        expires_at: '2026-10-24T18:04:00Z'
        resolved_at: '2026-10-17T21:30:00Z'
        note: Fine as long as the cups hold coffee.
        subject:
          object: check
          id: chk_r6s9t0wxyhk5zba2q8v1m3n7p4
        talent: tal_9t0wxyhk5zba2q8v1m3n7p4r6s
        license: lic_k5zba2q8v1m3n7p4r6s9t0wxyh
        license_revision: lrv_p4r6s9t0wxyhk5zba2q8v1m3n7
        licensee: acct_2q8v1m3n7p4r6s9t0wxyhk5zba
        licensee_name: Ridgeline
        platform: acct_7p4r6s9t0wxyhk5zba2q8v1m3n
        platform_name: Northlight
        use:
          modality: image
          kind: depiction
          purpose: advertising
          commercial: true
          channels:
            - social
          territories:
            - US
        inputs:
          - role: prompt
            text: >-
              Maya Okafor at a trailhead café with two friends, paper cups on
              the table, morning light
        reasons:
          - code: prohibited_custom_term
            stage: check
            talent: tal_9t0wxyhk5zba2q8v1m3n7p4r6s
            term: license:lic_k5zba2q8v1m3n7p4r6s9t0wxyh/terms.neverExtras
            sentence: Do not show alcohol or tobacco.
        findings: []
        artifact: null
        request_digest: >-
          sha256:c3e5a7b9d1f3c5e7a9b1d3f5c7e9a1b3d5f7c9e1a3b5d7f9c1e3a5b7d9f1c3e5
        review_url: null
        decision: allow
        decided_by:
          party: representative
          account: acct_6m8n0p2q4r6s8t0v2w4x6y8z0b
          name: Lena Brooks
        created_at: '2026-10-17T18:04:00Z'
  responses:
    BadRequest:
      description: The request was malformed or a parameter was invalid.
      headers:
        Request-Id:
          $ref: '#/components/headers/RequestId'
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
          example:
            type: https://docs.reflections.ai/errors/parameter_invalid
            title: A parameter is invalid
            status: 400
            code: parameter_invalid
            param: use.territories[1]
            detail: '"UK" is not an ISO 3166-1 alpha-2 code. Use "GB".'
            request_id: req_8f2k4m6p8r0t2v4x6z8b0d2f4h
    Unauthorized:
      description: The key is missing, unknown or revoked.
      headers:
        Request-Id:
          $ref: '#/components/headers/RequestId'
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
          example:
            type: https://docs.reflections.ai/errors/invalid_api_key
            title: The API key is not valid
            status: 401
            code: invalid_api_key
            request_id: req_8f2k4m6p8r0t2v4x6z8b0d2f4h
    MandateRequired:
      description: >-
        Your account holds no active mandate for this talent with the power this
        call needs.
      headers:
        Request-Id:
          $ref: '#/components/headers/RequestId'
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
          example:
            type: https://docs.reflections.ai/errors/mandate_required
            title: No mandate with the needed power
            status: 403
            code: mandate_required
            detail: >-
              Your mandate for tal_9t0wxyhk5zba2q8v1m3n7p4r6s does not include
              review_outputs.
            request_id: req_8f2k4m6p8r0t2v4x6z8b0d2f4h
    NotFound:
      description: No such object for this account.
      headers:
        Request-Id:
          $ref: '#/components/headers/RequestId'
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
          example:
            type: https://docs.reflections.ai/errors/resource_not_found
            title: No such object
            status: 404
            code: resource_not_found
            request_id: req_8f2k4m6p8r0t2v4x6z8b0d2f4h
    Conflict:
      description: >-
        The request conflicts with the object's state or with a request still
        running.
      headers:
        Request-Id:
          $ref: '#/components/headers/RequestId'
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
          example:
            type: https://docs.reflections.ai/errors/idempotency_key_in_use
            title: A request with this key is still running
            status: 409
            code: idempotency_key_in_use
            detail: Retry with the same key after a short wait.
            request_id: req_8f2k4m6p8r0t2v4x6z8b0d2f4h
    Unprocessable:
      description: The request is well formed but cannot be applied.
      headers:
        Request-Id:
          $ref: '#/components/headers/RequestId'
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
          example:
            type: https://docs.reflections.ai/errors/idempotency_key_reused
            title: This key was used for a different request
            status: 422
            code: idempotency_key_reused
            request_id: req_8f2k4m6p8r0t2v4x6z8b0d2f4h
    RateLimited:
      description: Too many requests.
      headers:
        Request-Id:
          $ref: '#/components/headers/RequestId'
        Retry-After:
          $ref: '#/components/headers/RetryAfter'
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
          example:
            type: https://docs.reflections.ai/errors/rate_limited
            title: Too many requests
            status: 429
            code: rate_limited
            request_id: req_8f2k4m6p8r0t2v4x6z8b0d2f4h
    ServerError:
      description: Something failed on our side. Retry with the same idempotency key.
      headers:
        Request-Id:
          $ref: '#/components/headers/RequestId'
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
    Unavailable:
      description: >
        Reflections is temporarily unavailable. Do not generate a named talent
        without a valid

        authorization. Retry with the same idempotency key.
      headers:
        Request-Id:
          $ref: '#/components/headers/RequestId'
        Retry-After:
          $ref: '#/components/headers/RetryAfter'
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
  securitySchemes:
    SecretKey:
      type: http
      scheme: bearer
      description: >
        Your secret key, `rk_test_…` or `rk_live_…`, sent as `Authorization:
        Bearer <key>`. Keep it

        on your server. Restricted keys carry only the scopes you give them.

````

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