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

# Revisar Proposal de la organización

> Records your organization's decision on a proposal that is waiting on you — one ChainPatrol escalated to you, or one on a report you submitted yourself. These are exactly the proposals your Review page shows and the ones `GET /organization/reports?needsCustomerReview=true` counts; find their IDs in `proposals[].id` on that endpoint. `APPROVE` blocks the asset and takes a `label` (plus a `brandId` for labels that name a specific brand). `REJECT` takes a `rejectReason`. `WATCHLIST` rejects the proposal and parks the asset so it is re-evaluated if it comes back alive.

Pass `assetId` alongside `proposalId`; it must match the proposal's current asset or the request returns `409`, which keeps a caller from actioning a proposal it never read.

Approvals are held to the same safety checks as the Review page, with no override: an asset that any enabled legitimacy rule marks as legitimate cannot be approved here, and an allowlisted asset cannot be blocked here. Both return `403` and must be handled on the Review page by a person.

Rate limited to 10 reviews per organization per day, since a review is not undoable and looping over a queue is easy to do by accident. Exceeding it returns `429`. The limit is shared across all of the organization's API credentials and does not apply to reviews made from the Review page.

## Descripción general

Registra la decisión de tu organización sobre una **Proposal** (propuesta para bloquear o permitir un asset) que está esperando por ti: una que ChainPatrol te escaló o una de un reporte que tú mismo enviaste. Son exactamente las Proposals que muestra tu página **Review** (revisión de propuestas pendientes de aprobación) y las que cuenta [`GET /organization/reports?needsCustomerReview=true`](https://chainpatrol.com/docs/es/external-api/organization-reports-list), así que este endpoint te permite vaciar esa cola sin abrir la app web.

Hay un solo endpoint para los tres resultados posibles, que se distinguen por `decision`:

| Decisión | Qué hace | También se requiere |
| - | - | - |
| `APPROVE` | Bloquea el **Asset** (activo digital: URL, dirección, perfil, app, etc.) | `label` (más `brandId` en las etiquetas que nombran un objetivo específico) |
| `REJECT` | Rechaza la Proposal | `rejectReason` |
| `WATCHLIST` | Rechaza la Proposal **y** deja el asset en la **Watchlist** (lista de seguimiento de assets sospechosos que se siguen monitoreando) para que se vuelva a evaluar si vuelve a estar activo | `watchlistReason` (más `note` cuando el motivo es `OTHER`) |

`WATCHLIST` es una variante del rechazo y no un resultado aparte: se guarda como una revisión `REJECT` con el asset agregado a la Watchlist, que es la misma escritura que hace la página Review. Por eso una respuesta exitosa de Watchlist vuelve con `review.decision: "REJECT"` y `watchlisted: true`.

> [!WARNING]
>
> Una revisión no se puede deshacer a través de la API. `APPROVE` bloquea el asset y, como los assets son únicos por tipo y contenido, ese estado es global y no se limita a tu organización. Lee la Proposal antes de actuar sobre ella y usa el [límite de revisiones](#límite-de-revisiones) como un resguardo, no como una meta.

## Inicio rápido

### Autenticación

Incluye tu clave de API en el encabezado `X-API-KEY`:

```bash theme={null}
X-API-KEY: your_api_key_here
```

### Cómo encontrar una Proposal para revisar

Los dos ID que necesita este endpoint salen del listado de reportes. Pide las Proposals que están esperando por ti y luego lee `proposals[].id` y `proposals[].asset.id`:

```bash cURL theme={null}
curl -X GET 'https://app.chainpatrol.io/api/v2/organization/reports?needsCustomerReview=true&limit=10' \
  -H 'X-API-KEY: YOUR_API_KEY_HERE'
```

### Solicitud de ejemplo

```typescript TypeScript theme={null}
const response = await fetch(
  "https://app.chainpatrol.io/api/v2/organization/proposals/4321/review",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": "YOUR_API_KEY_HERE",
    },
    body: JSON.stringify({
      assetId: 987,
      decision: "APPROVE",
      label: "General Phishing",
    }),
  }
);

const data = await response.json();
console.log(data.proposal.asset.status); // "BLOCKED"
```

```javascript JavaScript theme={null}
const response = await fetch(
  "https://app.chainpatrol.io/api/v2/organization/proposals/4321/review",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": "YOUR_API_KEY_HERE",
    },
    body: JSON.stringify({
      assetId: 987,
      decision: "APPROVE",
      label: "General Phishing",
    }),
  }
);

const data = await response.json();
console.log(data.proposal.asset.status); // "BLOCKED"
```

```python Python theme={null}
import requests

response = requests.post(
    "https://app.chainpatrol.io/api/v2/organization/proposals/4321/review",
    headers={
        "Content-Type": "application/json",
        "X-API-KEY": "YOUR_API_KEY_HERE",
    },
    json={
        "assetId": 987,
        "decision": "APPROVE",
        "label": "General Phishing",
    },
)

data = response.json()
print(data["proposal"]["asset"]["status"])  # "BLOCKED"
```

```bash cURL theme={null}
curl -X POST 'https://app.chainpatrol.io/api/v2/organization/proposals/4321/review' \
  -H 'Content-Type: application/json' \
  -H 'X-API-KEY: YOUR_API_KEY_HERE' \
  -d '{
    "assetId": 987,
    "decision": "APPROVE",
    "label": "General Phishing"
  }'
```

## Cuerpo de la solicitud

| Campo | Tipo | Obligatorio | Descripción |
| - | - | - | - |
| assetId | number | Sí | El asset al que apunta esta Proposal, tomado de `proposals[].asset.id`. Debe coincidir con el asset actual de la Proposal o la solicitud devuelve `409`. |
| decision | string | Sí | `APPROVE`, `REJECT` o `WATCHLIST`. |
| slug | string | No | Slug de la organización. Opcional para las claves de API con alcance de organización; obligatorio cuando tus credenciales tienen acceso a más de una organización. |
| label | string | Al aprobar | Por qué se bloquea el asset. Consulta [Etiquetas de bloqueo](#etiquetas-de-bloqueo). |
| brandId | number | Condicional | Marca que el asset suplanta. Obligatorio para `Brand Impersonation` y `Employee Impersonation`. Lista las tuyas con [`GET /organization/brands`](https://chainpatrol.com/docs/es/external-api/organization-brands). |
| rejectReason | string | Al rechazar | `irrelevant`, `no_malicious_activity`, `insufficient_evidence`, `not_targeting_org` o `decayed`. |
| watchlistReason | string | Al enviar a la Watchlist | `DEAD`, `PARKING`, `NOT_ENOUGH_EVIDENCE` u `OTHER`. |
| note | string | Condicional | Detalle en texto libre. Obligatorio cuando `watchlistReason` es `OTHER`, ya que en ese caso la nota contiene el motivo. |

`proposalId` es un parámetro de ruta, así que no se repite en el cuerpo.

### Por qué assetId es obligatorio

`assetId` es un valor de confirmación, no una búsqueda. El servidor lo compara con el asset actual de la Proposal y devuelve `409` si no coinciden, lo que significa que un `proposalId` desactualizado o mal escrito falla de forma visible en lugar de revisar un asset distinto del que leíste. Toma ambos valores de la misma respuesta del listado y pásalos juntos.

### Etiquetas de bloqueo

`label` es obligatorio al aprobar y se ignora en los demás casos. `Brand Impersonation` y `Employee Impersonation` también requieren `brandId`.

| Etiqueta | Úsala cuando |
| - | - |
| `Brand Impersonation` | El asset usa directamente el nombre, el logo u otras marcas registradas de la marca |
| `Employee Impersonation` | El asset suplanta a un empleado específico de la organización |
| `Fake Employee` | El asset afirma trabajar en la empresa sin suplantar a una persona específica |
| `Targeting Org Users` | Una estafa que quieres dar de baja y que queda fuera de la suplantación directa |
| `General Phishing` | El asset intenta robar fondos de los usuarios |
| `C2 Server` | Servidor de comando y control que provee la infraestructura de backend para el phishing |
| `False Positive` | El asset se marcó por error y debería permitirse |

### Motivos de rechazo

Los motivos de rechazo alimentan el desglose que ChainPatrol usa para ajustar la detección, así que elige el más cercano en lugar de poner el motivo real en `note`:

| Motivo | Significado |
| - | - |
| `irrelevant` | No está relacionado con tu organización |
| `no_malicious_activity` | Es un asset real y no tiene nada malicioso |
| `insufficient_evidence` | No hay señales suficientes para actuar |
| `not_targeting_org` | Es malicioso, pero no apunta a tu organización |
| `decayed` | Ya no está activo o ya no es relevante |

## Respuesta

### Respuesta exitosa

```json theme={null}
{
  "proposal": {
    "id": 4321,
    "reviewStatus": "APPROVED",
    "asset": {
      "id": 987,
      "type": "URL",
      "content": "https://scam-site.com",
      "status": "BLOCKED"
    }
  },
  "review": {
    "id": 55123,
    "decision": "APPROVE",
    "label": "General Phishing",
    "brandId": null,
    "comment": "General Phishing",
    "createdAt": "2026-08-06T10:30:00.000Z"
  },
  "watchlisted": false
}
```

### Respuesta de Watchlist

Una solicitud de Watchlist se registra como un rechazo con el asset en la Watchlist:

```json theme={null}
{
  "proposal": {
    "id": 4321,
    "reviewStatus": "REJECTED",
    "asset": {
      "id": 987,
      "type": "URL",
      "content": "https://parked-domain.com",
      "status": "UNKNOWN"
    }
  },
  "review": {
    "id": 55124,
    "decision": "REJECT",
    "label": "",
    "brandId": null,
    "comment": "Add to watchlist: Parking page",
    "createdAt": "2026-08-06T10:32:00.000Z"
  },
  "watchlisted": true
}
```

### Campos de la respuesta

| Campo | Tipo | Descripción |
| - | - | - |
| proposal.id | number | La Proposal revisada |
| proposal.reviewStatus | string | `APPROVED` o `REJECTED` después de tu decisión |
| proposal.asset | object | El asset, con su `status` después de tu decisión |
| review\.id | number | La revisión que se creó |
| review\.decision | string | Tal como quedó registrada en ChainPatrol. Una solicitud `WATCHLIST` se guarda como `REJECT`. |
| review\.label | string | Etiqueta de bloqueo registrada en la revisión; vacía cuando no hay ninguna |
| review\.brandId | number \| null | Marca registrada en la revisión |
| review\.comment | string | El comentario compuesto, armado a partir de tu motivo y tu nota |
| review\.createdAt | string | Marca de tiempo ISO 8601 de la revisión |
| watchlisted | boolean | Indica si el asset quedó en la Watchlist |

## Controles de seguridad

Aprobar a través de la API está sujeto a los mismos controles que la página Review y, a diferencia de la interfaz, **no se pueden anular**:

* **Reglas de legitimidad.** Si alguna regla de legitimidad habilitada concluyó que el asset parece legítimo (un dominio incluido en la lista Tranco, una coincidencia de regex con un dominio que te pertenece), la aprobación devuelve `403`. Esa decisión la tiene que tomar una persona en la página Review.
* **Assets en la Allowlist (lista de permitidos).** Un asset que actualmente está `ALLOWED` no se puede bloquear aquí; también devuelve `403`.

Ambos son callejones sin salida deliberados y no advertencias. Cuando te encuentres con uno, revisa la Proposal en la app.

### Límite de revisiones

Las revisiones están limitadas a **10 por organización por cada período móvil de 24 horas**. El cupo se comparte entre todas las credenciales de API que tiene tu organización, y las revisiones hechas desde la página Review no cuentan para ese cupo. Si lo superas, se devuelve `429`.

El límite existe porque una revisión no se puede deshacer y es fácil recorrer una cola en bucle por accidente. Trátalo como un resguardo: si lo alcanzas con frecuencia, conviene vaciar la cola en la app.

## Respuestas de error

### 400 Bad Request

No se cumplió un requisito condicional, o el tipo de asset no se puede enviar a la Watchlist:

```json theme={null}
{
  "message": "`label` is required when approving a proposal",
  "code": "BAD_REQUEST"
}
```

### 403 Forbidden

La credencial no corresponde a un miembro de la organización con rol de cliente, o un control de seguridad rechazó la escritura:

```json theme={null}
{
  "message": "This asset cannot be approved over the API because an enabled legitimacy rule marks it as legitimate. Review it on the Review page.",
  "code": "FORBIDDEN"
}
```

### 404 Not Found

La Proposal no existe o no es una de las tuyas:

```json theme={null}
{
  "message": "Proposal not found",
  "code": "NOT_FOUND"
}
```

### 409 Conflict

`assetId` no coincide con el asset actual de la Proposal, o la Proposal ya fue resuelta:

```json theme={null}
{
  "message": "assetId does not match the proposal's asset",
  "code": "CONFLICT"
}
```

### 429 Too Many Requests

Se agotó el cupo diario de revisiones de la organización:

```json theme={null}
{
  "message": "Review limit of 10 per day reached for this organization.",
  "code": "TOO_MANY_REQUESTS"
}
```

## Casos de uso

### Vaciar la cola que está esperando por ti

Lee las Proposals que están esperando por tu organización y luego actúa sobre cada una:

```typescript TypeScript theme={null}
const listed = await fetch(
  "https://app.chainpatrol.io/api/v2/organization/reports?needsCustomerReview=true&limit=20",
  { headers: { "X-API-KEY": process.env.CHAINPATROL_API_KEY! } }
).then((res) => res.json());

for (const report of listed.reports) {
  for (const proposal of report.proposals) {
    // Decide from the asset and its scan data before writing anything.
    const decision = shouldBlock(proposal.asset)
      ? { decision: "APPROVE", label: "General Phishing" }
      : { decision: "REJECT", rejectReason: "no_malicious_activity" };

    const res = await fetch(
      `https://app.chainpatrol.io/api/v2/organization/proposals/${proposal.id}/review`,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "X-API-KEY": process.env.CHAINPATROL_API_KEY!,
        },
        body: JSON.stringify({ assetId: proposal.asset.id, ...decision }),
      }
    );

    if (res.status === 429) {
      console.log("Daily review budget spent — finish the rest in the app.");
      return;
    }
    if (res.status === 403) {
      console.log(`Proposal ${proposal.id} needs a person on the Review page.`);
      continue;
    }
  }
}
```

```python Python theme={null}
import os
import requests

