lenz-io Assess API

openapi: 3.2.0
info:
  title: Lenz — AI Fact-Checking Assess API
  version: 1.0.0
  description: '# Four API calls and one to run them


    A research-depth ladder: find claims, judge fast, prove deep, citecheck; `/review` runs them all. - `POST /extract` — enumerate every major verifiable claim in a document (up to 100, most check-worthy first, inputs to 50k chars), or in a public web page given its URL; an optional `focus` narrows the list to the claims you care about, and `locate: true` keeps only the claims traced back to the text, with where each is made. Costs no credits; fair-use cap 1,000/account/day. - `POST /assess` — a fast panel verdict, with the pages the reviewers looked at, typically 10-25s. Sync, 1 credit per claim. Send one text in `claim`, or a list of up to 20 in `claims` — one row per claim, same order, all checked in parallel. A text that makes more claims than one call checks gets the most check-worthy checked and the rest back as `more_claims`, free, to send on. - `POST /verify` — a full investigation, with verified citations, in ~90s. Async, 10 credits — or 5 with `depth: "low"`, a shallower check that comes back sooner. - `POST /citecheck` — does each cited source say what the text attributes to it: send pairs of a statement and its URL or DOI, or a whole text. Async; 1 credit per checked citation, refunded when a citation could not be checked (guide). - `POST /review` — the extract → assess → verify ladder on a whole draft, returning the issues with suggested rewrites in 2-4 min. Async, 1 credit per claim assessed + 10 (5 at `depth: "low"`) per claim verified. With `escalate.max_citations` (0-20, default 0) it also checks whether each source the draft cites says what the draft attributes to it, at 1 credit per checked citation (one that could not be checked is refunded) (guide). `more_claims` and `more_citations` list what the review found and did not check, at no cost; send them to `/assess` and `/citecheck` to check the rest. - Also `POST /ask/{id}` — ask follow-up questions grounded on a verification. ## Built for teams whose AI output is async or document-shaped


    Legal-memo generators, AI deep-research, due-diligence platforms, vertical agents producing structured deliverables, "report-as-a-service" companies. `/assess` opens the door to sync UX too — fast enough to gate a chat completion or a UI submit. ## API versions


    Lenz versions the shape of its responses by date: send `X-Lenz-API-Version: 2026-10-11` to choose this shape. This reference describes `2026-10-11`. A field `2026-05-13` still sends under an older name is listed `deprecated` beside the current one, and where its shape differs, the operation names the `...Legacy` component it receives (`x-lenz-versions` on the response). Every response carries `X-Lenz-API-Version`, naming the version it is in. Which version a request gets without the header, and what changed: https://lenz.io/docs/api-versions. ## Install the SDK


    ```bash

    pip install lenz-io # Python

    npm install lenz-io # Node / TypeScript

    ```


    Source on GitHub: lenz-io-python · lenz-io-node. ## The canonical integration: one /review call


    ```python

    from lenz_io import Lenz

    client = Lenz(api_key="lenz_...")


    # Extract, assess, and verify the doubtful claims in one call (async, 2-4 min)

    draft = "The EU AI Act took effect in March 2024. It sorts AI systems into four risk tiers."

    review = client.review_and_wait(text=draft)

    for i in review.issues:

    print(i.verdict, i.claim, i.suggested_rewrite)

    ```


    The default policy: a quick verdict on every claim (up to 20), and the deep check on the rows whose quick verdict is `False`, `Mostly False`, `Mixed` or `No Public Record`, or whose confidence is `low`, up to five. Change it in `escalate`. To deep-check the rows the cap left out (`escalation.disposition == "cap"`), send them to `/verify/batch`. A resend with the same `Idempotency-Key` within 24 hours returns the same review; a new key is a new review.'
  termsOfService: https://lenz.io/terms
servers:
- url: https://lenz.io
  description: Production
tags:
- name: Assess
  description: Fast panel verdict on a claim, with the pages the reviewers looked at. Sync, typically 10-25s; allow 45s for the response.
