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

# Resolve open matches with an allowlist entry

> Marks open matches (no review status, or `unresolved`) as `suppressed` with `suppression_reason: allowlist` when the named live entry covers them, using the same rules as screening. Each accepted match is updated once, with the caller recorded as the actor. Matches that are not accepted, not open, unknown or in another workspace are returned in `skipped[]`, never as an error, so one bad id does not hide the others. The response is `200` even when every match is skipped.

Most integrations use `from-match` with `resolve_match: true` instead. Same credential rule as the capture route.



## OpenAPI

````yaml /api-reference/core.json post /v2/allowlist/resolve
openapi: 3.0.0
info:
  version: 1.6.2
  title: MinervaAI Core API
  description: >-
    The Minerva core monolith, which provides search, consensus, pruning, and
    report generation.
servers:
  - url: https://api.gominerva.com
    description: The production API server for Minerva.
security:
  - ApiKeyAuth: []
tags:
  - name: Search
    description: >-
      Current screening, search, and reporting endpoints for active
      integrations.
  - name: Legacy
    description: >-
      Legacy endpoints retained for backwards compatibility. Prefer the
      canonical POST-based search flows for new integrations.
  - name: API to UI Integration
    description: Endpoints used to bridge API integrations with Minerva UI workflows.
  - name: Potential Matches
    description: Update review workflow state for potential matches returned by searches.
  - name: Allowlists
    description: >-
      Capture a potential match for an allowlist entry and resolve open matches
      with a live entry. Allowlists themselves are managed through the custom
      lists Admin API.
paths:
  /v2/allowlist/resolve:
    post:
      tags:
        - Allowlists
      summary: Resolve open matches with an allowlist entry
      description: >-
        Marks open matches (no review status, or `unresolved`) as `suppressed`
        with `suppression_reason: allowlist` when the named live entry covers
        them, using the same rules as screening. Each accepted match is updated
        once, with the caller recorded as the actor. Matches that are not
        accepted, not open, unknown or in another workspace are returned in
        `skipped[]`, never as an error, so one bad id does not hide the others.
        The response is `200` even when every match is skipped.


        Most integrations use `from-match` with `resolve_match: true` instead.
        Same credential rule as the capture route.
      parameters:
        - name: x-workspace-id
          in: header
          required: true
          description: The workspace the matches belong to.
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/AllowlistResolveRequest'
      responses:
        '200':
          description: The outcome per match.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AllowlistResolveResponse'
        '400':
          description: >-
            `reason: resolve_requires_live_entry` when `record_uid` is not in
            the version, the version is not bound and no valid `artifact` was
            given, or the named version exceeds the supported allowlist size.
            `code: error/invalid-parameters` for more than 200 `match_ids` or a
            malformed body. `x-workspace-id` missing.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AllowlistApiError'
              example:
                status: 400
                code: error/bad-request
                message: >-
                  The named version exceeds the supported allowlist size, so it
                  cannot be used for this list.
                reason: resolve_requires_live_entry
        '401':
          description: Missing or invalid credential.
        '403':
          description: >-
            The key is not an Admin (tenant-wide) application key of this
            tenant, or the user is not an owner or admin.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AllowlistApiError'
              example:
                status: 403
                code: auth/unauthorized
                message: >-
                  This credential cannot manage allowlists: an admin tenant key
                  or an owner/admin user is required.
        '404':
          description: The list belongs to another tenant.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AllowlistApiError'
      security:
        - ApiKeyAuth: []
components:
  schemas:
    AllowlistResolveRequest:
      type: object
      required:
        - match_ids
        - list_id
        - record_uid
        - version_id
      properties:
        match_ids:
          type: array
          minItems: 1
          maxItems: 200
          items:
            type: string
        list_id:
          type: string
        record_uid:
          type: string
        version_id:
          type: string
          description: >-
            The allowlist version that contains the entry. A version that is not
            bound to the workspace needs `artifact`.
        artifact:
          type: object
          description: >-
            Optional. Locates a just-published version that is not bound yet;
            ignored when `version_id` is the bound version.
          properties:
            key:
              type: string
            version_id:
              type: string
            checksum:
              type: string
      example:
        match_ids:
          - MATCH_ID
        list_id: LIST_ID
        record_uid: al_ENTRY_UID
        version_id: VERSION_ID
    AllowlistResolveResponse:
      type: object
      required:
        - resolved_match_ids
        - skipped
      properties:
        resolved_match_ids:
          type: array
          items:
            type: string
        skipped:
          type: array
          items:
            type: object
            properties:
              match_id:
                type: string
              reason:
                type: string
                enum:
                  - subject_not_matched
                  - details_not_matched
                  - screened_name_is_record
                  - record_not_covered
                  - record_changed
                  - not_open
                  - not_live_yet
                description: >-
                  `not_open`: the match is not open (already reviewed, reopened,
                  unknown, or in another workspace). `not_live_yet`: the entry's
                  version is not readable yet or the list has no enabled
                  binding.
      example:
        resolved_match_ids:
          - m_5b1c
        skipped:
          - match_id: m_77aa
            reason: record_not_covered
    AllowlistApiError:
      type: object
      properties:
        status:
          type: integer
          example: 400
        code:
          type: string
          example: error/bad-request
        message:
          type: string
        reason:
          type: string
          description: >-
            Present for allowlist-specific cases, for example
            `resolve_requires_live_entry`.
          example: resolve_requires_live_entry
      required:
        - status
        - code
        - message
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        The Minerva API key used for this integration. Manage API keys in the
        Minerva dashboard under Administration > Developers.

````

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