Offendersearch API Batch API

openapi: 3.2.0
info:
  title: Offendersearch Batch API
  version: 1.0.0
  description: "National sex-offender search across all US states and territories, unified behind one API. Synchronous by default (call and wait) for interactive use; an asynchronous mode returns a job handle and is built for batch and high-volume work. Full offenders.io field parity plus scored matches, per-source provenance, freshness options, DOB/age match-state fidelity, and a consolidated verification-report PDF (`POST /v1/report`) with a source citation on every record. Criminal records land later as an additive `recordType` — the contract does not change.\n\n## Authentication\nMost customer endpoints authenticate with an API key sent in the `X-API-Key` header (`ApiKeyAuth`). The primary synchronous search additionally accepts a signed **session token** (`Authorization: Bearer <token>`) so the dashboard console can run searches on behalf of a signed-in user. The offenders.io compatibility endpoint accepts the key three ways for drop-in parity: `X-API-Key`, `Authorization: Bearer <key>`, or `?key=<key>`. Account/dashboard endpoints (`/v1/account`, `/v1/keys`, `/v1/usage`, ...) require a session token. Internal ops endpoints require the separate `X-Admin-Key` credential.\n\n## Freshness & billing\n`freshness` is a per-request parameter with two values — `daily` (the DEFAULT when omitted) and `weekly`.\n\n* **`daily`** is the freshest data we publish. Our sweep of every registry runs\n  on a daily cycle, so a `daily` answer is assembled from the newest snapshot we\n  hold of each one — in practice, almost real time. Ask for it when currency is\n  the point. It bills the **+$0.01/call daily-freshness surcharge** on top of the\n  base per-call rate (admin-overridable per customer).\n* **`weekly`** is also fresh. Identity is essentially identical to `daily` — the\n  same people, names, aliases, offenses, addresses and photos — and what can lag\n  is only the most recent movement, a registration or an address change from the\n  last day or so. Right for bulk screening and periodic re-screens. **No\n  surcharge.**\n\n\n**`freshness` describes the answer; it does not filter it.** No registry is ever withheld from a result because of when it was last swept: every registry covering the query contributes, from the newest snapshot we hold of it. `status` never becomes `partial` for a snapshot age, and `warnings[]` never carries a staleness sentence.\n\n**★ EVERY DATE IS ISO-8601 — BREAKING CHANGE, 2026-08-04.** Every date-shaped field in a record now comes back as ISO-8601: `dob`, the four `offense.*Date` fields, and the five `stateData` date fields. They used to be the registry's own string passed through byte-for-byte, so a single response could carry `\"2003-03-31\"`, `\"10/11/1988\"`, `\"11-29-1987\"` and `\"Aug. 10, 1987\"` in the same key — `offense.offenseDate` was ISO on only 45.4% of its populated values, in seven distinct shapes. **If you wrote a lenient parser or a per-state format table, you can delete it; if you compared these values as raw strings, or stored them in a text column and matched on it, those comparisons will change once.**\nThree rules govern the new values, and the third is the one to read carefully:\n1. A full date is `YYYY-MM-DD`. 2. **A partial date stays partial.** A registry that publishes only a month or\n   only a year yields `YYYY-MM` or `YYYY` — we never invent a day. The companion\n   `datePrecision` object on `offense` and `stateData` names the precision\n   explicitly, exactly as `dobPrecision` has always done for `dob`.\n3. **Nothing is discarded.** A value we cannot read as a date — a crime\n   description in an offence-date cell, a `registrationEnds` of \"Life\" — is NOT\n   served as a fake date and NOT silently blanked. The field is `\"\"`, the\n   precision is `unparseable`, and the registry's literal text is preserved in\n   the `datesAsPublished` object beside it.\n\n`source.scrapedAt` / `.lastCheckedAt` / `.sourceUpdatedAt` were already ISO-8601 timestamps and are unchanged. `dob` was already `YYYY-MM-DD` and is unchanged.\n\n**There is no date FILTER on the offense or stateData dates.** `dob` is the one date you can narrow a query on; read the rest off the record.\n**Provenance is never traded for normalisation.** The registry's own text is kept beside the normalised value, not overwritten by it, which is why `datesAsPublished` still carries what the source actually printed — including the 38,818 `registrationEnds` cells that hold a registration DURATION (\"15 Years\", \"Lifetime\") rather than a date.\n\n**Where currency is published — and where it is not.** Per record, `record.source.scrapedAt` is the moment we ingested the snapshot that record came from. Per registry, `GET /v1/sources` publishes `health.lastSuccessAt` and `health.ageSeconds` live and without an API key. Both are things you ask for. Neither is attached to a search answer: `sourceStatus[]` carries no age fields, because an answer that contains every matching record does not need a caveat about our sweep schedule.\n\n★ **Freshness and completeness are different questions, and only one of them makes an empty result unsafe.** `freshness` says how OLD an answer is; it says nothing about whether the answer is WHOLE. A registry swept ten minutes ago can still fail to be searched to the end — a deadline, or a candidate set larger than one search may examine — and then a `0` from it means UNKNOWN, not NO MATCH. That is `counts.sourcesIncomplete` / `sourceStatus[].incomplete`, it is unrelated to freshness, and it is the one signal that must never be ignored. See API-CONTRACT.md §5.0.\n\n**Migrating from a pre-2026-08-04 integration.** `counts.sourcesStale`, `counts.sourcesDegraded`, `counts.sourcesOmitted`, `counts.recordsFromStaleSources`, `freshnessDetail`, and `sourceStatus[].freshnessSatisfied` / `.degraded` / `.omitted` / `.ageSeconds` / `.lastSuccessAt` were removed and are no longer emitted. If you were gating on any of them, gate on `counts.sourcesIncomplete` instead — it asks whether your ANSWER is whole, which is the question those keys were being used to ask. `onStale` is deprecated but still accepted, so an older request body keeps working.\n\nBilling is required for every account; the ONLY free call is one scoped exclusively to statutorily non-commercial jurisdiction(s) (e.g. state=CA), which has nothing commercially billable. **Batch billing is per-search:** `POST /v1/batch` is one HTTP request but each search in it is billed as its own search (per-row freshness included) — a batch of 100 = 100 billable searches. The consolidated verification report (`POST /v1/report`) is a separate, callable endpoint any valid key may use (no per-key entitlement), billed **+$0.02 per document** (admin-overridable per customer). A separate `proof` add-on also carries an extra per-document charge and requires billing (402 otherwise); it is NOT the customer verification report.\n"
