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

# Search again on a value of one of a person's records.

> Starts a new search on the value of one field of one of the person's records: a lookup's, a profile's or one an earlier search found. Name the record and the field; the value itself is not sent. The field's kind must be email, phone, username, person_name, password, hash, ip or domain. A domain search finds the breach rows of every email address at the domain, which must be a registrable domain or a host under one; any other domain answers 400. Nothing ever searches again by itself: a search starts only when a person asks. The search runs the breach search and the account and phone lookups that take the value's kind, under the environment's source controls, and finishes seconds later. A password or hash search counts first: it stops at counted with rows, how many breach rows hold the value, and runs only when a person runs it. Name a table, as a lookup remaining entry names it, to fetch the rows an earlier search left out, up to 100. What the search finds joins the person's lookup records as leads, each match naming the search; the person report lists the searches, each with the value and the record and field it came from, and its records are scored like the rest. Without an Idempotency-Key, starting the same open search returns it. Its estimate counts against the environment's screening_daily_cap, and one the cap cannot hold answers 409 screening_cap_exceeded. A record or field the person does not hold answers 404. Each search is audited as person.search_started. Send an Idempotency-Key to retry safely: the same key and request return the same resource in its current state while it is retained, even after work completes. Reusing the key with different input answers 409 idempotency_key_reused. Use a new key for a deliberate new operation. The investigations scope grants this operation. Explicit evidence.read restrictions override default evidence access. The groups scope is also accepted for existing integrations. The API key selects the workspace and environment.



## OpenAPI