headers = {
    "Content-Type": "application/json",
    "X-API-KEY": os.environ["CHAINPATROL_API_KEY"],
}

listed = requests.get(
    "https://app.chainpatrol.io/api/v2/organization/reports",
    headers=headers,
    params={"needsCustomerReview": "true", "limit": 20},
).json()

for report in listed["reports"]:
    for proposal in report["proposals"]:
        # Decide from the asset and its scan data before writing anything.
        decision = (
            {"decision": "APPROVE", "label": "General Phishing"}
            if should_block(proposal["asset"])
            else {"decision": "REJECT", "rejectReason": "no_malicious_activity"}
        )

        res = requests.post(
            f"https://app.chainpatrol.io/api/v2/organization/proposals/{proposal['id']}/review",
            headers=headers,
            json={"assetId": proposal["asset"]["id"], **decision},
        )

        if res.status_code == 429:
            print("Daily review budget spent — finish the rest in the app.")
            break
        if res.status_code == 403:
            print(f"Proposal {proposal['id']} needs a person on the Review page.")
            continue
```

### Dejar en la Watchlist un asset que quedó inactivo

Un asset que está inactivo o estacionado (con una página de parking) no es un falso positivo: envíalo a la Watchlist para que ChainPatrol lo vuelva a evaluar si vuelve a estar activo:

```bash cURL theme={null}
curl -X POST 'https://app.chainpatrol.io/api/v2/organization/proposals/4321/review' \
  -H 'Content-Type: application/json' \
  -H 'X-API-KEY: YOUR_API_KEY_HERE' \
  -d '{
    "assetId": 987,
    "decision": "WATCHLIST",
    "watchlistReason": "OTHER",
    "note": "Registrar suspended the domain; watch in case it is restored"
  }'
