List Organization Reports

List all reports belonging to your organization with optional filtering and pagination. Organization is determined from your API key.

GET /organization/reports

List organization reports

cURL

curl --request GET \
  --url https://app.chainpatrol.io/api/v2/organization/reports \
  --header 'X-API-KEY: <api-key>'

import requests

url = "https://app.chainpatrol.io/api/v2/organization/reports"

headers = {"X-API-KEY": "<api-key>"}

response = requests.get(url, headers=headers)

print(response.text)

const options = {method: 'GET', headers: {'X-API-KEY': '<api-key>'}};

fetch('https://app.chainpatrol.io/api/v2/organization/reports', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://app.chainpatrol.io/api/v2/organization/reports",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "X-API-KEY: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://app.chainpatrol.io/api/v2/organization/reports"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-API-KEY", "<api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("https://app.chainpatrol.io/api/v2/organization/reports")
  .header("X-API-KEY", "<api-key>")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://app.chainpatrol.io/api/v2/organization/reports")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["X-API-KEY"] = '<api-key>'

response = http.request(request)
puts response.read_body

200

{
  "reports": [
    {
      "id": 123,
      "title": "<string>",
      "description": "<string>",
      "createdAt": "<string>",
      "updatedAt": "<string>",
      "attachments": [
        {
          "id": 123,
          "url": "<string>"
        }
      ],
      "proposals": [
        {
          "asset": {
            "id": 123,
            "content": "<string>",
            "scans": [
              {
                "id": 123,
                "createdAt": "<string>",
                "enrichments": [
                  {
                    "id": 123,
                    "type": "<string>",
                    "status": "<string>",
                    "output": null
                  }
                ],
                "output": null
              }
            ]
          }
        }
      ],
      "reporter": {
        "id": 123,
        "fullName": "<string>",
        "avatarUrl": "<string>"
      },
      "externalReporter": {
        "id": 123,
        "displayName": "<string>",
        "avatarUrl": "<string>",
        "platform": "<string>"
      }
    }
  ],
  "nextCursor": 123
}

{
  "code": "BAD_REQUEST",
  "message": "Invalid input data",
  "issues": []
}

{
  "code": "UNAUTHORIZED",
  "message": "Authorization not provided",
  "issues": []
}

{
  "code": "FORBIDDEN",
  "message": "Insufficient access",
  "issues": []
}

{
  "code": "NOT_FOUND",
  "message": "Not found",
  "issues": []
}

{
  "code": "INTERNAL_SERVER_ERROR",
  "message": "Internal server error",
  "issues": []
}

Overview

Retrieve security reports for your organization. This endpoint returns all reports submitted for your organization, including details about reported assets, proposals, and their current status. The organization is automatically inferred from your API key.

Quick Start

Authentication

Include your API key in the X-API-KEY header:

X-API-KEY: your_api_key_here

Example Request

TypeScript

const response = await fetch(
  "https://app.chainpatrol.io/api/v2/organization/reports?limit=50",
  {
    method: "GET",
    headers: {
      "X-API-KEY": "YOUR_API_KEY_HERE",
    },
  }
);

const data = await response.json();
console.log(data.reports);

const response = await fetch(
  "https://app.chainpatrol.io/api/v2/organization/reports?limit=50",
  {
    method: "GET",
    headers: {
      "X-API-KEY": "YOUR_API_KEY_HERE",
    },
  }
);

const data = await response.json();
console.log(data.reports);

import requests

response = requests.get(
    "https://app.chainpatrol.io/api/v2/organization/reports",
    headers={
        "X-API-KEY": "YOUR_API_KEY_HERE",
    },
    params={
        "limit": 50,
    },
)

data = response.json()
print(data["reports"])

curl -X GET 'https://app.chainpatrol.io/api/v2/organization/reports?limit=50' \
  -H 'X-API-KEY: YOUR_API_KEY_HERE'

Query Parameters

Parameter	Type	Required	Description
limit	number	No	Number of reports to return per page (1-100, default: 50)
cursor	string	No	Cursor for pagination. Pass the cursor from the previous response to get the next page.
startDate	string	No	Filter reports created after this date (ISO 8601 format)
endDate	string	No	Filter reports created before this date (ISO 8601 format)
onlyRejected	boolean	No	If true, only return reports with rejected proposals (default: false)

Response

Success Response

{
  "reports": [
    {
      "id": "rpt_1234567890abcdef",
      "createdAt": "2024-01-15T10:30:00.000Z",
      "status": "APPROVED",
      "assets": [
        {
          "id": 12345,
          "content": "https://scam-site.com",
          "type": "URL",
          "status": "BLOCKED"
        }
      ],
      "proposals": [
        {
          "id": "prop_abc123",
          "status": "APPROVED",
          "reason": "phishing",
          "createdAt": "2024-01-15T10:30:00.000Z"
        }
      ]
    }
  ],
  "cursor": "next_page_cursor_string"
}

Response Fields

Field	Type	Description
reports	array	Array of report objects for your organization
reports[].id	string	Unique identifier for the report
reports[].createdAt	string	ISO 8601 timestamp when the report was created
reports[].status	string	Overall status of the report (PENDING, APPROVED, REJECTED)
reports[].assets	array	Array of assets included in the report
reports[].proposals	array	Array of proposals associated with the report
cursor	string	Cursor for the next page of results (undefined if no more results)

Pagination

Use the cursor-based pagination to fetch all reports:

TypeScript

async function fetchAllReports() {
  let allReports = [];
  let cursor: string | undefined = undefined;

  while (true) {
    const params = new URLSearchParams({
      limit: "100",
      ...(cursor && { cursor }),
    });

    const response = await fetch(
      `https://app.chainpatrol.io/api/v2/organization/reports?${params}`,
      {
        method: "GET",
        headers: {
          "X-API-KEY": "YOUR_API_KEY_HERE",
        },
      }
    );

    const data = await response.json();
    allReports = allReports.concat(data.reports);
    cursor = data.cursor;

    if (!cursor) {
      break;
    }
  }

  return allReports;
}

fetchAllReports()
  .then((reports) => console.log(`Total reports: ${reports.length}`))
  .catch((error) => console.error("Error:", error));

import requests

def fetch_all_reports():
    all_reports = []
    cursor = None

    while True:
        params = {"limit": 100}
        if cursor:
            params["cursor"] = cursor

        response = requests.get(
            "https://app.chainpatrol.io/api/v2/organization/reports",
            headers={"X-API-KEY": "YOUR_API_KEY_HERE"},
            params=params,
        )

        data = response.json()
        all_reports.extend(data["reports"])
        cursor = data.get("cursor")

        if not cursor:
            break

    return all_reports

try:
    reports = fetch_all_reports()
    print(f"Total reports: {len(reports)}")
except Exception as error:
    print(f"Error: {str(error)}")

Filtering Examples

Filter by Date Range

Get reports from a specific time period:

curl -X GET 'https://app.chainpatrol.io/api/v2/organization/reports?startDate=2024-01-01T00:00:00Z&endDate=2024-03-31T23:59:59Z' \
  -H 'X-API-KEY: YOUR_API_KEY_HERE'

Filter Only Rejected Reports

Get reports that have rejected proposals:

curl -X GET 'https://app.chainpatrol.io/api/v2/organization/reports?onlyRejected=true' \
  -H 'X-API-KEY: YOUR_API_KEY_HERE'

Combine Filters

Get rejected reports from a specific date range:

curl -X GET 'https://app.chainpatrol.io/api/v2/organization/reports?startDate=2024-01-01T00:00:00Z&endDate=2024-03-31T23:59:59Z&onlyRejected=true&limit=100' \
  -H 'X-API-KEY: YOUR_API_KEY_HERE'

Error Responses

401 Unauthorized

Returned when the API key is missing, invalid, or doesn’t have organization access:

{
  "error": {
    "code": "UNAUTHORIZED",
    "message": "API key with organization access required"
  }
}

400 Bad Request

Returned when query parameters are invalid:

{
  "error": {
    "code": "BAD_REQUEST",
    "message": "Invalid date format. Use ISO 8601 format."
  }
}

Use Cases

Monitor Recent Reports

async function getRecentReports(days: number = 7) {
  const startDate = new Date();
  startDate.setDate(startDate.getDate() - days);

  const response = await fetch(
    `https://app.chainpatrol.io/api/v2/organization/reports?startDate=${startDate.toISOString()}&limit=100`,
    {
      headers: { "X-API-KEY": "YOUR_API_KEY_HERE" },
    }
  );

  const { reports } = await response.json();
  console.log(`Found ${reports.length} reports in the last ${days} days`);
  return reports;
}

Track Rejected Reports

async function analyzeRejectedReports() {
  const response = await fetch(
    "https://app.chainpatrol.io/api/v2/organization/reports?onlyRejected=true",
    {
      headers: { "X-API-KEY": "YOUR_API_KEY_HERE" },
    }
  );

  const { reports } = await response.json();

  // Analyze rejection reasons
  const rejectionReasons = reports.flatMap((report) =>
    report.proposals
      .filter((p) => p.status === "REJECTED")
      .map((p) => p.rejectionReason)
  );

  console.log("Common rejection reasons:", rejectionReasons);
  return rejectionReasons;
}

Export Reports to CSV

async function exportReportsToCSV(startDate: string, endDate: string) {
  const response = await fetch(
    `https://app.chainpatrol.io/api/v2/organization/reports?startDate=${startDate}&endDate=${endDate}&limit=100`,
    {
      headers: { "X-API-KEY": "YOUR_API_KEY_HERE" },
    }
  );

  const { reports } = await response.json();

  const csvHeader = "Report ID,Created At,Status,Assets,Proposals\n";
  const csvRows = reports
    .map(
      (r) =>
        `${r.id},${r.createdAt},${r.status},${r.assets.length},${r.proposals.length}`
    )
    .join("\n");

  const csv = csvHeader + csvRows;

  // Save or return CSV
  return csv;
}

Best Practices

Pagination

• Use limit=100 for bulk data retrieval to minimize API calls
• Always check for the cursor field to determine if more results exist
• Store the cursor if you need to resume pagination later

Date Filtering

• Always use ISO 8601 format for dates: YYYY-MM-DDTHH:mm:ss.sssZ
• Include timezone information (typically UTC with Z suffix)
• Use both startDate and endDate for precise time ranges

Performance

• Cache report data when appropriate to reduce API calls
• Use date filters to limit the result set size
• Consider polling intervals if monitoring for new reports (5-10 minutes recommended)

Notes

• Organization is automatically determined from your API key
• All timestamps are in ISO 8601 format with UTC timezone
• The onlyRejected filter shows reports with at least one rejected proposal, but the report may contain other approved proposals
• Reports are ordered by creation date (newest first)
• The cursor is opaque and should not be parsed or modified

Authorizations

X-API-KEY · string · header · required

Your API key. This is required by most endpoints to access our API programatically. Reach out to us at [e-mail] to get an API key for your use.

Query Parameters

limit · number · required

Required range: 1 <= x <= 20

cursor · number | null

status · enum<string>

Available options: TODO, IN_PROGRESS, CLOSED

searchQuery · string

reporterQuery · string

excludeAutomation · boolean · default: false

onlyRejected · boolean · default: false

reviewStatuses · enum<string>[]

Available options: APPROVE, REJECT, SKIP, ESCALATE

reviewedByUserId · number | null

startDate · string

endDate · string

brandIds · number[]

Response

200

application/json

Successful response

reports · object[] · required

Show child attributes

nextCursor · number | null · required