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

# Obligations

> Every obligation type, the fields it uses, and how to meet it.

<Note>
  Protocol reference. The sandbox can return example obligations for fictional licenses.
  Production delivery, deletion, usage reporting and provider enforcement described below are
  not supplied or certified by the sandbox.
  Start with the [runnable quickstart](/quickstart) and [sandbox support matrix](/sandbox).
</Note>

An `allow` is conditional. **Obligations** say what must happen for the use to stay licensed: pass
rules to the model, submit outputs, hold them for release, label them, embed the receipt, keep
material out of training, delete it, report usage. Each obligation is typed, so your code can meet
it without reading prose.

## Where obligations appear

| On | Means |
| - | - |
| A check | What the use requires, from the moment you generate |
| A generation | What delivering this output requires |
| A session | What the live session requires |
| A receipt | The obligations recorded with the decision |
| Licensed material | What to do with reference material you downloaded |
| A posture rule | What a use the talent declared `allowed` must do |

Every obligation has a `type` and only the fields listed for that type. Any obligation can carry
`term`, the address of the license term it comes from, such as
`license:lic_k5zba2q8v1m3n7p4r6s9t0wxyh/terms.neverExtras`.

## Unknown types are unmet

The obligation types are a registry, extended by a published change to the
[Talent License Protocol](/standard/obligations-registry). If a response carries a `type` your code
does not know, treat it as unmet: do not generate, and do not deliver. Never skip an obligation
because you do not recognize it.

<CodeGroup>
  ```typescript TypeScript theme={null}
  const KNOWN = new Set([
    "generation_check", "hold_until_release", "draft_watermark", "generation_instructions",
    "disclosure", "attribution", "c2pa_manifest", "no_training", "delete_material", "usage_report",
  ]);

  function canProceed(obligations: { type: string }[]): boolean {
    return obligations.every((o) => KNOWN.has(o.type));
  }

  if (!canProceed(check.obligations)) {
    throw new Error("Unknown obligation type; not generating.");
  }
  ```

  ```python Python theme={null}
  KNOWN = {
      "generation_check", "hold_until_release", "draft_watermark", "generation_instructions",
      "disclosure", "attribution", "c2pa_manifest", "no_training", "delete_material", "usage_report",
  }

  def can_proceed(obligations):
      return all(o["type"] in KNOWN for o in obligations)

  if not can_proceed(check["obligations"]):
      raise RuntimeError("Unknown obligation type; not generating.")
  ```
</CodeGroup>

## `generation_check`

Fields: `required` (`all` or `sampled`), `sample_rate` (0 to 1).

Submit outputs as [generations](/concepts/generation-checks) before anyone sees them. With `all`,
submit every output. With `sampled`, submit at least the share in `sample_rate`, chosen at random
rather than by content. Deliver a submitted output only when its decision is `allow`.

## `hold_until_release`

Fields: `reviewer` (`talent`, `representative` or `reflections`).

A person releases each output. Its generation returns `escalate` with `status: "held"`. Keep the
clean output private, and deliver it only after
[`generation.released`](/api-reference/webhooks/generation-released). A held output that nobody
reviews expires after 7 days and can never be released. See [Escalation](/concepts/escalation).

## `draft_watermark`

No fields.

Anything you show before release, such as a preview for the person who asked for it, carries a
visible draft watermark. Without this obligation, show nothing before release. Deliver the clean
output only after release.

## `generation_instructions`

Fields: `instructions` (a list of strings).

Include every instruction, as written, in what the model receives, for example in its system text.
Instructions say what must stay ("Keep Maya Okafor the same person: face, skin tone and build
unchanged.") and what must not appear ("Do not show alcohol or tobacco."). Do not paraphrase or
drop any of them.

## `disclosure`

Fields: `level` (`licensed`, `brand` or `scope`), `text`, `placement` (`visible`, `metadata` or
`both`).

Label the output with `text`, exactly as given. `licensed` says the person's likeness is licensed;
`brand` adds who licensed it; `scope` adds the use. With `visible`, show the label with the output
wherever it appears; with `metadata`, write it into the file's metadata; with `both`, do both.
[Embedding provenance](/build/embedding-provenance) shows where.

## `attribution`

Fields: `text`.

Show the credit line in `text`, as written, where the output appears.

## `c2pa_manifest`

No fields.

Before you deliver, add the generation's `c2pa` object to the output's C2PA manifest as an assertion
under its `label`, `ai.reflections.license`. You stay the C2PA claim signer for your output; the
receipt inside is signed by Reflections. See [Provenance](/concepts/provenance).

## `no_training`

Fields: `material` (`references`, `voice` or `outputs`).

Do not use the covered material to train or fine-tune any model, yours or a provider's. A license
can change this only with `scope.training: "permitted"`.

## `delete_material`

Fields: `material` (`references`, `voice` or `outputs`), `within` (an ISO 8601 duration).

Delete the covered material, including copies held at model providers, within `within`, counted
from the decision that carried the obligation. Copies at providers, such as a voice, are listed
in the facet's `provider_bindings`.

## `usage_report`

Fields: `units` (`outputs`, `seconds`, `characters`, `placements` or `impressions`), `within`.

Report usage in `units` with a [usage record](/concepts/usage-and-settlement) that names the
generation or session. `within` is counted from the generation's decision, or for a session from
the session's end.

## Example: an image for Ridgeline

A check for a Ridgeline campaign image returns these obligations:

```json theme={null}
[
  { "type": "generation_check", "required": "all" },
  { "type": "hold_until_release", "reviewer": "talent" },
  { "type": "draft_watermark" },
  {
    "type": "generation_instructions",
    "instructions": [
      "Keep Maya Okafor the same person: face, skin tone and build unchanged.",
      "Do not show alcohol or tobacco.",
      "Do not imply she endorses any product other than the one shown."
    ],
    "term": "license:lic_k5zba2q8v1m3n7p4r6s9t0wxyh/terms.neverExtras"
  },
  { "type": "disclosure", "level": "brand", "placement": "both", "text": "Made with AI. Maya Okafor's likeness used under license by Ridgeline." },
  { "type": "c2pa_manifest" },
  { "type": "no_training", "material": "outputs" },
  { "type": "usage_report", "units": "placements", "within": "P30D" }
]
```

Northlight adds the three instructions to the model's system text, submits all four candidates,
and shows Ridgeline's designer watermarked previews while Maya Okafor reviews them. When she
releases one, Northlight embeds the receipt, writes the label into the file and shows it beside the
image, keeps the output out of its training data, and reports each placement within 30 days.

## Related

<Columns cols={2}>
  <Card title="Decisions" icon="scale-balanced" href="/concepts/decisions">
    What an `allow` carries.
  </Card>

  <Card title="Obligations registry" icon="book" href="/standard/obligations-registry">
    The registered types and how new ones are added.
  </Card>

  <Card title="Submitting outputs" icon="upload" href="/build/submitting-outputs">
    Uploads, candidates and findings.
  </Card>

  <Card title="Embedding provenance" icon="receipt" href="/build/embedding-provenance">
    The C2PA assertion and the disclosure label.
  </Card>
</Columns>


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