paths:
  /api/v1/assess:
    post:
      operationId: assess
      summary: Assess
      parameters:
      - $ref: '#/components/parameters/XLenzApiVersion'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AssessOut'
          x-lenz-versions:
            '2026-10-11':
              $ref: '#/components/schemas/AssessOut'
            '2026-05-13':
              $ref: '#/components/schemas/AssessOutLegacy'
          headers:
            X-Lenz-API-Version:
              $ref: '#/components/headers/XLenzApiVersion'
        '422':
          description: A field to fix
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ValidationErrorOut'
          x-lenz-versions:
            '2026-10-11':
              $ref: '#/components/schemas/ValidationErrorOut'
            '2026-05-13':
              $ref: '#/components/schemas/ValidationErrorOutLegacy'
          headers:
            X-Lenz-API-Version:
              $ref: '#/components/headers/XLenzApiVersion'
        default:
          description: An error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorOut'
          x-lenz-versions:
            '2026-10-11':
              $ref: '#/components/schemas/ErrorOut'
            '2026-05-13':
              $ref: '#/components/schemas/ErrorOutLegacy'
          headers:
            X-Lenz-API-Version:
              $ref: '#/components/headers/XLenzApiVersion'
      description: 'Fast verdict via a 3-model panel (sync, ~10-25s).


        Escalation contract: a ``claims[].claim`` text POSTed back verbatim to

        ``/verify`` within 24 hours is verified as-is — in normal operation it

        does not return ``needs_input`` and its wording is not rewritten.


        Two input forms, one response shape::


        claim / text ─► ONE text. Lenz reads the claims in it, and each becomes a

        row, up to 20 a call; the rest go back, unchecked and

        free, in ``more_claims``.

        claims[] ─► a LIST of up to 20 items, each one claim. One row per item, same order.

        A compound item is assessed on its primary reading and

        the rest is listed in that row''s ``more_claims``.


        The list form is the batch rung of the extract → assess → verify ladder:

        one ``/assess`` call answers up to 20 of ``/extract``''s claims (it finds up

        to 100) in about the time a single call takes, because every item is

        assessed in parallel.


        A verdict can be served from memory: a completed ``/verify`` of the exact

        same claim text, or a prior ``/assess`` of it, within the last hour,

        whichever account ran it — the verdict is a function of the input.

        ``verification_url`` is set only when the caller could read that

        verification by id.


        Billing: 1 credit per row that carries a verdict; error rows are free; a

        duplicate item is a second row and a second credit (the panel runs once).


        **Versions.** 200: `2026-10-11` receives `AssessOut`, `2026-05-13` receives `AssessOutLegacy`; 422: `2026-10-11` receives `ValidationErrorOut`, `2026-05-13` receives `ValidationErrorOutLegacy`; default: `2026-10-11` receives `ErrorOut`, `2026-05-13` receives `ErrorOutLegacy`.'
      tags:
      - Assess
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/AssessIn'
        required: true
      security:
      - APIKeyBearerAuth: []
      x-codeSamples:
      - lang: Python
        source: "from lenz_io import Lenz\n\nclient = Lenz(api_key=\"lenz_...\")\nout = client.assess(claim=\"Coffee causes cancer and the earth is flat.\")\n# Add language=\"es\" for Spanish verdict text; verdict labels stay English.\nfor c in out.claims:\n    print(c.claim, \"→\", c.verdict, c.confidence)\n    if c.rationale:\n        print(\"  \", c.rationale)\n\n# Several claims at once: one row per item, same order (up to 20).\nrows = client.assess(claims=[\"Coffee causes cancer.\", \"The earth is flat.\"]).claims\nfor c in rows:\n    if c.failure:  # status == \"failed\": no verdict, nothing charged\n        print(\"No verdict:\", c.failure.code, c.failure.hint)\n    else:\n        print(c.verdict, c.confidence)\n"
      - lang: TypeScript
        source: "import { Lenz } from \"lenz-io\";\n\nconst client = new Lenz({ apiKey: \"lenz_...\" });\nconst out = await client.assess({\n  claim: \"Coffee causes cancer and the earth is flat.\",\n});\nout.claims.forEach(c => {\n  console.log(c.claim, \"→\", c.verdict, c.confidence);\n  if (c.rationale) console.log(\"  \", c.rationale);\n});\n\n// Several claims at once: one row per item, same order (up to 20).\nconst rows = (await client.assess({\n  claims: [\"Coffee causes cancer.\", \"The earth is flat.\"],\n})).claims;\nrows.forEach(c => {\n  // status \"failed\": no verdict, nothing charged\n  if (c.status === \"failed\") console.log(\"No verdict:\", c.failure?.code, c.failure?.hint);\n  else console.log(c.verdict, c.confidence);\n});\n"