```

## Desde la CLI

La [ChainPatrol CLI](https://chainpatrol.com/docs/es/cli/overview.md) envuelve este endpoint y pide confirmación antes de escribir:

```bash theme={null}
chainpatrol reports list --org acme --needs-customer-review --json
chainpatrol proposals review 4321 --asset-id 987 --decision approve --label "General Phishing"
```

Pasa `--yes` para omitir la confirmación en un script, o `--dry-run` para imprimir el payload sin enviarlo. Consulta [`proposals review`](https://chainpatrol.com/docs/es/cli/commands/proposals) para ver todas las opciones.

## Buenas prácticas

### Lee antes de escribir

Cada solicitud necesita el `assetId` de un listado que acabas de leer, y eso es deliberado. Obtén la Proposal, decide a partir de su asset y de los datos de su escaneo, y solo entonces revísala: no inventes ID ni reutilices un listado viejo.

### Trata el 403 como una derivación, no como una falla

Un `403` de un control de seguridad significa que la decisión necesita a una persona, no que tu integración esté rota. Registra el ID de la Proposal y sigue adelante; no reintentes.

### No reintentes un 409

Un `409` significa que el asset no coincide o que la Proposal ya está resuelta. Vuelve a leer la Proposal en lugar de reintentar con el mismo cuerpo.

## Notas

* Las revisiones deben atribuirse a un miembro de la organización con rol de cliente. Las credenciales de staff se rechazan con `403`.
* El estado del asset es global: los assets son únicos por tipo y contenido, así que aprobar bloquea el asset en todas partes y no solo para tu organización.
* No todos los tipos de asset se pueden enviar a la Watchlist. Los tipos que la Watchlist no puede volver a verificar se rechazan con `400` en lugar de omitir en silencio el envío a la Watchlist.
* `GET /organization/reports` devuelve `proposals[].id` justamente para que las Proposals se puedan referenciar aquí.


## OpenAPI

````yaml POST /organization/proposals/{proposalId}/review
openapi: 3.0.3
info:
  title: ChainPatrol External API - OpenAPI 3.0
  description: ChainPatrol External API documentation
  version: 2.0.0
servers:
  - url: https://app.chainpatrol.io/api/v2
security: []
tags:
  - name: asset
  - name: report
  - name: dark-web
externalDocs:
  url: https://chainpatrol.com/docs
paths:
  /organization/proposals/{proposalId}/review:
    post:
      tags:
        - organization
      summary: Review an organization proposal
      description: >-
        Records your organization's decision on a proposal that is waiting on
        you — one ChainPatrol escalated to you, or one on a report you submitted
        yourself. These are exactly the proposals your Review page shows and the
        ones `GET /organization/reports?needsCustomerReview=true` counts; find
        their IDs in `proposals[].id` on that endpoint. `APPROVE` blocks the
        asset and takes a `label` (plus a `brandId` for labels that name a
        specific brand). `REJECT` takes a `rejectReason`. `WATCHLIST` rejects
        the proposal and parks the asset so it is re-evaluated if it comes back
        alive.


        Pass `assetId` alongside `proposalId`; it must match the proposal's
        current asset or the request returns `409`, which keeps a caller from
        actioning a proposal it never read.


        Approvals are held to the same safety checks as the Review page, with no
        override: an asset that any enabled legitimacy rule marks as legitimate
        cannot be approved here, and an allowlisted asset cannot be blocked
        here. Both return `403` and must be handled on the Review page by a
        person.


        Rate limited to 10 reviews per organization per day, since a review is
        not undoable and looping over a queue is easy to do by accident.
        Exceeding it returns `429`. The limit is shared across all of the
        organization's API credentials and does not apply to reviews made from
        the Review page.
      operationId: organizationProposalsReview
      parameters:
        - in: path
          name: proposalId
          description: >-
            ID of the proposal to review. Read it from `proposals[].id` on `GET
            /organization/reports`.
          schema:
            type: integer
            minimum: 0
            exclusiveMinimum: true
            description: >-
              ID of the proposal to review. Read it from `proposals[].id` on
              `GET /organization/reports`.
          required: true
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                assetId:
                  type: integer
                  minimum: 0
                  exclusiveMinimum: true
                  description: >-
                    ID of the asset this proposal is for, from
                    `proposals[].asset.id` on `GET /organization/reports`.
                    Required, and must match the proposal's current asset — a
                    mismatch returns 409. This proves the request was built from
                    a proposal you actually read, rather than from a guessed or
                    stale ID.
                slug:
                  type: string
                  description: >-
                    Organization slug. Optional for organization-scoped API
                    keys, which resolve the organization from the key itself.
                    Required when your credentials can reach more than one
                    organization.
                decision:
                  type: string
                  enum:
                    - APPROVE
                    - REJECT
                    - WATCHLIST
                  description: >-
                    What to do with the proposal. `APPROVE` blocks the asset,
                    `REJECT` declines it, and `WATCHLIST` declines it but parks
                    the asset so it is re-evaluated if it comes back alive.
                    `WATCHLIST` is recorded as a rejection with the asset
                    watchlisted — the same write the Review page performs.
                label:
                  type: string
                  enum:
                    - Brand Impersonation
                    - Employee Impersonation
                    - Fake Employee
                    - Targeting Org Users
                    - General Phishing
                    - C2 Server
                    - False Positive
                    - Organization Member Impersonation
                    - Targeting Organization
                  description: >-
                    Why the asset is being blocked. Required when `decision` is
                    `APPROVE`, ignored otherwise. One of: `Brand Impersonation`,
                    `Employee Impersonation`, `Fake Employee`, `Targeting Org
                    Users`, `General Phishing`, `C2 Server`, `False Positive`,
                    `Organization Member Impersonation`, `Targeting
                    Organization`.


                    - `Brand Impersonation` — The asset is directly using the
                    Brand's name, logo, or other trademarks

                    - `Employee Impersonation` — The asset is impersonating a
                    specific employee of the organization

                    - `Fake Employee` — The asset claims to work at the company
                    but is not directly impersonating a specific person

                    - `Targeting Org Users` — A scam the org wants taken down
                    that falls outside direct impersonation

                    - `General Phishing` — This asset is trying to steal user
                    funds

                    - `C2 Server` — Command and Control server providing backend
                    infrastructure for phishing operations

                    - `False Positive` — This asset was incorrectly flagged and
                    should be allowed

                    - `Organization Member Impersonation` — The asset is
                    impersonating a member or employee of the organization

                    - `Targeting Organization` — A scam the org wants taken down
                    that falls outside direct impersonation
                brandId:
                  type: integer
                  minimum: 0
                  exclusiveMinimum: true
                  description: >-
                    Brand the asset impersonates. Optional for most labels, but
                    required for `Brand Impersonation` and `Employee
                    Impersonation`, which name a specific impersonation target.
                    List your brands with `GET /organization/brands`.
                rejectReason:
                  type: string
                  enum:
                    - irrelevant
                    - no_malicious_activity
                    - insufficient_evidence
                    - not_targeting_org
                    - decayed
                  description: >-
                    Why the proposal is being rejected. Required when `decision`
                    is `REJECT`, ignored otherwise. These are the same reasons
                    the Review page offers, and they feed ChainPatrol's
                    detection-tuning breakdown — pick the closest one rather
                    than relying on `note`.
                watchlistReason:
                  type: string
                  enum:
                    - DEAD
                    - PARKING
                    - NOT_ENOUGH_EVIDENCE
                    - OTHER
                  description: >-
                    Why the asset is being parked. Required when `decision` is
                    `WATCHLIST`, ignored otherwise. Use `OTHER` for anything not
                    covered, in which case `note` becomes required and is
                    treated as the reason. Note that the watchlist only covers
                    asset types that can be re-checked for revival (URL, PAGE,
                    EMAIL, and the social platforms); watchlisting any other
                    type is rejected, so reject the proposal instead.
                note:
                  type: string
                  maxLength: 1000
                  description: >-
                    Free-text detail recorded on the review, alongside the
                    structured reason. Required when `watchlistReason` is
                    `OTHER`.
              required:
                - assetId
                - decision
              description: >-
                Review a proposal on your organization's behalf


                Records your organization's decision on a proposal ChainPatrol
                escalated to you

                and you have not answered yet. These are exactly the proposals
                your Review page

                shows, and the ones counted by

                `GET /organization/reports?needsCustomerReview=true`.


                Proposals on reports your organization sourced itself are not
                reviewable here:

                ChainPatrol triages those and staff approval blocks the asset on
                its own, so

                there is no decision for you to record. They return `403`.
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                type: object
                properties:
                  proposal:
                    type: object
                    properties:
                      id:
                        type: number
                        description: Proposal ID
                      reviewStatus:
                        type: string
                        enum:
                          - PENDING
                          - APPROVED
                          - REJECTED
                        description: >-
                          The proposal's review status after your decision —
                          `APPROVED` or `REJECTED`.
                      asset:
                        type: object
                        properties:
                          id:
                            type: number
                            description: Asset ID
                          type:
                            type: string
                            description: Asset type
                          content:
                            type: string
                            description: Asset content (URL, handle, address, …)
                          status:
                            type: string
                            enum:
                              - UNKNOWN
                              - ALLOWED
                              - BLOCKED
                            description: The asset's status after your decision
                        required:
                          - id
                          - type
                          - content
                          - status
                    required:
                      - id
                      - reviewStatus
                      - asset
                    description: The reviewed proposal
                  review:
                    type: object
                    properties:
                      id:
                        type: number
                        description: Review ID
                      decision:
                        type: string
                        enum:
                          - APPROVE
                          - REJECT
                          - SKIP
                          - ESCALATE
                        description: >-
                          The decision as recorded in ChainPatrol. A `WATCHLIST`
                          request is stored as `REJECT` with the asset
                          watchlisted.
                      label:
                        type: string
                        description: Block label recorded on the review, empty when none
                      brandId:
                        type: number
                        nullable: true
                        description: Brand recorded on the review
                      comment:
                        type: string
                        description: >-
                          The composed review comment, built from your reason
                          and note
                      createdAt:
                        type: string
                        description: When the review was recorded
                    required:
                      - id
                      - decision
                      - label
                      - brandId
                      - comment
                      - createdAt
                    description: The review that was created
                  watchlisted:
                    type: boolean
                    description: >-
                      Whether the asset was added to the watchlist as part of
                      this review
                required:
                  - proposal
                  - review
                  - watchlisted
                description: Successful operation
        '400':
          description: Invalid input data
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/error.BAD_REQUEST'
        '401':
          description: Authorization not provided
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/error.UNAUTHORIZED'
        '403':
          description: Insufficient access
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/error.FORBIDDEN'
        '500':
          description: Internal server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/error.INTERNAL_SERVER_ERROR'
      security:
        - ApiKey: []
components:
  schemas:
    error.BAD_REQUEST:
      type: object
      properties:
        message:
          type: string
          description: The error message
          example: Invalid input data
        code:
          type: string
          description: The error code
          example: BAD_REQUEST
        issues:
          type: array
          items:
            type: object
            properties:
              message:
                type: string
            required:
              - message
          description: An array of issues that were responsible for the error
          example: []
      required:
        - message
        - code
      title: Invalid input data error (400)
      description: The error information
      example:
        code: BAD_REQUEST
        message: Invalid input data
        issues: []
    error.UNAUTHORIZED:
      type: object
      properties:
        message:
          type: string
          description: The error message
          example: Authorization not provided
        code:
          type: string
          description: The error code
          example: UNAUTHORIZED
        issues:
          type: array
          items:
            type: object
            properties:
              message:
                type: string
            required:
              - message
          description: An array of issues that were responsible for the error
          example: []
      required:
        - message
        - code
      title: Authorization not provided error (401)
      description: The error information
      example:
        code: UNAUTHORIZED
        message: Authorization not provided
        issues: []
    error.FORBIDDEN:
      type: object
      properties:
        message:
          type: string
          description: The error message
          example: Insufficient access
        code:
          type: string
          description: The error code
          example: FORBIDDEN
        issues:
          type: array
          items:
            type: object
            properties:
              message:
                type: string
            required:
              - message
          description: An array of issues that were responsible for the error
          example: []
      required:
        - message
        - code
      title: Insufficient access error (403)
      description: The error information
      example:
        code: FORBIDDEN
        message: Insufficient access
        issues: []
    error.INTERNAL_SERVER_ERROR:
      type: object
      properties:
        message:
          type: string
          description: The error message
          example: Internal server error
        code:
          type: string
          description: The error code
          example: INTERNAL_SERVER_ERROR
        issues:
          type: array
          items:
            type: object
            properties:
              message:
                type: string
            required:
              - message
          description: An array of issues that were responsible for the error
          example: []
      required:
        - message
        - code
      title: Internal server error error (500)
      description: The error information
      example:
        code: INTERNAL_SERVER_ERROR
        message: Internal server error
        issues: []
  securitySchemes:
    ApiKey:
      type: apiKey
      in: header
      name: X-API-KEY
      description: >-
        Your API key. This is required by most endpoints to access our API
        programatically. Reach out to us at
        [support@chainpatrol.io](mailto:support@chainpatrol.io?subject=Re:%20API%20Key%20for%20SDK&body=Company:%20%0AName:%20%0APurpose:%20)
        to get an API key for your use.

````

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