servers:
- url: https://api.offendersearch.app
security:
- ApiKeyAuth: []
tags:
- name: Batch
paths:
  /v1/batch:
    post:
      operationId: batchSearch
      summary: Batch search (row-in / row-out bulk lookups)
      description: 'Runs many queries in one call — offenders.io CSV-batch parity (one row = one call in, one result out). Each row goes through the SAME engine as `/v1/search` (served from the current snapshot), with bounded server-side concurrency, and results come back in input order. Send either a JSON array of query objects, a JSON envelope `{ "queries": [...], ...batch-wide options }` (the non-`queries` keys — `jurisdictions`, `freshness`, `match`, `recordTypes`, `locationScoped`, `include` — apply to every row), or a `text/csv` body whose header row names Query fields (`firstName,lastName,state,dob,city,zipcode,address,age,q`). A row that fails is reported with `status: error` in place; it never aborts the batch. Max 1000 rows. Accepts an API key OR a session token.


        **Billing — per search, NOT per request.** A batch is one HTTP call but contains N searches, and **each search in the batch is billed as one search** (at the graduated per-call rate, plus its own +$0.01 daily-freshness surcharge when that row''s freshness is `daily` — the default). A batch of 100 rows = 100 billable searches. Freshness applies per row: set `freshness: weekly` on a row (or batch-wide) to bill that search with no surcharge.

        '
      security:
      - ApiKeyAuth: []
      - BearerAuth: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              oneOf:
              - type: array
                items:
                  $ref: '#/components/schemas/Query'
              - type: object
                properties:
                  queries:
                    type: array
                    items:
                      $ref: '#/components/schemas/Query'
                  jurisdictions:
                    type: array
                    items:
                      type: string
                  freshness:
                    type: string
                    enum:
                    - daily
                    - weekly
                    default: daily
                    description: Batch-wide default; a per-row `freshness` overrides it for that row.
                  match:
                    type: string
                    enum:
                    - strict
                    - balanced
                    - broad
                  recordTypes:
                    type: array
                    items:
                      type: string
                  locationScoped:
                    type: boolean
                  include:
                    type: array
                    items:
                      type: string
                required:
                - queries
          text/csv:
            schema:
              type: string
              description: Header row of Query field names, then one query per line.
              example: 'firstName,lastName,state

                John,Smith,FL

                Jane,Doe,TX

                '
      responses:
        '200':
          description: Per-row results, in input order.
          content:
            application/json:
              schema:
                type: object
                properties:
                  count:
                    type: integer
                    description: Number of rows processed.
                  results:
                    type: array
                    items:
                      type: object
                      properties:
                        index:
                          type: integer
                          description: 0-based input row index.
                        status:
                          type: string
                          description: Row outcome (complete/partial/error).
                        counts:
                          type: object
                          properties:
                            records:
                              type: integer
                            sourcesQueried:
                              type: integer
                            sourcesIncomplete:
                              type: integer
                              description: Registries in THIS ROW that could not be searched to the end. Check it per row — one row can be short while the rest are whole. See API-CONTRACT.md §5.0.
                        warnings:
                          type: array
                          items:
                            type: string
                          description: Per-row warnings, same shape as the envelope's. `[]` when nothing shortened this row. A batch row carries no `sourceStatus`, so this is the only prose signal it has.
                        records:
                          type: array
                          items:
                            $ref: '#/components/schemas/Record'
                        error:
                          type: string
                          description: Present only when status=error.
        '401':
          $ref: '#/components/responses/Unauthorized'
        '413':
          description: Batch exceeded the maximum row count (1000).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '422':
          $ref: '#/components/responses/Unprocessable'
      tags:
      - Batch