components:
  parameters:
    XLenzApiVersion:
      name: X-Lenz-API-Version
      in: header
      required: false
      schema:
        type: string
        examples:
        - '2026-05-13'
      description: The API version to answer in, as a date. A date before `2026-10-11` (or a value that is not a date) gets `2026-05-13`. See https://lenz.io/docs/api-versions.
  schemas:
    ValidationErrorItemOut:
      title: ValidationErrorItemOut
      type: object
      description: 'One field to fix: where (`loc`, as the request names it), what (`msg`) and the kind (`type`).'
      properties:
        loc:
          type: array
          items:
            anyOf:
            - type: string
            - type: integer
        msg:
          type: string
        type:
          type: string
        ctx:
          type: object
          description: Pydantic's context for the error (the limit that was exceeded, ...).
      required:
      - loc
      - msg
      - type
      additionalProperties: true
    FailureOut:
      description: 'Why an item failed, and what to do next. The same block everywhere an

        item fails: a verification, an /assess row, a review, a review''s claim

        rows and citation checks.


        ``code`` is what failed, ``detail`` one sentence on it (the same sentence

        for the same code on every endpoint), ``hint`` what to send next (null

        when there is nothing to change), ``failure_class`` why, ``retryable``

        whether sending the same request again can succeed, ``docs_url`` where

        that class is explained.


        API version ``2026-05-13`` sends each endpoint''s earlier fields instead

        (flat ``error`` / ``failure_reason`` on a verification, ``error_code`` /

        ``hint`` on an /assess row, ``failure.failure_reason`` on a review).'
      properties:
        code:
          description: 'What failed, one vocabulary everywhere: `no_checkable_claim`, `page_unreadable`, `upstream_unavailable`, `internal`, `cancelled`, `no_citations`, `insufficient_credits` (a verification only ever says the first, the third, the fourth and `cancelled`). Branch on `retryable` for whether to resend, and on the input codes for what to say; fall through on a value you do not know. `no_checkable_claim`: no claim in the input could be checked against public evidence (an opinion, a forecast, a claim about a private person, a statement whose only source is unidentified; on a review, also claims found that could not be traced back to the text); `hint` says which. `page_unreadable`: the link /review was sent could not be read. Version `2026-05-13` spells `no_checkable_claim` as `no_claim` (/assess, /review) or `not_a_claim` (/extract, a verification), and keeps the earlier causes as codes (`timeout`, `framing_failed`, `assessment_failed`, `citation_check_failed`, `invalid_input`).'
          title: Code
          type: string
        detail:
          description: The cause, in one sentence (out of time, no row could be assessed, ...); the same sentence for the same cause everywhere.
          title: Detail
          type: string
        hint:
          anyOf:
          - type: string
          - type: 'null'
          description: What to send next; null when there is nothing to change.
          title: Hint
        failure_class:
          enum:
          - upstream_unavailable
          - invalid_input
          - cancelled
          - internal
          title: Failure Class
          type: string
        retryable:
          title: Retryable
          type: boolean
        docs_url:
          anyOf:
          - type: string
          - type: 'null'
          title: Docs Url
      required:
      - code
      - detail
      - failure_class
      - retryable
      - docs_url
      title: FailureOut
      type: object
    ErrorOut:
      title: ErrorOut
      type: object
      description: 'Every error response: `detail` is one sentence on what happened and `code` names it (every code is listed at https://lenz.io/docs/errors#codes). A field you must fix adds `errors`. Waits are `retry_after` (seconds, the same value as the `Retry-After` header); a docs link is `docs_url`. Some codes add their own fields: a 402 carries `upgrade_url`, `wall_id`, `cost` and the balance, a 429 `limit` and `upgrade_url`.'
      properties:
        detail:
          type: string
        code:
          type: string
        errors:
          type: array
          items:
            $ref: '#/components/schemas/ValidationErrorItemOut'
        hint:
          type: string
        docs_url:
          type: string
        retry_after:
          type: integer
        upgrade_url:
          type: string
        wall_id:
          type: string
        remaining:
          type: integer
        credits_remaining:
          type: integer
        cost:
          type: integer
        requested:
          type: integer
        resets_at:
          type: string
        limit:
          type: integer
        scope:
          type: string
        task_id:
          type: string
        purged_at:
          anyOf:
          - type: string
          - type: 'null'
        doc_url:
          type: string
          deprecated: true
          description: Sent only to callers on `2026-05-13`; use `docs_url`.
        reset_in_seconds:
          type: integer
          deprecated: true
          description: Sent only to callers on `2026-05-13`; use `retry_after`.
        retry_after_seconds:
          type: integer
          deprecated: true
          description: Sent only to callers on `2026-05-13`; use `retry_after`.
        error:
          type: string
          deprecated: true
          description: Sent only to callers on `2026-05-13`; use `code`.
      required:
      - detail
      - code
      additionalProperties: true
    SearchedPageOut:
      description: A page looked at while assessing a claim.
      properties:
        title:
          title: Title
          type: string
        url:
          title: Url
          type: string
      required:
      - title
      - url
      title: SearchedPageOut
      type: object
    AssessIn:
      description: 'Request body for ``POST /assess``.


        Two forms. ``claim`` (or its alias ``text``) is ONE text: read once and

        expanded, so every claim found in it becomes a row (up to 20, one credit

        each; a text that makes more lists the rest in ``more_claims``). ``claims`` is a list

        of up to 20 items: exactly one row per item, in order — the batch rung of

        the extract → assess → verify ladder. Sending both is a 422.'
      properties:
        claim:
          anyOf:
          - type: string
          - type: 'null'
          description: The claim to check. A statement in natural language; several claims in one string are split and handled separately.
          title: Claim
        text:
          default: ''
          description: Accepted alias for `claim`. Send one or the other; `text` is used when it has content.
          title: Text
          type: string
        claims:
          anyOf:
          - items:
              type: string
            type: array
          - type: 'null'
          description: A list of up to 20 — one verdict row each, in order. Use this for the claims `/extract` returned; each item is one claim (≤2000 chars), not a document. Mutually exclusive with `claim`.
          title: Claims
        language:
          default: ''
          description: 'ISO 639-1 code for the language of the verdict rows. Omitted: English. `auto`: detected from the submitted text (the same rule as lenz.io: a supported language, or English when the text is short, English or in a language we do not answer in). A code always wins. Responses carry the code that was used, never `auto`. With `claims`, `auto` picks ONE language for the whole request: the language more than half of the items of at least 20 letters agree on, else English; for a list in mixed languages send a code.'
          title: Language
          type: string
        suggest_rewrite:
          default: false
          description: 'Also write `suggested_rewrite` on each row: the claim with its wrong part corrected, for a claim the check found False or Mostly False with high confidence. Off by default. It costs no extra credit and works in both forms, per row. The rewrite comes from the quick check''s reasoning and is not itself verified: review it, or run it through `/verify`, before using it.'
          title: Suggest Rewrite
          type: boolean
      title: AssessIn
      type: object
    AssessClaimOutLegacy:
      description: 'An /assess row as `2026-05-13` sends it: no `status` or `failure`; a row with no verdict has `verdict: "Error"`, `confidence: "low"` and says why in `error_code` (`no_claim` where the current version says `no_checkable_claim`) and `hint`.'
      properties:
        claim:
          title: Claim
          type: string
        language:
          title: Language
          type: string
        verdict:
          type: string
          enum:
          - 'True'
          - Mostly True
          - Mixed
          - Mostly False
          - 'False'
          - Error
          description: '`Error` when the row carries no verdict (`error_code` says why).'
        confidence:
          type: string
          enum:
          - low
          - medium
          - high
        verification_url:
          anyOf:
          - type: string
          - type: 'null'
          title: Verification Url
        rationale:
          anyOf:
          - type: string
          - type: 'null'
          title: Rationale
        dissent:
          anyOf:
          - type: string
          - type: 'null'
          deprecated: true
          description: 'Deprecated: always null.'
          title: Dissent
        searched_pages:
          default: []
          description: Pages looked at while assessing this claim, as title and link.
          items:
            $ref: '#/components/schemas/SearchedPageOut'
          title: Searched Pages
          type: array
        suggested_rewrite:
          anyOf:
          - type: string
          - type: 'null'
          title: Suggested Rewrite
        identified_claims:
          default: []
          items:
            type: string
          type: array
        error_code:
          anyOf:
          - type: string
          - type: 'null'
        candidate_claims:
          type: array
          items:
            type: string
          maxItems: 0
          description: Always `[]`.
        hint:
          anyOf:
          - type: string
          - type: 'null'
      required:
      - claim
      - language
      - verdict
      - confidence
      title: AssessClaimOutLegacy
      type: object
    ValidationErrorOutLegacy:
      title: ValidationErrorOutLegacy
      type: object
      properties:
        detail:
          anyOf:
          - type: string
          - type: array
            items:
              type: object
              additionalProperties: true
        code:
          type: string
        errors:
          type: array
          items:
            type: object
            properties:
              loc:
                type: array
                items:
                  anyOf:
                  - type: string
                  - type: integer
              msg:
                type: string
        hint:
          type: string
        doc_url:
          type: string
        unrecognized_fields:
          type: array
          items:
            type: string
        error:
          type: string
      required:
      - detail
      description: A 422 as `2026-05-13` sends it. `detail` is a sentence, or (for a field of the wrong type or a missing one) the list of validation errors, each `{type, loc, msg}`, with `hint`, `doc_url` and `unrecognized_fields` beside it. `code` is on some (an /assess `claims` list, /review, /citecheck); `errors`, each `{loc, msg}`, only on /review and /citecheck.
    AssessOut:
      description: 'Response body for ``POST /assess``.


        ``status`` is ``ok`` when at least one row carries a verdict (other rows

        may have failed), ``no_checkable_claim`` when no claim in the input could

        be checked against public evidence (every row, or the single text),

        and ``error`` when no row carries a verdict for another reason. A single

        text with no checkable claim answers ``claims: []`` with the reason in

        ``failure`` (the same block a failed row carries); ``failure`` is

        ``null`` otherwise.'
      properties:
        status:
          enum:
          - ok
          - no_checkable_claim
          - error
          title: Status
          type: string
        claims:
          default: []
          items:
            $ref: '#/components/schemas/AssessClaimOut'
          title: Claims
          type: array
        failure:
          anyOf:
          - $ref: '#/components/schemas/FailureOut'
          - type: 'null'
        more_claims:
          description: 'Claims found in a single `text` past the ones checked: one call checks at most 20, ranked most check-worthy first. Not checked and not charged; send them as `claims` (up to 20 a call) to check them. Always `[]` for the `claims` list form.'
          items:
            type: string
          title: More Claims
          type: array
      required:
      - status
      title: AssessOut
      type: object
    AssessClaimOut:
      description: 'Per-claim entry inside an ``AssessOut.claims`` list.


        ``status`` is ``completed`` when the row carries a verdict and ``failed``

        when it does not; a failed row has ``verdict`` and ``confidence``

        ``null`` and says why in ``failure`` (``code``, ``detail``, ``hint``,

        ``failure_class``, ``retryable``, ``docs_url``). ``failure.code`` is an

        OPEN set: ``no_checkable_claim`` (no claim in the item could be checked

        against public evidence), ``framing_failed`` (the item could not be read;

        send it rephrased), ``upstream_unavailable`` and ``timeout`` (worth

        sending again in a new call). On a failed row ``claim`` echoes the item

        as submitted. Failed rows are free.


        A verdict row is the entire answer for that claim. ``verification_url``

        is set when a full verification of the same claim exists and the caller

        can read it; follow it for sources, reasoning and the deep score.


        ``verdict`` may be ``No Public Record``: the reviewers found no public

        record that would show the claim (its ``confidence`` is medium or low,

        never high; a deep check, /verify, looks further). A failed row whose

        ``failure.detail`` says the reviewers did not reach an answer is free and

        worth sending again.


        ``rationale`` is the reasoning of a reviewer who agrees with the panel''s

        verdict. It is a reviewer''s note, not a checked source; for sourced

        evidence, call /verify.


        Same field vocabulary as ``ClaimDetailOut`` (``claim``, ``verdict``,

        ``confidence``); /assess omits ``lenz_score``, which only a full

        verification computes. ``language`` echoes the output language so a

        batch caller can route per-claim text when items differ in language.


        ``suggested_rewrite`` is on every row: the claim with its wrong part

        corrected when the request set ``suggest_rewrite`` and the check found the

        claim False or Mostly False with high confidence; ``null`` when it was not

        requested, the row is outside that, or there was no correction to write. It

        is not itself verified: review it, or run it through /verify.


        ``more_claims`` lists the OTHER claims found in a list item that were NOT

        assessed (the list form assesses one claim per item, the primary): send

        them as their own items to check them. A vague item is assessed on its

        most likely reading, which ``claim`` carries.'
      properties:
        claim:
          title: Claim
          type: string
        language:
          title: Language
          type: string
        status:
          enum:
          - completed
          - failed
          title: Status
          type: string
        verdict:
          anyOf:
          - enum:
            - 'True'
            - Mostly True
            - Mixed
            - Mostly False
            - 'False'
            - No Public Record
            type: string
          - type: 'null'
          title: Verdict
        confidence:
          anyOf:
          - enum:
            - low
            - medium
            - high
            type: string
          - type: 'null'
          title: Confidence
        verification_url:
          anyOf:
          - type: string
          - type: 'null'
          title: Verification Url
        rationale:
          anyOf:
          - type: string
          - type: 'null'
          title: Rationale
        dissent:
          anyOf:
          - type: string
          - type: 'null'
          deprecated: true
          description: 'Deprecated: always null.'
          title: Dissent
        searched_pages:
          default: []
          description: Pages looked at while assessing this claim, as title and link.
          items:
            $ref: '#/components/schemas/SearchedPageOut'
          title: Searched Pages
          type: array
        suggested_rewrite:
          anyOf:
          - type: string
          - type: 'null'
          title: Suggested Rewrite
        more_claims:
          default: []
          items:
            type: string
          title: More Claims
          type: array
        failure:
          anyOf:
          - $ref: '#/components/schemas/FailureOut'
          - type: 'null'
        identified_claims:
          items:
            type: string
          type: array
          deprecated: true
          description: Sent only to callers on `2026-05-13`; use `more_claims`.
      required:
      - claim
      - language
      - status
      title: AssessClaimOut
      type: object
    AssessOutLegacy:
      description: 'The /assess body as `2026-05-13` sends it: `status` says `not_a_claim` for an input with nothing checkable; no `failure`; `error` is null, or a sentence when the single text held no claim, beside `error_code: no_claim` and `candidate_claims: []`.'
      properties:
        status:
          type: string
          enum:
          - ok
          - not_a_claim
          - error
        claims:
          default: []
          items:
            $ref: '#/components/schemas/AssessClaimOutLegacy'
          title: Claims
          type: array
        more_claims:
          description: 'Claims found in a single `text` past the ones checked: one call checks at most 20, ranked most check-worthy first. Not checked and not charged; send them as `claims` (up to 20 a call) to check them. Always `[]` for the `claims` list form.'
          items:
            type: string
          title: More Claims
          type: array
        error:
          anyOf:
          - type: string
          - type: 'null'
        error_code:
          type: string
        candidate_claims:
          type: array
          items:
            type: string
          maxItems: 0
          description: Always `[]`.
      required:
      - claims
      title: AssessOutLegacy
      type: object
    ErrorOutLegacy:
      title: ErrorOutLegacy
      type: object
      description: 'An error as `2026-05-13` sends it: `detail`, and `code` on most (not on a 401, a 404 or 405 outside /review and /citecheck, a malformed body, or an idempotency conflict); `doc_url`, `reset_in_seconds` (the /extract daily cap), `retry_after_seconds` (a review or citation check already running) and `error` (a repeat of some codes) where the current version has other names.'
      properties:
        detail:
          type: string
        code:
          type: string
        errors:
          type: array
          items:
            $ref: '#/components/schemas/ValidationErrorItemOut'
        hint:
          type: string
        docs_url:
          type: string
        retry_after:
          type: integer
        upgrade_url:
          type: string
        wall_id:
          type: string
        remaining:
          type: integer
        credits_remaining:
          type: integer
        cost:
          type: integer
        requested:
          type: integer
        resets_at:
          type: string
        limit:
          type: integer
        scope:
          type: string
        task_id:
          type: string
        purged_at:
          anyOf:
          - type: string
          - type: 'null'
        doc_url:
          type: string
        reset_in_seconds:
          type: integer
        retry_after_seconds:
          type: integer
        error:
          type: string
      required:
      - detail
      additionalProperties: true
    ValidationErrorOut:
      title: ValidationErrorOut
      type: object
      description: 'A 422: `detail` names the first field to fix by its public name (`claims[2].text: ...`), `code` says what kind of problem it is (`validation_error`, `blank_input`, `unsupported_language`, `too_many_items`, ...), and `errors` lists every field. `unrecognized_fields` lists keys the endpoint does not take.'
      properties:
        detail:
          type: string
        code:
          type: string
        errors:
          type: array
          items:
            $ref: '#/components/schemas/ValidationErrorItemOut'
        hint:
          type: string
        docs_url:
          type: string
        unrecognized_fields:
          type: array
          items:
            type: string
      required:
      - detail
      - code
      additionalProperties: true
  headers:
    XLenzApiVersion:
      description: The API version this response is in.
      schema:
        type: string
  securitySchemes:
    APIKeyBearerAuth:
      type: http
      scheme: bearer