````yaml /openapi.json post /v1/groups/{group_id}/people/{person_id}/searches
openapi: 3.1.0
info:
  title: NoResponse API
  version: '1'
  description: >-
    NoResponse is an identity and people risk engine. Create workspace people,
    start investigations, read complete source evidence and retain job history.
    Groups organize people for screening and contextual review. Account
    assessment uses the same engine for account creation, login and purchase
    decisions.


    Authenticate every request with your API key as `Authorization: Bearer
    nrk_...`. Call the API only from your backend.


    Guides, SDKs and webhook verification are at
    [docs.noresponse.org](https://docs.noresponse.org/). Every error is an RFC
    9457 problem document; see
    [Errors](https://docs.noresponse.org/reference/errors).
servers:
  - url: https://api.noresponse.org
    description: Production
security:
  - tenantBearer: []
tags:
  - name: people
    x-displayName: People
    x-group: People
    description: >-
      Retain people in one workspace environment, with submitted identity,
      expiry and source evidence.
  - name: investigations
    x-displayName: Investigations
    x-group: Investigations
    description: >-
      Start person investigations, read job history and record context-specific
      review decisions.
  - name: assess
    x-displayName: Assessments
    x-group: Assessments
    description: Create, read and list assessments, and report outcomes.
  - name: accounts
    x-displayName: Accounts
    x-group: Accounts
    description: >-
      Each of your accounts holds one current risk, and its assessments are its
      history.
  - name: usage
    x-displayName: Key usage
    x-group: Key usage
    description: >-
      Report usage of the API keys that your account creation gate issued, so a
      shared or stolen key raises its account's risk.
  - name: keys
    x-displayName: API keys
    x-group: API keys
    description: >-
      Rotate your own API key and, with the `management` scope, create, list and
      revoke the keys of its environment.
  - name: settings
    x-displayName: Settings
    x-group: Settings
    description: >-
      Read and preview environment settings, run evaluations, and publish
      reviewed policy with separate permissions.
  - name: lists
    x-displayName: Lists
    x-group: Lists
    description: >-
      Preview, allow or block accounts that use an email or email domain.
      Publishing changes requires policy authority.
  - name: integrations
    x-displayName: Integrations
    x-group: Integrations
    description: >-
      Hosted endpoints that answer your WorkOS, Auth0 or Supabase sign-up and
      sign-in hooks.
  - name: webhooks
    x-displayName: Webhooks
    x-group: Webhooks
    description: Your webhook endpoints, and the signed events NoResponse sends to them.
  - name: workspaces
    x-displayName: Workspaces
    x-group: Workspaces
    description: >-
      Manage non-owner team access, read usage and audit events, configure audit
      streams, and export retained account or audit data.
  - name: requests
    x-displayName: Request diagnostics
    x-group: Request diagnostics
    description: Search retained request attempts and summarize their status and latency.
  - name: groups
    x-displayName: Groups
    x-group: Groups
    description: >-
      Screen a group's people: create the group, upload its list of people,
      start screenings and record a decision on each person.
  - name: reviews
    x-displayName: Reviews
    x-group: Reviews
    description: >-
      Investigate accounts with assignments, comments, linked evidence, saved
      filters and recorded resolutions.
paths:
  /v1/groups/{group_id}/people/{person_id}/searches:
    post:
      tags:
        - groups
      summary: Search again on a value of one of a person's records.
      description: >-
        Starts a new search on the value of one field of one of the person's
        records: a lookup's, a profile's or one an earlier search found. Name
        the record and the field; the value itself is not sent. The field's kind
        must be email, phone, username, person_name, password, hash, ip or
        domain. A domain search finds the breach rows of every email address at
        the domain, which must be a registrable domain or a host under one; any
        other domain answers 400. Nothing ever searches again by itself: a
        search starts only when a person asks. The search runs the breach search
        and the account and phone lookups that take the value's kind, under the
        environment's source controls, and finishes seconds later. A password or
        hash search counts first: it stops at counted with rows, how many breach
        rows hold the value, and runs only when a person runs it. Name a table,
        as a lookup remaining entry names it, to fetch the rows an earlier
        search left out, up to 100. What the search finds joins the person's
        lookup records as leads, each match naming the search; the person report
        lists the searches, each with the value and the record and field it came
        from, and its records are scored like the rest. Without an
        Idempotency-Key, starting the same open search returns it. Its estimate
        counts against the environment's screening_daily_cap, and one the cap
        cannot hold answers 409 screening_cap_exceeded. A record or field the
        person does not hold answers 404. Each search is audited as
        person.search_started. Send an Idempotency-Key to retry safely: the same
        key and request return the same resource in its current state while it
        is retained, even after work completes. Reusing the key with different
        input answers 409 idempotency_key_reused. Use a new key for a deliberate
        new operation. The investigations scope grants this operation. Explicit
        evidence.read restrictions override default evidence access. The groups
        scope is also accepted for existing integrations. The API key selects
        the workspace and environment.
      operationId: startSearch
      parameters:
        - $ref: '#/components/parameters/GroupId'
        - $ref: '#/components/parameters/PersonId'
        - $ref: '#/components/parameters/ResourceIdempotencyKey'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/SearchRequest'
      responses:
        '202':
          $ref: '#/components/responses/SearchAccepted'
        '400':
          $ref: '#/components/responses/InvalidGroupRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/ControlForbidden'
        '404':
          $ref: '#/components/responses/WorkspaceNotFound'
        '409':
          $ref: '#/components/responses/GroupConflict'
        '415':
          $ref: '#/components/responses/UnsupportedMediaType'
        '503':
          $ref: '#/components/responses/ServiceUnavailable'
      security:
        - tenantBearer: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |
            curl --request POST \
              --url 'https://api.noresponse.org/v1/groups/grp_01JA2Z8K6Q4V7W9XBCDEFGHJKM/people/per_01JA2Z8K6Q4V7W9XBCDEFGHJKM/searches' \
              --header "Authorization: Bearer $NORESPONSE_API_KEY" \
              --header 'Content-Type: application/json' \
              --header 'Idempotency-Key: request-01JA2Z8K6Q4V7W9XBCDEFGHJKM' \
              --data '{
              "record_id": "rec_3f9a1c22d4e5b6a73f9a1c22d4e5b6a7",
              "field": "username",
              "table": "FORUM_EXAMPLE_COM_2019"
            }'
        - lang: typescript
          label: TypeScript
          source: |
            import { NoResponse } from "@noresponse/node";

            const noResponse = new NoResponse({
              apiKey: process.env["NORESPONSE_API_KEY"] ?? "",
            });

            async function run() {
              const result = await noResponse.groups.startSearch({
                groupId: "grp_01JA2Z8K6Q4V7W9XBCDEFGHJKM",
                personId: "per_01JA2Z8K6Q4V7W9XBCDEFGHJKM",
                idempotencyKey: "request-01JA2Z8K6Q4V7W9XBCDEFGHJKM",
                body: {
                  recordId: "rec_3f9a1c22d4e5b6a73f9a1c22d4e5b6a7",
                  field: "username",
                  table: "FORUM_EXAMPLE_COM_2019",
                },
              });

              console.log(result);
            }

            run();
        - lang: python
          label: Python
          source: |
            from noresponse import NoResponse
            import os


            with NoResponse(
                api_key=os.getenv("NORESPONSE_API_KEY", ""),
            ) as no_response:

                res = no_response.groups.start_search(group_id="grp_01JA2Z8K6Q4V7W9XBCDEFGHJKM", person_id="per_01JA2Z8K6Q4V7W9XBCDEFGHJKM", record_id="rec_3f9a1c22d4e5b6a73f9a1c22d4e5b6a7", field="username", idempotency_key="request-01JA2Z8K6Q4V7W9XBCDEFGHJKM", table="FORUM_EXAMPLE_COM_2019")

                # Handle response
                print(res)
        - lang: go
          label: Go
          source: "package main\n\nimport(\n\t\"context\"\n\t\"os\"\n\tnoresponse \"github.com/noresponsehq/go/v14\"\n\t\"github.com/noresponsehq/go/v14/models/components\"\n\t\"log\"\n)\n\nfunc main() {\n    ctx := context.Background()\n\n    s := noresponse.New(\n        noresponse.WithSecurity(os.Getenv(\"NORESPONSE_API_KEY\")),\n    )\n\n    res, err := s.Groups.StartSearch(ctx, \"grp_01JA2Z8K6Q4V7W9XBCDEFGHJKM\", \"per_01JA2Z8K6Q4V7W9XBCDEFGHJKM\", components.SearchRequest{\n        RecordID: \"rec_3f9a1c22d4e5b6a73f9a1c22d4e5b6a7\",\n        Field: \"username\",\n        Table: noresponse.Pointer(\"FORUM_EXAMPLE_COM_2019\"),\n    }, noresponse.Pointer(\"request-01JA2Z8K6Q4V7W9XBCDEFGHJKM\"))\n    if err != nil {\n        log.Fatal(err)\n    }\n    if res != nil {\n        // handle response\n    }\n}\n"
        - lang: java
          label: Java
          source: |
            package hello.world;

            import java.lang.Exception;
            import org.noresponse.NoResponse;
            import org.noresponse.models.errors.AuthenticationException;
            import org.noresponse.models.errors.BadRequestException;
            import org.noresponse.models.errors.ConflictException;
            import org.noresponse.models.errors.NotFoundException;
            import org.noresponse.models.errors.PermissionDeniedException;
            import org.noresponse.models.errors.RateLimitException;
            import org.noresponse.models.operations.StartSearchResponse;
            import org.noresponse.models.shared.SearchRequest;

            public class Application {

                public static void main(String[] args) throws Exception {

                    NoResponse sdk = NoResponse.builder()
                            .apiKey(System.getenv().getOrDefault("NORESPONSE_API_KEY", ""))
                        .build();

                    StartSearchResponse res = sdk.groups().startSearch()
                            .groupId("grp_01JA2Z8K6Q4V7W9XBCDEFGHJKM")
                            .personId("per_01JA2Z8K6Q4V7W9XBCDEFGHJKM")
                            .idempotencyKey("request-01JA2Z8K6Q4V7W9XBCDEFGHJKM")
                            .body(SearchRequest.builder()
                                .recordId("rec_3f9a1c22d4e5b6a73f9a1c22d4e5b6a7")
                                .field("username")
                                .table("FORUM_EXAMPLE_COM_2019")
                                .build())
                            .call();

                    if (res.search().isPresent()) {
                        System.out.println(res.search().get());
                    }
                }
            }
        - lang: csharp
          label: C#
          source: >
            using NoResponse;

            using NoResponse.Models.Shared;

            using System;


            var sdk = new NoResponseClient(apiKey:
            Environment.GetEnvironmentVariable("NORESPONSE_API_KEY"));


            var res = await sdk.Groups.StartSearchAsync(
                groupId: "grp_01JA2Z8K6Q4V7W9XBCDEFGHJKM",
                personId: "per_01JA2Z8K6Q4V7W9XBCDEFGHJKM",
                body: new SearchRequest() {
                    RecordId = "rec_3f9a1c22d4e5b6a73f9a1c22d4e5b6a7",
                    Field = "username",
                    Table = "FORUM_EXAMPLE_COM_2019",
                },
                idempotencyKey: "request-01JA2Z8K6Q4V7W9XBCDEFGHJKM"
            );


            // handle response
        - lang: php
          label: PHP
          source: |
            <?php

            declare(strict_types=1);

            require 'vendor/autoload.php';

            use NoResponse;
            use NoResponse\Models\Shared;

            $sdk = NoResponse\NoResponseClient::builder()
                ->setSecurity(
                    getenv('NORESPONSE_API_KEY') ?: ''
                )
                ->build();

            $body = new Shared\SearchRequest(
                recordId: 'rec_3f9a1c22d4e5b6a73f9a1c22d4e5b6a7',
                field: 'username',
                table: 'FORUM_EXAMPLE_COM_2019',
            );

            $response = $sdk->groups->startSearch(
                groupId: 'grp_01JA2Z8K6Q4V7W9XBCDEFGHJKM',
                personId: 'per_01JA2Z8K6Q4V7W9XBCDEFGHJKM',
                body: $body,
                idempotencyKey: 'request-01JA2Z8K6Q4V7W9XBCDEFGHJKM'

            );

            $result = $response->result;
            // handle response
        - lang: ruby
          label: Ruby
          source: >
            require 'noresponse'


            Models = ::NoResponse::Models

            s = ::NoResponse::NoResponseClient.new(
              api_key: ENV.fetch('NORESPONSE_API_KEY', '')
            )

            res = s.groups.start_search(group_id:
            'grp_01JA2Z8K6Q4V7W9XBCDEFGHJKM', person_id:
            'per_01JA2Z8K6Q4V7W9XBCDEFGHJKM', body:
            Models::Shared::SearchRequest.new(
              record_id: 'rec_3f9a1c22d4e5b6a73f9a1c22d4e5b6a7',
              field: 'username',
              table: 'FORUM_EXAMPLE_COM_2019'
            ), idempotency_key: 'request-01JA2Z8K6Q4V7W9XBCDEFGHJKM')


            unless res.nil?
              # handle response
            end
components:
  parameters:
    GroupId:
      name: group_id
      in: path
      required: true
      schema:
        type: string
        pattern: ^grp_[0-7][0-9A-HJKMNP-TV-Z]{25}$
    PersonId:
      name: person_id
      in: path
      required: true
      schema:
        type: string
        pattern: ^per_[0-7][0-9A-HJKMNP-TV-Z]{25}$
    ResourceIdempotencyKey:
      name: Idempotency-Key
      in: header
      required: false
      description: >-
        Opaque request key, 16 to 128 characters. Repeating the key and request
        returns the same resource in its current state while it is retained. A
        different request with the same key answers 409. Use a new key for a
        deliberate new operation. Keys are scoped to the environment and
        operation; person searches also scope them to the group and person.
      schema:
        type: string
        minLength: 16
        maxLength: 128
        pattern: ^[A-Za-z0-9._:-]{16,128}$
        not:
          pattern: \n
  schemas:
    SearchRequest:
      type: object
      additionalProperties: false
      required:
        - record_id
        - field
      properties:
        record_id:
          type: string
          pattern: ^rec_[0-9a-f]{32}$
          description: >-
            One of the person's records: a lookup's, a profile's or one an
            earlier search found.
        field:
          type: string
          minLength: 1
          maxLength: 500
          description: >-
            The name of the record's field whose value to search. Its kind must
            be email, phone, username, person_name, password, hash, ip or
            domain, and it must have a value: a field the source masked or that
            could not be cleaned is not searched.
        table:
          type: string
          minLength: 1
          maxLength: 500
          description: >-
            Search only this breach table, as a remaining entry names it, to
            fetch the rows an earlier search left out. Not for a phone.
      description: >-
        The value to search again, named by the record and field that hold it
        rather than sent again.
    Search:
      type: object
      additionalProperties: false
      required:
        - search_id
        - record_id
        - field
        - kind
        - value
        - status
        - sources
        - answered
        - found
        - estimated_spend
        - spent
        - requested_by
        - created_at
      properties:
        search_id:
          type: string
          pattern: ^srh_[0-7][0-9A-HJKMNP-TV-Z]{25}$
        record_id:
          type: string
          pattern: ^rec_[0-9a-f]{32}$
          description: The record whose value led to the search.
        field:
          type: string
          minLength: 1
          maxLength: 500
          description: The field of that record that holds the value.
        table:
          type: string
          minLength: 1
          maxLength: 500
          description: The one breach table searched, when the search was of one table.
        kind:
          enum:
            - email
            - phone
            - username
            - person_name
            - password
            - hash
            - ip
            - domain
          description: >-
            The kind of the value searched. A domain search finds the leaked
            rows of every email address at the domain.
        value:
          type: string
          description: >-
            The searched value. Empty in person reports when evidence.read is
            denied.
        status:
          enum:
            - counting
            - counted
            - queued
            - running
            - completed
            - partial
            - failed
          description: >-
            A password or hash search is counting, then counted: rows says how
            many breach rows hold the value, and nothing runs until a person
            runs it (POST.../searches/{search_id}/run). Any other search is
            queued, then running. completed: every source it asked answered.
            partial: some did not. failed: none answered or none could be asked,
            which says nothing about whether the value is held anywhere.
        rows:
          type: integer
          minimum: 0
          description: >-
            How many breach rows hold the password or hash, counted before the
            search runs.
        sources:
          type: integer
          minimum: 0
          description: >-
            How many sources the search asked: the breach search and the account
            and phone lookups that take the value's kind.
        answered:
          type: integer
          minimum: 0
          description: How many of them gave a definite answer, found or not found.
        found:
          type: integer
          minimum: 0
          description: >-
            How many records the search found. They are among the person
            report's lookup records, each match naming this search.
        estimated_spend:
          type: integer
          minimum: 0
          description: >-
            What the search may spend, in US cents, held against the
            environment's daily screening cap while it runs.
        spent:
          type: integer
          minimum: 0
          description: What the search spent, in US cents, metered as screening work.
        error_code:
          enum:
            - not_answered
            - no_source
            - worker_attempts_exhausted
          description: >-
            Why a failed search found nothing: its sources did not answer, none
            could be asked, or it could not run before its attempts were spent.
        requested_by:
          type: string
          minLength: 1
          maxLength: 256
          description: Who started the search.
        created_at:
          type: string
          format: date-time
        finished_at:
          type: string
          format: date-time
      description: >-
        One search a person started on a value of one of a person's records.
        Nothing searches again by itself.
    Problem:
      title: Problem details error
      description: >-
        RFC 9457 problem-details error body returned by every non-2xx API
        response, extended with a stable machine code and request id.
      type: object
      additionalProperties: false
      required:
        - type
        - title
        - status
        - detail
        - code
        - request_id
      properties:
        type:
          type: string
          format: uri-reference
        title:
          type: string
        status:
          type: integer
          minimum: 400
          maximum: 599
        detail:
          type: string
        instance:
          type: string
          format: uri-reference
        code:
          type: string
        request_id:
          type: string
          minLength: 1
        invalid_params:
          type: array
          items:
            type: object
            additionalProperties: false
            required:
              - field
              - reason
            properties:
              field:
                type: string
                minLength: 1
              reason:
                type: string
                minLength: 1
              example:
                type: string
                minLength: 1
  responses:
    SearchAccepted:
      description: >-
        The search: counting, or queued to run. Read the person after
        Retry-After to see its status, its count and what it found.
      headers:
        Cache-Control:
          schema:
            type: string
            const: no-store
          required: true
        X-Request-ID:
          description: The request correlation id, 32 lowercase hexadecimal characters.
          schema:
            type: string
            pattern: ^[0-9a-f]{32}$
            not:
              pattern: \n
          required: true
        Retry-After:
          description: Whole seconds to wait before reading the person.
          schema:
            type: string
            pattern: ^[1-9][0-9]{0,3}$
          required: true
        Idempotent-Replayed:
          schema:
            type: boolean
          description: >-
            True when this response reuses the resource created by this request
            key.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Search'
    InvalidGroupRequest:
      description: >-
        The body or query is invalid, or Idempotency-Key is missing, repeated or
        malformed.
      headers:
        Cache-Control:
          schema:
            type: string
            const: no-store
          required: true
        X-Request-ID:
          description: The request correlation id, 32 lowercase hexadecimal characters.
          schema:
            type: string
            pattern: ^[0-9a-f]{32}$
            not:
              pattern: \n
          required: true
      content:
        application/problem+json:
          schema:
            allOf:
              - $ref: '#/components/schemas/Problem'
              - properties:
                  status:
                    const: 400
                  code:
                    enum:
                      - invalid_request
                      - invalid_idempotency_key
    Unauthorized:
      description: No API key, or one that is malformed, unknown, revoked or expired.
      headers:
        Cache-Control:
          schema:
            type: string
            const: no-store
          required: true
        WWW-Authenticate:
          schema:
            type: string
            const: Bearer realm="noresponse-assessments"
          required: true
        X-Request-ID:
          description: The request correlation id, 32 lowercase hexadecimal characters.
          schema:
            type: string
            pattern: ^[0-9a-f]{32}$
            not:
              pattern: \n
          required: true
      content:
        application/problem+json:
          schema:
            allOf:
              - $ref: '#/components/schemas/Problem'
              - properties:
                  status:
                    const: 401
                  code:
                    enum:
                      - unauthorized
    ControlForbidden:
      description: >-
        workspace_forbidden: an API key without the management scope, or any API
        key on a route other than the key, settings and list routes.
        role_forbidden: a console credential's acting user is an active member
        whose role does not grant the operation.
      headers:
        Cache-Control:
          schema:
            type: string
            const: no-store
          required: true
        X-Request-ID:
          description: The request correlation id, 32 lowercase hexadecimal characters.
          schema:
            type: string
            pattern: ^[0-9a-f]{32}$
            not:
              pattern: \n
          required: true
      content:
        application/problem+json:
          schema:
            allOf:
              - $ref: '#/components/schemas/Problem'
              - properties:
                  status:
                    const: 403
                  code:
                    enum:
                      - workspace_forbidden
                      - role_forbidden
    WorkspaceNotFound:
      description: >-
        No such workspace, member, invite, key or environment for the caller. A
        workspace the acting user is not an active member of answers this too,
        as do another workspace and the other environment to an API key, so no
        answer shows which workspaces exist.
      headers:
        Cache-Control:
          schema:
            type: string
            const: no-store
          required: true
        X-Request-ID:
          description: The request correlation id, 32 lowercase hexadecimal characters.
          schema:
            type: string
            pattern: ^[0-9a-f]{32}$
            not:
              pattern: \n
          required: true
      content:
        application/problem+json:
          schema:
            allOf:
              - $ref: '#/components/schemas/Problem'
              - properties:
                  status:
                    const: 404
                  code:
                    enum:
                      - not_found
    GroupConflict:
      description: >-
        The group or screening's state does not allow the change, a bound is
        reached, the Idempotency-Key was used for another body, the environment
        cannot screen yet, or the screening's estimate exceeds what the daily
        screening cap has left.
      headers:
        Cache-Control:
          schema:
            type: string
            const: no-store
          required: true
        X-Request-ID:
          description: The request correlation id, 32 lowercase hexadecimal characters.
          schema:
            type: string
            pattern: ^[0-9a-f]{32}$
            not:
              pattern: \n
          required: true
      content:
        application/problem+json:
          schema:
            allOf:
              - $ref: '#/components/schemas/Problem'
              - properties:
                  status:
                    const: 409
                  code:
                    enum:
                      - group_conflict
                      - group_limit_reached
                      - idempotency_key_reused
                      - screening_cap_exceeded
                      - screening_unavailable
    UnsupportedMediaType:
      description: Content-Type is not application/json.
      headers:
        Cache-Control:
          schema:
            type: string
            const: no-store
          required: true
        X-Request-ID:
          description: The request correlation id, 32 lowercase hexadecimal characters.
          schema:
            type: string
            pattern: ^[0-9a-f]{32}$
            not:
              pattern: \n
          required: true
      content:
        application/problem+json:
          schema:
            allOf:
              - $ref: '#/components/schemas/Problem'
              - properties:
                  status:
                    const: 415
                  code:
                    enum:
                      - unsupported_media_type
    ServiceUnavailable:
      description: >-
        The assessment could not be admitted at all (overload, shutdown or a
        dependency down). An assessment that was admitted answers partial or
        pending instead of 503.
      headers:
        Cache-Control:
          schema:
            type: string
            const: no-store
          required: true
        Retry-After:
          description: >-
            Whole seconds to wait before polling or retrying. Required on 202,
            429 and 503.
          schema:
            type: string
            pattern: >-
              ^(?:[1-9]|[1-9][0-9]|[1-9][0-9]{2}|[12][0-9]{3}|3[0-5][0-9]{2}|3600)$
            description: Whole decimal seconds; wait at least this long.
          required: true
        X-Request-ID:
          description: The request correlation id, 32 lowercase hexadecimal characters.
          schema:
            type: string
            pattern: ^[0-9a-f]{32}$
            not:
              pattern: \n
          required: true
      content:
        application/problem+json:
          schema:
            allOf:
              - $ref: '#/components/schemas/Problem'
              - properties:
                  status:
                    const: 503
                  code:
                    enum:
                      - service_unavailable
  securitySchemes:
    tenantBearer:
      type: http
      scheme: bearer
      description: >-
        Your API key, sent as `Authorization: Bearer <key>`. A key is
        `nrk_live_` or `nrk_test_`, a 26-character key id, `_` and a
        43-character secret. Account, audit and usage data stay within the key's
        environment. Dedicated team scopes apply across the workspace.


        `assess` creates and reads assessments, records outcomes and reports key
        usage. `investigate` reads accounts, assessment history and request
        diagnostics without export or enforcement access. The legacy `history`
        scope also permits account exports, submitted identifiers and
        enforcement reports. `delete` permits account and assessment deletion.


        `evidence` or `detailed` adds detailed merged evidence and submitted
        identifiers where the operation permits them. Neither grants access to
        the underlying resource alone. `exports` permits exports with the
        underlying account or audit scope. `audit` reads audit events and
        `usage` reads usage. `audit_manage` manages audit streams and retention,
        and includes audit-read and export authority.


        `webhooks` manages webhook endpoints. `integrations` manages hosted
        auth-provider integrations. `management` manages keys, settings, lists,
        reviews and policy evaluations in the key's environment. New keys cannot
        exceed the issuer's effective permissions.


        `settings` reads configuration, previews policy and list changes, runs
        evaluations and changes retention. Publishing decision policy or
        changing lists requires `settings` and `policy_publish` together, or the
        legacy `management` scope.


        `people` reads people, groups and investigations with full evidence by
        default. `people_write` changes submitted people, groups and
        memberships. `investigations` starts or cancels jobs and screenings.
        `decisions` records reviews. `exports` with people-read access exports
        rosters. `delete` deletes people, groups and memberships. Existing
        `groups` keys retain non-destructive people access. Explicit
        `evidence.read` restrictions withhold collected records, posts, media,
        discovered identifiers and notes.


        `members` reads the workspace directory. `members_manage` also
        administers non-owner members and invitations. These scopes require a
        live key issued by a current owner with access to both environments.
        They grant access across the workspace. `management` does not grant team
        access. API keys cannot change owners or accept invitations.


        A missing, unknown, revoked or expired key answers 401. A valid key
        without a required scope answers 403.

````

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