components:
  schemas:
    Error:
      type: object
      description: Standard FastAPI error body.
      properties:
        detail:
          type: string
          description: Human-readable error message.
          example: Missing or invalid API key. Send it in the X-API-Key header.
    Query:
      type: object
      additionalProperties: false
      description: 'The person/location query. All fields are optional; supply what you have. DOB/age drive the match-state (see Record.dobVerification). offenders.io parity filters (q/address/prefixMatch/fuzzy/createdAt*/updatedAt*/page/ perPage) are applied uniformly across ALL jurisdictions.

        '
      properties:
        firstName:
          type: string
          description: Given name.
          example: John
        lastName:
          type: string
          description: Surname (primary match key).
          example: Smith
        dob:
          type: string
          format: date
          description: 'Date of birth, `YYYY-MM-DD`. Optional, and it NARROWS — a record whose published birth evidence conflicts with this date is excluded.


            ★ **It does not require us to hold a date of birth for the person.** The date you send is matched against every kind of birth evidence a registry publishes: a full date, a birth year alone, or a published age alone. Records with none of those are still returned on the name, flagged unverified. `matchState` on each record tells you which of those happened and how strong it was — read it there; the four outcomes are `dob_match`, `year_match`, `age_match` and `no_dob_age_year`.

            '
          example: '1985-06-14'
        age:
          type: integer
          description: Age filter. Used when DOB is unavailable; matched ±1 year for birthday drift.
          example: 39
        city:
          type: string
          description: Residence city filter.
          example: Chicago
        state:
          type: string
          description: '2-letter USPS state/territory code (`FL`), case-insensitive; the full state or territory name (`Florida`) is also accepted and means exactly the same thing. A value we cannot resolve to a jurisdiction is rejected with 422 — it is never silently treated as `matches nothing`.


            ★ IT IS A UNION, AND YOU SHOULD KNOW WHICH HALF MATCHED. `state` keeps a record when EITHER one of its `addressStates` is that state (they live there) OR its `registrationState` is (that state''s registry holds them). It does NOT change which registries run — all 58 are searched and `state` narrows the answer. (Until 2026-08-05 it silently scoped the fan-out to that state''s own registries, which hid anyone registered elsewhere while residing there; use `locationScoped: true` if you explicitly want the cheaper, narrower search.) Those two halves are genuinely different populations: 105,028 records are registered in a state where they have no address on file, and 70,973 records carry no address state at all and are reachable ONLY by the registration half. Every record comes back carrying both `registrationState` and `addressStates`, so you can tell which half answered without a second call — narrow to residents with `addressStates`, or to a registry''s roster with `jurisdictions: ["FL"]`, which is the registration-only filter.

            '
          example: IL
        zipcode:
          type: string
          description: Residence ZIP (first 5 used).
          example: '60614'
        address:
          type: string
          description: 'Parity: fuzzy street-address match (every token must appear in some record address).'
        lat:
          type: number
          description: Latitude for GIS radius search.
          example: 41.9
        lng:
          type: number
          description: Longitude for GIS radius search.
          example: -87.65
        radiusMiles:
          type: number
          maximum: 100
          description: 'Parity: GIS radius in miles. Defaults to 1 when lat/lng given; capped at 100.'
        q:
          type: string
          description: 'Parity: free-text across name/alias/address/city/state/zip (all tokens must appear).'
        fuzzy:
          type: boolean
          description: 'Parity: offenders.io fuzzy toggle. true -> balanced match; false -> strict. Overrides `SearchRequest.match`.'
        prefixMatch:
          description: 'PARTIAL-NAME SEARCH. Treat the name(s) you supplied as the START of a name: `thom` returns Thomas, Thompson and Thomason. Accepts "firstName", "lastName", "both" (prefix-match BOTH fields at once), or a list. Matched against every recorded ALIAS as well as the registered legal name; `matchedName` on each record says which one matched. MINIMUM 3 CHARACTERS — a shorter prefix returns 422. Prefix matching is a strict superset of exact matching, and an exact match always ranks above a prefix match. `nameMatch` overrides this.

            '
          oneOf:
          - type: string
            enum:
            - firstName
            - lastName
            - both
          - type: array
            items:
              type: string
              enum:
              - firstName
              - lastName
        nameMatch:
          type: object
          description: 'EXPLICIT PER-FIELD CONTROL over how names are matched — the fine-grained form of `prefixMatch`/`match`. Anything omitted from a field''s list is OFF for that field. Exact matching is always on and cannot be disabled. Overrides both `prefixMatch` and `SearchRequest.match`.

            '
          properties:
            firstName:
              type: array
              description: Strategies for the first name. prefix requires >=3 characters; middle requires >=2.
              items:
                type: string
                enum:
                - exact
                - prefix
                - nickname
                - fuzzy
                - middle
            lastName:
              type: array
              description: Strategies for the last name. prefix requires >=3 characters.
              items:
                type: string
                enum:
                - exact
                - prefix
                - fuzzy
            aliases:
              type: boolean
              default: true
              description: Also apply these strategies to every recorded alias.
        faceId:
          type: string
          description: Parity input ONLY — facial search is NOT supported; supplying it returns 422 (never a faked face match).
        createdAtStart:
          type: string
          format: date-time
          description: 'Parity: lower bound on source.scraped_at (when we first recorded the record).'
        createdAtEnd:
          type: string
          format: date-time
          description: 'Parity: upper bound on source.scraped_at.'
        updatedAtStart:
          type: string
          format: date-time
          description: 'Parity: lower bound on source.source_updated_at (when the source last changed the record).'
        updatedAtEnd:
          type: string
          format: date-time
          description: 'Parity: upper bound on source.source_updated_at.'
        page:
          type: integer
          minimum: 1
          description: 'Parity: 1-based page number. Omit it and the whole match set is returned in a single page — up to the response cap. ★ ABOVE THE CAP, OMITTING IT IS NOT THE SAME AS ASKING FOR EVERYTHING: an unpaginated answer larger than `cappedLimit` (4,000) is trimmed to that many records and says so with `capped: true`, and `cappedOmittedSources` names the registries that contributed nothing to it. A PAGINATED request is never trimmed — it walks the entire match set and `capped` stays `false`. So `counts.records` vs `counts.recordsReturned` is the pair to branch on: if they differ, send `perPage` and page through. Most searches never reach this — a `name + DOB` query returns tens of records — but a bare common surname does. A page past `totalPages` returns an empty `records` array (changed 2026-08-05; it used to re-serve the last page).

            '
        perPage:
          type: integer
          minimum: 1
          description: 'Parity: page size. Defaults to 20 when paginating. Sending it turns pagination ON, which is what makes an over-cap match set fully reachable. Clamped to `cappedLimit`, so a single page can never rebuild the oversized response the cap exists to prevent.

            '
        ageTolerance:
          type: integer
          minimum: 0
          maximum: 10
          default: 1
          description: 'How many years of slack the age comparison allows, when the query carries a `dob` and the record publishes only an `age`. Eleven registries publish an age and no date at all, so a `name + DOB` search has to compare a searched DATE against a published AGE; how much slack that allows is a risk decision, and it is yours. The default of 1 is not arbitrary — a published age with an unpublished birthday is consistent with two birth years, and the registry may have computed it a refresh before we read it, so the age is anchored to the date we read that page rather than to today. Raise it for a high-recall screening pass: more same-name strangers, fewer missed true matches.

            '
        onAgeMismatch:
          type: string
          enum:
          - drop
          - flag
          default: drop
          description: 'What to do with a record that matches on NAME but whose published age contradicts the searched `dob`. `drop` (default) omits it. `flag` RETURNS it, labelled `matchState: "age_mismatch"`, and lets you judge — "silently omitted" and "checked, and the age contradicts your date" are different facts. A flagged record is always `unverified` and can never be reported as DOB-confirmed.

            '
    SourceRef:
      type: object
      description: Provenance stamp — mandatory on every record's primary source.
      properties:
        jurisdiction:
          type: string
          description: Jurisdiction code, e.g. IL.
          example: IL
        registryName:
          type: string
        recordUrl:
          type: string
          format: uri
          description: Link to the underlying record.
        scrapedAt:
          type: string
          format: date-time
          nullable: true
          description: createdAt basis — when we first recorded it.
        lastCheckedAt:
          type: string
          format: date-time
          nullable: true
        sourceUpdatedAt:
          type: string
          format: date-time
          nullable: true
          description: updatedAt basis — when the source last changed the record.
    Name:
      type: object
      properties:
        first:
          type: string
        middle:
          type: string
        last:
          type: string
        suffix:
          type: string
        full:
          type: string
          description: 'Computed: first middle last suffix, joined.'
    Address:
      type: object
      properties:
        type:
          type: string
          default: residence
          description: 'Address kind. This is an OPEN vocabulary, not a closed enum — treat it as a string with a common case. Values observed in production, by frequency: `residence` (~85%), `employment` (~8%), `other` (~4%), `incarceration`, `H`, `O`, `school`, `transient`, `RL`. The single-letter values are raw registry codes that are not yet normalized. Match `residence` explicitly and bucket everything else rather than switching exhaustively.

            '
          example: residence
        line1:
          type: string
        city:
          type: string
        county:
          type: string
        state:
          type: string
        zipcode:
          type: string
        lat:
          type: number
          nullable: true
          description: Populated only for GIS/geocoded sources.
        lng:
          type: number
          nullable: true
    StateData:
      type: object
      description: 'Parity: offenders.io extensive stateData (retained only for include=stateData/extensive).'
      properties:
        stateOffenderId:
          type: string
        status:
          type: string
          description: 'Where the registrant stands with the registry, in the registry''s own words, or `""`. This is the key that answers *is this person still at liberty?* — and it is distinct from `offense.riskLevel`, which carries a risk classification. Free text, per state: **Florida (FDLE)** publishes nine values — `"Released - Subject to Registration"`, `"Confinement"`, `"Supervised - FL Dept of Corrections"`, `"Supervised - US Probation"`, `"Supervised - FL Dept of Juvenile Justice"`, `"Deported"`, `"Deceased"`, `"Absconded"`, `"Civil Commitment"` — while other states use their own (`"Compliant"`, `"Non-Compliant"`, …). **Match on the exact strings a given state publishes; there is no cross-state enum.** Two of these conditions also have booleans you can read without string matching: `flags.absconder` and, where published, `stateData.incarcerationStatus`.


            ★ **Georgia (GBI)** publishes this instead of an address for registrants it records as moved out of state, deceased, homeless, incarcerated outside Georgia, or out of the country — e.g. `"*** MOVED OUT OF STATE ***"`, `"*** INCARCERATED - OUT OF STATE ***"`, `"ABSCONDER (Address Unknown)"`. Georgia''s coverage is built from GBI''s per-registrant pages as well as its bulk export, so these registrants are returned like any other; read `stateData.status` for why `addresses[]` may be empty on them, and note that address- and radius-filtered queries cannot reach them.

            '
        designation:
          type: string
          description: 'The registry''s statutory CLASSIFICATION of the offender, verbatim — e.g. `"Sexual Predator"`, `"Sexual Offender"`, `"Juvenile Sexual Offender"` — or `""`. Distinct from a risk tier. Where a registry distinguishes a predator class, `flags.predator` mirrors it as a boolean.

            '
        registrationEnds:
          type: string
          description: 'When the registration TERM ends. ISO-8601 (`YYYY-MM-DD` / `YYYY-MM` / `YYYY`) or `""`. ★ READ `datePrecision.registrationEnds` BEFORE YOU TRUST AN EMPTY VALUE HERE. 49,961 records publish something in this field that is not a date at all but a DURATION or a lifetime marker — Wisconsin "15 Years" / "25 Years" / "Life" (25,218), Oklahoma "Lifetime" (6,606), North Dakota "LIFETIME" (742). Those come back as `""` with precision `unparseable` and the literal text in `datesAsPublished`, because a date-typed key must hold a date or nothing. They are NOT missing data, and reading `""` here as "no end date on file" would be wrong for exactly those registrants — check `datesAsPublished.registrationEnds`, and see also `isLifetimeRegistration` and `registrationDuration`.

            '
        datePrecision:
          type: object
          additionalProperties:
            type: string
            enum:
            - exact
            - year_month
            - year
            - none
            - unparseable
          description: 'How much of each date this registry published, one entry for every date key on this object — `registrationEnds`, `lastVerificationDate`, `addressVerificationDate`, `sentenceCompletionDate`, `registrationStarts` — always all five, always present. Values as documented on `Offense.datePrecision`.

            '
        datesAsPublished:
          type: object
          additionalProperties:
            type: string
          description: 'The registry''s ORIGINAL text for any date key on this object whose published form differs from what we now emit; `{}` when none do. This is where "Life", "15 Years" and "Lifetime" live after normalisation — they are preserved, not discarded.

            '
        verificationRequirement:
          type: string
        lawAgency:
          type: string
        judgmentOfConvictionUrl:
          type: string
          format: uri
        vehicles:
          type: array
          items:
            type: object
            additionalProperties: true
            properties:
              plate:
                type: string
                description: 'Plate as printed, usually state-prefixed: "UT F814NW".'
              make:
                type: string
                description: '"Ford", "Kawasaki", "General Motors".'
              model:
                type: string
                description: '"F150", "Motorcycle" — free text, sometimes a class rather than a model.'
              year:
                type: string
                description: 'STRING, not an integer: "2018".'
              color:
                type: string
                description: '"White", "Black Green (Light)" — registry vocabulary, not normalized.'
          description: 'Vehicles the registrant has reported to the registry. Keys are not guaranteed: the five above are what the OffenderWatch cluster prints, and other registries publish different ones — always read defensively. `[]` is AMBIGUOUS and carries three different facts that the response cannot separate: this person reported no vehicle, this registry does not publish vehicles at all, or the detail page has not been fetched for this record yet. Treat `[]` as "no vehicle known", never as "no vehicle owned". Populated in 22 jurisdictions; among records that HAVE a detail page, roughly 27-69% carry at least one (FL 27%, PA 44%, OH 58%, LA 61%).

            '
        photos:
          type: array
          items:
            type: object
            additionalProperties: true
        complianceStatus:
          type: string
          description: e.g. compliant | non-compliant.
        isLifetimeRegistration:
          type: boolean
          nullable: true
          description: True when registration is for life.
        lastVerificationDate:
          type: string
          description: 'When the offender last verified, ISO-8601 or `""`. ★ Format changed 2026-08-04: it was ISO on 85.9% of its populated values and `MM/DD/YYYY` on the rest, despite this description having claimed "ISO date" all along. It is ISO now.

            '
        addressVerificationDate:
          type: string
          description: 'When the address was verified (e.g. KS "Current as of"), ISO-8601 or `""`. ★ Format changed 2026-08-04 — previously ISO on 96.2% of populated values, `MM/DD/YYYY` on the rest.

            '
        incarcerationStatus:
          type: string
          description: e.g. incarcerated | released (e.g. SD IsInJail).
        comments:
          type: string
          description: Free-text registry remarks.
        criminalHistory:
          type: string
          description: Narrative / prior-history summary.
        adjudication:
          type: string
          description: e.g. adult | juvenile.
        registrationDuration:
          type: string
          description: e.g. 10 years | lifetime.
        skinTone:
          type: string
          description: IA skin-tone descriptor (e.g. light | medium | dark).
        residencyRestriction:
          type: string
          description: IA residency constraint (free text).
        employmentRestriction:
          type: string
          description: IA employment constraint (free text).
        exclusionZones:
          type: array
          items:
            type: string
          description: IA geographic zones the offender is barred from.
        district:
          type: string
          description: DC police district.
        psa:
          type: string
          description: DC Police Service Area.
        quadrant:
          type: string
          description: DC quadrant (NW | NE | SW | SE).
        birthCity:
          type: string
          description: Place of birth — city (WY DCI prints a 'Place Of Birth' row on every detail page).
        birthState:
          type: string
          description: Place of birth — state.
        birthCountry:
          type: string
         

# --- truncated at 32 KB (77 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/offendersearch-api/refs/heads/main/openapi/offendersearch-api-batch-api-openapi.yml