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

# Atlas API

> Start and continue Atlas investigations, and read their findings, attribution graph, files, agent activity, reports and exports.

[Atlas API or People Intelligence](https://docs.sixtyfour.ai/atlas/integrations.md#atlas-api-or-people-intelligence) compares this API with the `xhigh` tier.

> [!NOTE]
>
> Atlas keeps its own request and response names. It takes `lead_info` and `struct`, returns a `task_id`, pages with `limit` and `after`, and reports `completed` where other `/v1` routes report `succeeded`. A run is not a [Job](https://docs.sixtyfour.ai/api-reference/async-jobs.md) yet: poll it with `GET /job-status/{task_id}`, not `GET /v1/jobs/{job_id}`.

## Endpoints

All paths are under `https://api.sixtyfour.ai/v1/atlas`.

| Method | Path | Purpose |
| - | - | - |
| `GET` | `/access` | Check whether your organization has Atlas, and the engines it can run with their prices. |
| `POST` | `/investigations` | Start an investigation. |
| `POST` | `/investigations/{investigation_id}/runs` | Continue an investigation with another run. |
| `GET` | `/investigations` | List investigations. |
| `GET` | `/investigations/{investigation_id}` | Get one investigation. |
| `GET` | `/investigations/{investigation_id}/findings` | List findings (graph nodes), paginated. |
| `GET` | `/investigations/{investigation_id}/links` | List links between findings (graph edges), paginated. |
| `GET` | `/investigations/{investigation_id}/graph` | The whole attribution graph. |
| `GET` | `/investigations/{investigation_id}/output` | The latest saved structured output for the current run. |
| `GET` | `/investigations/{investigation_id}/files` | List workspace files. |
| `GET` | `/investigations/{investigation_id}/file-entries` | List workspace files, paginated. |
| `GET` | `/investigations/{investigation_id}/files/{path}` | Read one workspace file or attachment. |
| `GET` | `/investigations/{investigation_id}/events` | The agents' sessions and events, paginated. |
| `GET` | `/investigations/{investigation_id}/events/stream` | Follow the agents' turn summaries live over Server-Sent Events. |
| `GET` | `/investigations/{investigation_id}/events/{event_id}/payload` | Read one event's full arguments, result and reasoning. Requires activity access. |
| `POST` | `/investigations/{investigation_id}/report` | Generate the intelligence report. |
| `GET` | `/investigations/{investigation_id}/report` | Report generation status. |
| `GET` | `/investigations/{investigation_id}/report.pdf` | Download the report PDF. |
| `GET` | `/investigations/{investigation_id}/export.zip` | Export the whole workspace as a ZIP. |
| `GET` | `/investigations/{investigation_id}/identifiers.csv` | Export every identifier the investigation found as a CSV. |

Authenticate with your `x-api-key` header, as on every other endpoint.

## Checking access

Atlas is enabled on request; [talk to sales](https://cal.com/team/sixtyfour/discovery) to turn it on. `GET /access` works for every organization. It returns whether yours has Atlas and the engines your API key's team can run, default first, with each engine's price.

```bash cURL theme={null}
curl "https://api.sixtyfour.ai/v1/atlas/access" \
  -H "x-api-key: YOUR_API_KEY"
```

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

response = requests.get(
    "https://api.sixtyfour.ai/v1/atlas/access",
    headers={"x-api-key": "YOUR_API_KEY"}
)
response.raise_for_status()
access = response.json()
```

```javascript JavaScript theme={null}
const response = await fetch("https://api.sixtyfour.ai/v1/atlas/access", {
  headers: { "x-api-key": "YOUR_API_KEY" }
});
if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const access = await response.json();
```

```json theme={null}
{
  "has_atlas": true,
  "engines": [
    {"engine": "xhigh", "label": "XHigh", "credits": 250.0},
    {"engine": "scout", "label": "Scout", "credits": 50.0}
  ]
}
```

| Field | Type | Description |
| - | - | - |
| `has_atlas` | boolean | Whether your organization can use Atlas. |
| `engines` | array | The engines your organization can run, the default first. Empty when `has_atlas` is `false`. |
| `engines[].engine` | string | The value to pass as `engine` when starting or continuing a run. |
| `engines[].label` | string | Display name for the engine. |
| `engines[].credits` | number or null | Price of one unit of research on this engine, in credits. `null` when the price is unavailable; retry the request. |

## Starting an investigation

`POST /investigations` returns 202 with the run's `task_id` and the new investigation:

| Field | Type | Default | Description |
| - | - | - | - |
| `lead_info` | object | required | Who to investigate, for example `{"name": "Jane Doe", "company": "Acme"}`. |
| `name` | string | derived from `lead_info` | Title for the investigation. |
| `engine` | string | `xhigh` | `xhigh` for the deepest research, or `scout` for faster, lower-cost research (needs Scout access). [`GET /access`](#checking-access) lists the engines your organization can run. |
| `research_plan` | string | None | Plain-language guidance on what to look into. |
| `task` | string | None | Set `org_chart` with `engine: "xhigh"` to research a company’s people, teams and reporting relationships. |
| `struct` | object | None | Optional target fields, in the same format as [People Intelligence](https://docs.sixtyfour.ai/api-reference/legacy/people-intelligence.md#using-the-struct-field). |
| `relentless` | boolean | `true` | Research until the budget runs out. Set `false` with a `struct` to let the run stop once every field is answered. |
| `max_credits` | integer | one unit of the engine price | How much research to buy, from one to ten units of the engine price. |
| `max_minutes` | integer (10 to 1440) | no limit | Working-time limit. When it is reached the run writes up what it found and completes. See [Credit Costs](https://docs.sixtyfour.ai/guides/credits-and-pricing.md#atlas-investigations) for what it is charged. |
| `dispatch_id` | string (8 to 128 chars) | None | Idempotency key, unique within your organization and shared with `POST /people-intelligence-async`. Resending a key returns the run it first started and starts nothing, even for another investigation. |
| `private` | boolean | `false` | Make the investigation visible only to you, not your team. Needs private runs enabled for your organization and allowed by your team. With an API key, the run is private to the key's creator, and that person's keys on the team can read it. |

Other fields are ignored without an error. [Atlas API or People Intelligence](https://docs.sixtyfour.ai/atlas/integrations.md#atlas-api-or-people-intelligence) lists the fields only People Intelligence takes.

```bash cURL theme={null}
curl -X POST "https://api.sixtyfour.ai/v1/atlas/investigations" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "lead_info": {"name": "Jane Doe", "company": "Acme Corp"},
    "research_plan": "Professional background, current role and public board seats",
    "max_minutes": 60
  }'
```

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

response = requests.post(
    "https://api.sixtyfour.ai/v1/atlas/investigations",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "lead_info": {"name": "Jane Doe", "company": "Acme Corp"},
        "research_plan": "Professional background, current role and public board seats",
        "max_minutes": 60
    }
)
response.raise_for_status()
run = response.json()
investigation_id = run["investigation"]["id"]
```

```javascript JavaScript theme={null}
const response = await fetch("https://api.sixtyfour.ai/v1/atlas/investigations", {
  method: "POST",
  headers: { "x-api-key": "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    lead_info: { name: "Jane Doe", company: "Acme Corp" },
    research_plan: "Professional background, current role and public board seats",
    max_minutes: 60
  })
});
if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const run = await response.json();
const investigationId = run.investigation.id;
```

```json theme={null}
{
  "task_id": "enrich_3f8b2c1e-9d4a-4f6b-8c2e-1a7b5d9e0f34",
  "status": "RUNNING",
  "investigation": {
    "id": "29beab70-42e4-5d19-b3b1-9a28279ca19f",
    "workspace_url": "https://app.sixtyfour.ai/atlas/29beab70-42e4-5d19-b3b1-9a28279ca19f/graph"
  }
}
```

Poll the run with [`GET /job-status/{task_id}`](https://docs.sixtyfour.ai/api-reference/legacy#job-status-and-callbacks), or open `workspace_url` to watch it in the Atlas section of the Sixtyfour app. A completed run's `result` has the fields of an [Atlas job result](https://docs.sixtyfour.ai/atlas/integrations.md#response), including `structured_data` and `field_confidence` when you send a `struct`. A run the agents decline also reports `completed`; see [Declined runs](https://docs.sixtyfour.ai/atlas/integrations.md#declined-runs).

## Continuing an investigation

`POST /investigations/{investigation_id}/runs` starts another run on the same workspace and graph. It takes the same body as starting one, without `lead_info`, `name` and `private`, and returns the same 202 response. Continuing needs editor access to the investigation.

```bash cURL theme={null}
curl -X POST "https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID/runs" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"research_plan": "Follow up on the earlier role at the previous employer"}'
```

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

response = requests.post(
    "https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID/runs",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={"research_plan": "Follow up on the earlier role at the previous employer"}
)
response.raise_for_status()
run = response.json()
```

```javascript JavaScript theme={null}
const response = await fetch("https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID/runs", {
  method: "POST",
  headers: { "x-api-key": "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({ research_plan: "Follow up on the earlier role at the previous employer" })
});
if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const run = await response.json();
```

Continuing while a run is going starts a second run, billed separately. To refuse a second run, continue through [`POST /people-intelligence-async`](https://docs.sixtyfour.ai/atlas/integrations#request-parameters) with `investigation_id` and `exclusive_run: true`.

The investigation's `status` covers all of its runs. After you continue a finished investigation it still reads `completed` until the new run's agents start, so follow the new run with [`GET /job-status/{task_id}`](https://docs.sixtyfour.ai/api-reference/legacy#job-status-and-callbacks).

## Listing and reading investigations

`GET /investigations` returns `investigations`, newest first, the page `limit` and a `next_cursor`. An API key lists and opens its team's investigations and the ones shared with that team.

| Query parameter | Default | Description |
| - | - | - |
| `limit` | `50` | Page size, 1 to 200. |
| `after` | None | `next_cursor` from the previous page. |
| `shared` | `all` | `owned` for your team's investigations, `shared` for ones other teams shared with yours, or `all`. |
| `status` | None | Only investigations in this [state](#investigation-status): `created`, `running`, `stalled`, `completed` or `failed`. A filtered page can come back short or empty, so follow `next_cursor` until it is `null`. |
| `created_after`, `created_before` | None | ISO 8601 timestamps. |

Each investigation, also returned by `GET /investigations/{investigation_id}`, looks like this:

```json theme={null}
{
  "id": "29beab70-42e4-5d19-b3b1-9a28279ca19f",
  "name": "Jane Doe, Acme Corp",
  "status": "completed",
  "visibility": "private",
  "lead_info": {"name": "Jane Doe", "company": "Acme Corp"},
  "created_at": "2026-01-15T10:00:00Z",
  "updated_at": "2026-01-15T10:42:00Z",
  "completed_at": "2026-01-15T10:42:00Z",
  "cost_cents": 25000,
  "cost_credits": 2500,
  "shared": null,
  "workspace_url": "https://app.sixtyfour.ai/atlas/29beab70-42e4-5d19-b3b1-9a28279ca19f/graph",
  "private": false
}
```

`shared` is `null` when your team owns the investigation. Otherwise it names the team that shared it and your `tier` on it: a `viewer` can read and export, an `editor` can also run and edit.

| Field | Description |
| - | - |
| `status` | The investigation's [status](#investigation-status), across all of its runs. |
| `visibility` | `public` while a public link to the investigation is on (set in the web app), otherwise `private`. |
| `private` | `true` for a private run, visible only to the person who started it. Separate from `visibility`. |
| `completed_at` | When the investigation reached `completed` or `failed`. `null` while a run is going. |
| `cost_credits` | Total spend across every run, in credits. `null` if a run's cost has not been recorded yet. `cost_cents` is deprecated. |
| `spend_access` | Set when you may not see what the investigation's creator spent: `state`, `reason` and `message`. `cost_credits` and `cost_cents` are then `null`, and so is each agent session's cost. An API key sees the costs the person who created it may see. |

### Investigation status

| Status | Meaning |
| - | - |
| `created` | No run's agents have started yet. |
| `running` | A run's agents are working. |
| `stalled` | An agent has made no progress for an hour. It returns to `running` when the agent resumes; after 24 hours without progress, its run fails. |
| `completed` | A run has completed. The investigation stays `completed` between runs, and when a later run fails or is stopped. |
| `failed` | The latest run failed or was stopped, and no run has completed. |

## Reading the graph and workspace

| Endpoint | Returns |
| - | - |
| `GET .../graph` | The whole attribution graph: `nodes` (findings with their source URLs) and `edges` (confidence-weighted links between them). |
| `GET .../findings`, `GET .../links` | The same nodes and edges one page at a time: `items` and `next_cursor`. `limit` is 1 to 50 (default 50); pass `next_cursor` as `after`. |
| `GET .../files` | `files`: every workspace file's `path`, `content_type`, `size_bytes`, `updated_at`, `version`, and `attachment` metadata for saved images and documents. |
| `GET .../file-entries` | The same file metadata one page at a time: `items` and `next_cursor`. `limit` is 1 to 50 (default 50). |
| `GET .../files/{path}` | One file's content, or an attachment's bytes with its content type. |
| `GET .../events` | The agents' `sessions` (type, task, status, turn count, cost) and their turn summaries as `events`, oldest first, up to 500 a page. `next_cursor` is `null` on the last page, which can be empty. |

### Findings, links and events

Findings are the graph's `nodes` and the items of `GET .../findings`. Empty fields are left out.

| Field | Description |
| - | - |
| `id` | The finding's id in this graph. The inputs the investigation started from are `input.<key>`. |
| `type` | `ground_truth` for those inputs, `discovered` for everything the agents found. |
| `value` | The finding: a URL, handle, name or other value. |
| `kind` | A free-text category, such as `account` or `email`. |
| `status` | `active`, or `retired` once it is taken out of the graph. |
| `ruled_out` | `true` when someone retired it as wrong in the web app. |
| `field` | The `struct` field it answers, if any. |
| `source_url`, `source_urls` | The pages it was read on. `source_url` is the first. |
| `source_quote` | The text it was read from. |
| `confidence` | A confidence recorded on the finding itself, when there is one. |
| `evidence_receipts` | The evidence behind it: each receipt's `confidence`, `basis` and source `records`. |
| `attachments` | Workspace paths of images saved as evidence for it. |
| `depth`, `unexplored` | How far the agents explored this source, and what is left to check there. |

Links are the graph's `edges` and the items of `GET .../links`:

| Field | Description |
| - | - |
| `from`, `to` | The finding the link starts from, and the finding reached through it. |
| `confidence` | How confident the link is, 0 to 100. |
| `label` | Why the link holds, and where it came from. |

Events are the agents' turn summaries:

| Field | Description |
| - | - |
| `id`, `seq` | The event's id and its order in the investigation. |
| `session_id`, `agent_id` | The agent session and the agent that wrote it. |
| `turn` | The agent's turn when it was written. |
| `kind` | `turn_summary`. |
| `summary` | What the agent did, shortened for display. `detail.summary` holds the full text. |
| `created_at` | When it was written. |

With activity access, the event list also includes tool calls and their `payload`: `args`, `result` and `thinking`. A large payload has a non-null `payload.storage_ref` instead of inline values; `GET /investigations/{investigation_id}/events/{event_id}/payload` returns it in full. The request takes the event's `id`. `storage_ref` is opaque.

### Images and attachments

Job results and image fields link attachments by permanent `https://api.sixtyfour.ai/v1/media/...` URLs that need no API key and can be embedded. For organizations with customer-managed encryption, media URLs need the `x-api-key` header, so fetch them from your server.

## Following a run live

`GET .../events/stream` sends the agents' turn summaries over [Server-Sent Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events) as they are written, in order. Omit `after` to replay from the start.

| Frame | Sent | Data |
| - | - | - |
| `sessions` | When the stream opens, and whenever an agent session starts, finishes or changes | Every agent session |
| `event` | For each turn summary | The event. Its `id:` is the cursor to resume from |
| `status` | When the stream opens, and whenever the investigation's status changes | `status` and `completed_at` |
| `end` | When the investigation is `completed` or `failed` and every event has been sent | `status`. The stream closes |
| `access_lost` | When you can no longer see the investigation | None. The stream closes |

The `sessions` frame before `end` carries the run's cost, or `null` if the cost has not been recorded yet; read `cost_credits` from `GET /investigations/{investigation_id}` later. Comment lines keep the connection open; ignore them.

`status` and `end` follow the investigation's [status](#investigation-status). After you continue a finished investigation, open the stream once it reads `running`.

A stream closes after about five minutes. Reconnect with the last event's `id` as `after` or as a `Last-Event-ID` header; `after` also accepts `next_cursor` from `GET .../events`. Every new stream sends `status` and `sessions` again, so treat them as the current state, not as changes.

Browser `EventSource` can't send the `x-api-key` header, so read the stream with an HTTP client, as below. Close it on `end` or `access_lost`: the stream sets `retry: 1000`, and each reconnect counts toward your [rate limit](https://docs.sixtyfour.ai/api-reference/rate-limits.md#atlas).

```bash cURL theme={null}
curl -N "https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID/events/stream" \
  -H "x-api-key: YOUR_API_KEY"
```

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

STREAM = "https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID/events/stream"
HEADERS = {"x-api-key": "YOUR_API_KEY"}

after, done = None, False
while not done:
    params = {"after": after} if after else None
    with requests.get(STREAM, headers=HEADERS, params=params, stream=True, timeout=(10, 60)) as response:
        if response.status_code in (429, 503):
            time.sleep(int(response.headers.get("Retry-After", "10")))
            continue
        response.raise_for_status()
        frame = {}
        for raw in response.iter_lines():
            line = raw.decode()
            if line:
                field, _, value = line.partition(": ")
                frame[field] = value
                continue
            if frame.get("event") == "event":
                after = frame["id"]
                print(json.loads(frame["data"])["summary"])
            elif frame.get("event") in ("end", "access_lost"):
                done = True
                break
            frame = {}
```

```javascript JavaScript theme={null}
const STREAM = "https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID/events/stream";
const headers = { "x-api-key": "YOUR_API_KEY" };
const sleep = (seconds) => new Promise((resolve) => setTimeout(resolve, seconds * 1000));

let after = null;
let done = false;
while (!done) {
  const response = await fetch(after ? `${STREAM}?after=${encodeURIComponent(after)}` : STREAM, { headers });
  if (response.status === 429 || response.status === 503) {
    await sleep(Number(response.headers.get("Retry-After") ?? 10));
    continue;
  }
  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
  const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
  let buffer = "";
  while (!done) {
    const { value, done: closed } = await reader.read();
    if (closed) break;
    buffer += value;
    let boundary;
    while (!done && (boundary = buffer.indexOf("\n\n")) !== -1) {
      const frame = {};
      for (const line of buffer.slice(0, boundary).split("\n")) {
        const split = line.indexOf(": ");
        if (split > 0) frame[line.slice(0, split)] = line.slice(split + 2);
      }
      buffer = buffer.slice(boundary + 2);
      if (frame.event === "event") {
        after = frame.id;
        console.log(JSON.parse(frame.data).summary);
      } else if (frame.event === "end" || frame.event === "access_lost") {
        done = true;
      }
    }
  }
  await reader.cancel();
}
```

## Reports

Atlas starts a report when a run completes. To get one at any other time, or to be sure it covers the newest findings:

1. `POST .../report` starts a PDF report from the current workspace and returns 202 with a report build. A report build is not a [Job](https://docs.sixtyfour.ai/api-reference/async-jobs.md): it has its own statuses, below. A request while a report is building joins that build; if the build predates newer findings, the job has `follow_up: true` and a new build starts after it. If the latest report is current, the job is `completed` with `cached: true`. Send `{"retry_failed": true}` to retry a failed build. An empty workspace returns 400.
2. Poll `GET .../report` until `status` is `completed` and `follow_up` is `false`. It returns the latest job: `job_id`, `status`, `follow_up`, `cached`, `requested_at`, `completed_at`, `error` and `byte_size`.
3. Download `GET .../report.pdf`.

| `status` | Meaning |
| - | - |
| `pending`, `running` | The build is in progress. |
| `completed` | The build finished, and `report.pdf` serves its PDF. |
| `failed` | The build failed, and `error` says so. With `follow_up: true`, a build from the newest findings follows; otherwise `POST .../report` with `retry_failed: true` tries again. |
| `superseded` | A revision in the web app replaced the build before it finished. |

If `follow_up` stays `true` for 10 minutes after a build ends, send `POST .../report` again.

`GET .../report.pdf` answers:

| Response | When |
| - | - |
| `200` | The latest report. `X-Report-As-Of` is when its findings were read; `X-Report-Current: false` means the investigation has changed since. |
| `202` | No report can be served yet: the first one is being written, or the last one cited something since removed or rewritten and its replacement is being written. The body is the job; retry after `Retry-After` seconds. |
| `404` | No report exists. See [Handling Errors](https://docs.sixtyfour.ai/api-reference/errors.md). |

When no run is going, you can also poll `report.pdf` after `POST .../report` until it returns `200` with `X-Report-Current: true`. An older report that only lacks newer findings returns `200` with `X-Report-Current: false`.

```bash cURL theme={null}
# Request the report
curl -X POST "https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID/report" \
  -H "x-api-key: YOUR_API_KEY"

# Repeat every 15 s until status is "completed" and follow_up is false
curl "https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID/report" \
  -H "x-api-key: YOUR_API_KEY"

# Download it
curl -o report.pdf "https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID/report.pdf" \
  -H "x-api-key: YOUR_API_KEY"
```

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

BASE = "https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID"
HEADERS = {"x-api-key": "YOUR_API_KEY"}


def call(method, path):
    while True:
        response = requests.request(method, f"{BASE}/{path}", headers=HEADERS)
        if response.status_code not in (429, 503):
            response.raise_for_status()
            return response
        time.sleep(int(response.headers.get("Retry-After", "10")))


call("POST", "report")
while True:
    job = call("GET", "report").json()
    if job["status"] == "completed" and not job["follow_up"]:
        pdf = call("GET", "report.pdf")
        if pdf.status_code == 200:
            break
    elif job["status"] not in ("pending", "running") and not job["follow_up"]:
        raise RuntimeError(f"Report {job['status']}: {job['error']}")
    time.sleep(15)

with open("report.pdf", "wb") as file:
    file.write(pdf.content)
```

```javascript JavaScript theme={null}
const BASE = "https://api.sixtyfour.ai/v1/atlas/investigations/INVESTIGATION_ID";
const headers = { "x-api-key": "YOUR_API_KEY" };
const sleep = (seconds) => new Promise((resolve) => setTimeout(resolve, seconds * 1000));

async function call(path, init = {}) {
  while (true) {
    const response = await fetch(`${BASE}/${path}`, { ...init, headers });
    if (response.status !== 429 && response.status !== 503) {
      if (!response.ok) throw new Error(`Request failed: ${response.status}`);
      return response;
    }
    await sleep(Number(response.headers.get("Retry-After") ?? 10));
  }
}

await call("report", { method: "POST" });
let pdf;
while (true) {
  const job = await (await call("report")).json();
  if (job.status === "completed" && !job.follow_up) {
    const response = await call("report.pdf");
    if (response.status === 200) {
      pdf = await response.arrayBuffer();
      break;
    }
  } else if (!["pending", "running"].includes(job.status) && !job.follow_up) {
    throw new Error(`Report ${job.status}: ${job.error}`);
  }
  await sleep(15);
}
```

## Export

`GET .../export.zip` downloads everything visible in the app in one archive:

| Path | Contents |
| - | - |
| `investigation.json` | The investigation record. |
| `attribution-graph.json`, `attribution-graph.svg` | The attribution graph as data and as an image, when it has findings. |
| `agents/sessions.json`, `agents/events.jsonl` | The agents' sessions and turn summaries. Each session's cost is `null` when you may not see what the investigation's creator spent. |
| Workspace paths | Every workspace file. Each attachment comes with a `<path>.json` metadata sidecar. |

`GET .../identifiers.csv` lists every email address, phone number, IP address, name, organization, account and domain the investigation found, one row each, with its confidence, whom it is about, a source URL, the finding that names it and when it was first found. Retired findings are left out. An email or IP address read from a finding about something else leaves `About` and `Relation` empty. Cells a spreadsheet would run as formulas are escaped with a leading `'`; pass `spreadsheet_safe=false` to read the file as data.

## Web app only

These have no API route and are done in the [web app](https://docs.sixtyfour.ai/atlas/web-app.md): stopping a run (**Stop latest run**), steering agents, attaching files to a run, sharing with another team or by public link, renaming and deleting investigations, folders, editing notes and findings, revising a report and reading earlier versions, automations, and saved instructions.

## Pricing

See [Credit Costs](https://docs.sixtyfour.ai/guides/credits-and-pricing.md#atlas-investigations) for more information.

## Related

* [Atlas Overview](https://docs.sixtyfour.ai/atlas/overview.md)
* [Atlas Integrations](https://docs.sixtyfour.ai/atlas/integrations.md)
* [Handling Errors](https://docs.sixtyfour.ai/api-reference/errors.md)

## Org chart output

Start an investigation with `task: "org_chart"`, `engine: "xhigh"` and the company in `lead_info`. Use `research_plan` for an optional department or other scope. Org chart tasks use per-person billing; see [Credit Costs](https://docs.sixtyfour.ai/guides/credits-and-pricing.md#org-charts).

Read `GET /investigations/{investigation_id}/output` for the latest saved structured output. The response contains `data` and `confidence` objects. Org chart data includes `nodes`, `relationships` and `company_linkedin_id`; nodes represent companies, teams and people. Output can be partial while research runs. Before the current run has saved output, both objects are empty. The endpoint uses the same investigation access rules as other reads.


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