> ## 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.

# Monitor Endpoints (Legacy)

> Create monitors from rows or a file, read, update, trigger, and cancel them, and read change history, snapshots, and history exports.

> [!NOTE]
>
> This page documents the original routes, which keep working. For new integrations, use the `/v1` routes in [Monitor Endpoints](https://docs.sixtyfour.ai/api-reference/monitors/monitors-endpoints.md). [Legacy](https://docs.sixtyfour.ai/api-reference/legacy.md) maps each original route to its `/v1` replacement.

Watch fields on a list of people or companies and read what changed. Use these endpoints to create a monitor from rows or from a file, inspect its rows and events, export the table at any point in time or across a date range, and change or stop it. See [Monitors Overview](https://docs.sixtyfour.ai/api-reference/legacy/monitors-overview.md) for how checks work.

> [!NOTE]
>
> Monitors require access for your organization. Contact [support@sixtyfour.ai](mailto:support@sixtyfour.ai).

> [card] [API Reference](https://docs.sixtyfour.ai/api-reference/monitors-v1/create-monitor.md)
>
> See the full request/response schema and parameters in the API Reference.

LinkedIn-specific field discovery and single-profile creation are documented in [LinkedIn Monitors](https://docs.sixtyfour.ai/api-reference/legacy/linkedin-monitors.md). The read, update, trigger, cancel, history, and export endpoints here apply to both monitor types.

## Create monitor

Create one monitor from a table, with one row per subject.

```http theme={null}
POST https://api.sixtyfour.ai/monitors
```

| Field | Type | Required | Description |
| - | - | - | - |
| `name` | string | Yes | Monitor name, 1–120 characters. Each row is named after it, followed by the row's key values. |
| `rows` | array of objects | One of `rows` or `handle_id` | The table, one object per subject. |
| `handle_id` | string (UUID) | One of `rows` or `handle_id` | A CSV upload handle from [`POST /storage/csv/upload`](https://docs.sixtyfour.ai/api-reference/legacy/workflows-overview#uploading-an-input-file), used instead of `rows`. See [Rows from an upload handle](#rows-from-an-upload-handle). |
| `key_columns` | array of strings | Yes | Columns that identify each row. Every row needs a value in at least one of them. |
| `struct` | object | Yes | Watched fields, keyed by field name. Each value is a description or an object with `type`, `description`, and `subfields`. At least one field. A row column with the same name as a watched field sets that field's starting value; send starting values as strings (see [Values](https://docs.sixtyfour.ai/api-reference/legacy/monitors-overview.md#values)). |
| `frequency` | string | No | How often to check, `1h` to `365d`. Default `1d`. LinkedIn monitors differ. See [Frequency](https://docs.sixtyfour.ai/api-reference/legacy/monitors-overview.md#frequency). |
| `tier` | string | No | Depth of the full re-check: `low` (default), `medium`, or `high`. `high` requires High tier access for your organization. |
| `subject_type` | string | No | `company` (default) or `lead`. |
| `monitor_type` | string | No | `research` (default) or `linkedin`. See [Create a LinkedIn monitor from multiple profiles](#create-a-linkedin-monitor-from-multiple-profiles). |
| `research_plan` | string | No | Instructions for the enrichment that re-derives the fields. Up to 100,000 characters. |
| `webhook_url` | string | No | Public URL that receives notifications. See [Monitor Notifications](https://docs.sixtyfour.ai/api-reference/legacy/monitor-notifications.md). |
| `webhook_event_types` | array of strings | No | Nonempty list of `monitor.field.changed`, `monitor.execution.completed`, `monitor.execution.failed`, or `monitor.run.completed`. Defaults to `["monitor.field.changed"]`. |
| `metadata` | object | No | Free-form data stored on the monitor and echoed in events and notifications. Sixtyfour adds keys to it; see [Metadata](#metadata). |
| `is_active` | boolean | No | Default `true`. `false` creates the monitor paused: nothing is checked until you resume it with [Update monitor](#update-monitor). See [Disabled reasons](#disabled-reasons). |
| `first_check` | string | No | `now` (default) immediately runs setup only for rows missing watched values. Complete rows wait for the schedule, including in mixed tables. `next_tick` defers every row to the first scheduled fire. |
| `idempotency_key` | string | No | Up to 255 characters. A resend with the same key, or an identical body without one, returns the monitor the first attempt created, even if it has since been paused, updated, or cancelled. Send a new key to create the monitor again. |

Send exactly one of `rows` or `handle_id`; a monitor needs at least one row. For large tables, use [Create monitor from a file](#create-monitor-from-a-file).

See [Billing](https://docs.sixtyfour.ai/api-reference/legacy/monitors-overview.md#billing) for what creation checks.

Creation is all or nothing. If any row is invalid, nothing is created. The response is `201` with the monitor, without its rows. Read them with [List rows](#list-rows).

### Example request

```json theme={null}
{
  "name": "Portfolio leadership",
  "key_columns": ["company_name", "domain"],
  "rows": [
    { "company_name": "Acme Robotics", "domain": "acmerobotics.com", "ceo_name": "Dana Lee" },
    { "company_name": "Northwind Labs", "domain": "northwindlabs.io" }
  ],
  "struct": {
    "ceo_name": "Full name of the current CEO",
    "headcount": { "type": "int", "description": "Current number of employees" }
  },
  "frequency": "1d",
  "tier": "low",
  "subject_type": "company",
  "webhook_url": "https://example.com/hooks/sixtyfour",
  "webhook_event_types": ["monitor.field.changed", "monitor.execution.completed", "monitor.execution.failed"],
  "metadata": { "portfolio_id": "p_42" }
}
```

### Example response

```json theme={null}
{
  "monitor_type": "research",
  "id": "0b7f2c6e-4a1d-4a8e-9f3b-2d5c8e1a7b90",
  "org_id": "acme",
  "team_id": "5e1d9c3a-7b2f-4e6a-8c1d-3f9a2b4c6d8e",
  "name": "Portfolio leadership",
  "frequency": "1d",
  "struct": {
    "ceo_name": "Full name of the current CEO",
    "headcount": { "type": "int", "description": "Current number of employees" }
  },
  "tier": "low",
  "subject_type": "company",
  "research_plan": null,
  "is_active": true,
  "disabled_reason": null,
  "webhook_url": "https://example.com/hooks/sixtyfour",
  "webhook_event_types": ["monitor.field.changed", "monitor.execution.completed", "monitor.execution.failed"],
  "metadata": { "portfolio_id": "p_42" },
  "last_run_at": null,
  "next_run_times": [
    "2026-09-29T00:00:00+00:00",
    "2026-09-30T00:00:00+00:00",
    "2026-10-01T00:00:00+00:00"
  ],
  "row_count": 2,
  "active_row_count": 2,
  "status": "active",
  "created_at": "2026-09-28T17:05:12.482Z",
  "updated_at": "2026-09-28T17:05:12.482Z"
}
```

### Rows from an upload handle

`handle_id` reads the rows of a `.csv`, `.json`, `.jsonl`, or `.ndjson` file uploaded with `POST /storage/csv/upload`. The upload must belong to the same team as the request, and the file can hold up to 100,000 rows. The file is read when the monitor is created, and its rows pass the same checks as `rows`.

With `monitor_type: "linkedin"`, the file needs exactly one column of profile URLs, under any header. The response is still `201`, but with `status: "starting"`: rows are added in the background, as in [Create monitor from a file](#create-monitor-from-a-file).

### Metadata

`metadata` is stored on the monitor and its rows. It is echoed in the `payload` of `change` and `established` events and in every notification.

Sixtyfour adds keys that record where the rows came from:

| Key | Added when |
| - | - |
| `source_handle_id` | The monitor was created from a file, with `POST /monitors/upload` or `handle_id`. Holds the upload handle the rows were read from. |
| `workflow_run_id` | The monitor was created in the web app from a workflow run's results. Holds that run's ID. |

Your own keys sit beside them. [Updating](#update-monitor) `metadata` replaces the whole object, including these keys.

***

## Create monitor from a file

Create one monitor from an uploaded file, with one row per subject. Use this endpoint for large tables: the request returns as soon as the file is validated, and the rows are added afterwards.

```http theme={null}
POST https://api.sixtyfour.ai/monitors/upload
```

The request is `multipart/form-data` with two parts.

| Part | Type | Required | Description |
| - | - | - | - |
| `file` | file | Yes | A `.csv`, `.json`, `.jsonl`, or `.ndjson` file. Maximum 100 MB and 100,000 rows. CSV files need a header row. |
| `config` | string | Yes | The monitor's settings as a JSON-encoded string. Maximum 1,000,000 characters. |

`config` takes the fields of [Create monitor](#create-monitor) except `rows`, `handle_id`, and `idempotency_key`. Every column in `key_columns` must exist in the file.

| Header | Required | Description |
| - | - | - |
| `Idempotency-Key` | No | Up to 255 characters. Works like `idempotency_key` on [Create monitor](#create-monitor); without it, the key is derived from `config` and the file. |

The file is validated in full before anything is created. If any row is invalid, nothing is created.

The response is `202` with the monitor, without its rows. `status` is `starting` and `row_count` is `0`. Rows are then added in the background, in the file's order, and `row_count` rises as they arrive. When every row is in, `status` becomes `active`, `next_run_times` is populated, and the first check follows `first_check`. Poll `GET /monitors/{monitor_id}` to follow progress.

While `status` is `starting`, no row is checked or billed. The monitor cannot be triggered, and an update cannot change its `frequency` or `is_active`. `POST /monitors/{monitor_id}/cancel` is accepted: the rows finish adding and the monitor stays cancelled.

Uploads are rate limited; see [Rate Limits](https://docs.sixtyfour.ai/api-reference/rate-limits.md#monitors).

### Example request

```bash theme={null}
curl -X POST "https://api.sixtyfour.ai/monitors/upload" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@companies.csv" \
  -F 'config={
    "name": "Portfolio leadership",
    "key_columns": ["company_name", "domain"],
    "struct": {
      "ceo_name": "Full name of the current CEO",
      "headcount": {"type": "int", "description": "Current number of employees"}
    },
    "frequency": "1d",
    "tier": "low",
    "subject_type": "company"
  }'
```

### Example response

```json theme={null}
{
  "monitor_type": "research",
  "id": "0b7f2c6e-4a1d-4a8e-9f3b-2d5c8e1a7b90",
  "org_id": "acme",
  "team_id": "5e1d9c3a-7b2f-4e6a-8c1d-3f9a2b4c6d8e",
  "name": "Portfolio leadership",
  "frequency": "1d",
  "struct": {
    "ceo_name": "Full name of the current CEO",
    "headcount": { "type": "int", "description": "Current number of employees" }
  },
  "tier": "low",
  "subject_type": "company",
  "research_plan": null,
  "is_active": true,
  "disabled_reason": "Rows are still being added.",
  "webhook_url": null,
  "webhook_event_types": ["monitor.field.changed"],
  "metadata": { "source_handle_id": "3f8b2c1e-9d4a-4e7b-8c2f-6a1d5e9b7c30" },
  "last_run_at": null,
  "next_run_times": [],
  "row_count": 0,
  "active_row_count": 0,
  "status": "starting",
  "created_at": "2026-09-28T17:05:12.482Z",
  "updated_at": "2026-09-28T17:05:12.482Z"
}
```

### Interrupted uploads

If adding rows fails, `status` becomes `failed` and `disabled_reason` explains the failure. Send the same request again to finish it: rows that were already added are kept, and only the missing rows are written.

If adding rows stops without finishing, `status` becomes `failed` once `updated_at` is more than five minutes old. Send the same request again to finish it.

***

## List monitors

Retrieve your team's monitors, newest first. Rows are not included.

```http theme={null}
GET https://api.sixtyfour.ai/monitors
```

| Query parameter | Default | Description |
| - | - | - |
| `include_inactive` | `false` | Include inactive monitors. |
| `include_cancelled` | `true` | With `include_inactive=true`, `false` leaves out cancelled monitors. |
| `limit` | `50` | Page size, 1–200. |
| `cursor` | None | `next_cursor` from the previous page. |

The response is `{ "monitors": [...], "next_cursor": "..." }`. A page can hold fewer than `limit` monitors, or none, before the last page. Keep requesting pages until `next_cursor` is `null`.

URL-encode `next_cursor` when you send it back.

***

## Get monitor

Retrieve a monitor: its settings, `status`, and row counts. Rows are not included; read them with [List rows](#list-rows).

```http theme={null}
GET https://api.sixtyfour.ai/monitors/{monitor_id}
```

Every monitor response includes `status`:

| `status` | Meaning |
| - | - |
| `starting` | Rows from an uploaded file are still being added. Nothing is checked yet. |
| `failed` | Adding rows from an uploaded file failed. Nothing is checked. Send the upload request again to finish it. |
| `active` | The monitor is checking its rows on schedule. |
| `paused` | Checks are paused and can be resumed. `is_active` is `false`; `disabled_reason` says why. |
| `cancelled` | Future checks are permanently stopped. The monitor cannot be resumed or updated. |

Paused and cancelled monitors return `next_run_times: []`.

### Disabled reasons

`disabled_reason` says why a monitor or one of its rows is not being checked. It is `null` while checks run.

| `disabled_reason` | Set on | Meaning | To resume |
| - | - | - | - |
| `Rows are still being added.` | Monitor | An uploaded file's rows are being added. `status` is `starting`. | Wait until `status` is `active`. |
| Starts with `Adding rows failed` | Monitor | Adding an uploaded file's rows failed. `status` is `failed`. | Send the same upload request again. |
| `paused` | Monitor | Paused with [Update monitor](#update-monitor), or created with `is_active: false`. | Update with `"is_active": true`. |
| `cancelled` | Monitor | [Cancelled](#cancel-monitor). | Create a new monitor with a new `idempotency_key`. |
| `team_archived` | Monitor and its rows | The monitor's team was archived. | Create a new monitor on an active team. |
| `excluded` | Row | [Switched off](#switch-a-row-on-or-off). | Switch the row on. |
| `key_revoked` | Monitor | The API key that created the monitor was revoked or expired. | Create a new monitor with an active key. |
| `owner_removed` | Monitor | The user who created the monitor is no longer in the organization. | Create a new monitor. |
| `team_removed` | Monitor | The user who created the monitor is no longer in its team. | Create a new monitor. |

A monitor created with `is_active: false` whose rows were added in the background has `status: "paused"` and `disabled_reason: null`. A monitor paused with `key_revoked`, `owner_removed`, or `team_removed` pauses again at its next check if resumed, and so does a row paused with one of these or `team_archived` if switched back on. Pausing a monitor does not change its rows' `disabled_reason`.

***

## List rows

Retrieve a page of a monitor's rows, switched-off rows included, in the order they were added.

```http theme={null}
GET https://api.sixtyfour.ai/monitors/{monitor_id}/rows
```

| Query parameter | Default | Description |
| - | - | - |
| `limit` | `100` | Rows per page, 1–1000. |
| `cursor` | None | `next_cursor` from the previous page. |

The response is `{ "rows": [...], "next_cursor": "..." }`. `next_cursor` is `null` on the last page. To read the whole table at once as CSV, [download a snapshot](#download-snapshot) instead.

A row has no schedule of its own. Its `next_run_times` are the monitor's, and are empty when the row is switched off or the monitor is paused or cancelled.

### Example response

```json theme={null}
{
  "rows": [
    {
      "monitor_type": "research",
      "id": "8c3e1f2a-6b4d-4c9e-a1f7-2e5d9b3c7a10",
      "org_id": "acme",
      "team_id": "5e1d9c3a-7b2f-4e6a-8c1d-3f9a2b4c6d8e",
      "name": "Portfolio leadership: Acme Robotics, acmerobotics.com",
      "frequency": "1d",
      "subject": { "company_name": "Acme Robotics", "domain": "acmerobotics.com" },
      "struct": {
        "ceo_name": "Full name of the current CEO",
        "headcount": { "type": "int", "description": "Current number of employees" }
      },
      "baseline": { "ceo_name": "Dana Lee" },
      "tier": "low",
      "subject_type": "company",
      "research_plan": null,
      "is_active": true,
      "disabled_reason": null,
      "webhook_url": "https://example.com/hooks/sixtyfour",
      "webhook_event_types": ["monitor.field.changed", "monitor.execution.completed", "monitor.execution.failed"],
      "metadata": { "portfolio_id": "p_42" },
      "last_run_at": null,
      "next_run_times": ["2026-09-29T00:00:00+00:00"],
      "created_at": "2026-09-28T17:05:12.531Z",
      "updated_at": "2026-09-28T17:05:12.531Z"
    }
  ],
  "next_cursor": null
}
```

***

## List monitor runs

List a monitor's runs, newest first. A run is one scheduled or triggered check of the monitor, not a workflow run.

```http theme={null}
GET https://api.sixtyfour.ai/monitors/{monitor_id}/runs?limit=100
```

```json theme={null}
{
  "runs": [
    {
      "run_id": "01a13cb3-4b52-763d-a4ea-c6261a32c731",
      "status": "completed",
      "started_at": "2026-10-15T06:00:00+00:00",
      "completed_at": "2026-10-15T06:54:17+00:00",
      "rows_total": 500000,
      "rows_checked": 500000,
      "rows_failed": 0,
      "rows_skipped": 0,
      "rows_changed": 1
    }
  ],
  "next_cursor": null
}
```

`status` is `running`, `completed`, or `failed`. Counts are final once `status` is `completed` or `failed`. `rows_checked` includes successful checks with no changes. A completed run can include failed row checks, reported in `rows_failed`.

A run is `failed` when any row's check ends in an error before recording a result, or the run stops before every row finishes. A failed run sends no `monitor.run.completed` notification, and its changed rows are not available from [Get a run's changed rows](#get-a-runs-changed-rows). The other rows' changes are still recorded: read them from [row events](#list-row-events), [List latest changes](#list-latest-changes), or [snapshots](#list-snapshots). Poll this list to catch runs that end without a notification.

Both run endpoints accept `limit` (default `100`, maximum `500`) and `cursor`. Pass the response's `next_cursor` unchanged as the next request's `cursor`; `null` means there are no more pages.

## Get a run's changed rows

Retrieve only the rows changed by a completed run, with previous and current values for each changed field. Initial values and unchanged rows are excluded; a completed run with no changes returns `changes: []`.

```http theme={null}
GET https://api.sixtyfour.ai/monitors/{monitor_id}/runs/{run_id}/changes?limit=100
```

```json theme={null}
{
  "run_id": "01a13cb3-4b52-763d-a4ea-c6261a32c731",
  "changes": [
    {
      "row_id": "8c3e1f2a-6b4d-4c9e-a1f7-2e5d9b3c7a10",
      "subject": { "name": "Jane Doe" },
      "fields": {
        "job_title": { "previous": "Manager", "current": "Director" }
      }
    }
  ],
  "next_cursor": null
}
```

Each entry contains all changed fields for that row.

***

## List latest changes

Retrieve, for every row, when each watched field last changed. Use it to highlight recently changed cells without reading every row's events.

```http theme={null}
GET https://api.sixtyfour.ai/monitors/{monitor_id}/changes
```

The response is an object keyed by row ID. Each row maps field names to timestamps (ISO 8601, UTC) of their latest `change` events. Only `change` events count; `established` values and checks that found nothing are excluded. Rows and fields that never changed are omitted, so a monitor with no changes returns `{}`. For the values themselves, [list the row's events](#list-row-events) or [download a snapshot](#download-snapshot).

```json theme={null}
{
  "8c3e1f2a-6b4d-4c9e-a1f7-2e5d9b3c7a10": {
    "ceo_name": "2026-10-02T00:04:51.118000+00:00"
  }
}
```

***

## Get the monitor a workflow run started

Retrieve the monitor that a workflow's `monitor` block started. Read its rows with [List rows](#list-rows).

```http theme={null}
GET https://api.sixtyfour.ai/monitors/for-run/{workflow_run_id}/{block_id}
```

Only the monitor's team can read it. See the [`monitor` block](https://docs.sixtyfour.ai/api-reference/workflows/workflow-blocks#monitor).

## List a workflow run's monitors

Retrieve every monitor started from one workflow run, newest first. Rows are not included.

```http theme={null}
GET https://api.sixtyfour.ai/monitors/for-run/{workflow_run_id}
```

The response is a JSON array of up to 50 monitors. LinkedIn monitors are listed only when your organization has LinkedIn monitoring. For the next page, set `cursor` to `{created_at}|{id}` of the last monitor on the page, URL-encoded, with its time zone. An empty array ends the list.

***

## Update monitor

Change a monitor’s settings, including how often it runs, how deeply it researches, and where it notifies.

```http theme={null}
POST https://api.sixtyfour.ai/monitors/{monitor_id}/update
```

`struct` is fixed at creation. Changing watched fields requires a new monitor, with its own baseline and history.

All body fields are optional: `name`, `frequency`, `tier`, `webhook_url`, `webhook_event_types`, `metadata`, `is_active`, and `criteria` (LinkedIn only). Changes apply to every row. Send `null` for `webhook_url` or `metadata` to clear them. Changing `tier` checks tier access and the team's spend limit. For LinkedIn monitors, see [Update a LinkedIn monitor](https://docs.sixtyfour.ai/api-reference/legacy/linkedin-monitors.md#update-a-linkedin-monitor).

`webhook_event_types` replaces the subscription. Omit it to keep the current one, or send `null` to restore `["monitor.field.changed"]`.

`is_active: false` pauses the whole monitor; `is_active: true` resumes a paused monitor. Pausing through this endpoint sets `disabled_reason: "paused"`, and resuming clears it. A row you switched off stays off when the monitor resumes.

### Example request

```json theme={null}
{
  "frequency": "6h",
  "tier": "medium",
  "webhook_event_types": ["monitor.field.changed", "monitor.execution.completed"]
}
```

***

## Trigger monitor

Check every active row now, without waiting for the next scheduled fire.

```http theme={null}
POST https://api.sixtyfour.ai/monitors/{monitor_id}/trigger
```

Returns `202` with `{ "status": "accepted", "monitor_id": "..." }`. Only a monitor whose `status` is `active` can be triggered. If a check of the monitor is already running, the triggered one is skipped, with the same response.

A triggered check runs every active row through the same steps as a scheduled check and is billed the same way. See [Credit Costs](https://docs.sixtyfour.ai/guides/credits-and-pricing.md#monitors).

***

## Cancel monitor

Permanently stop future checks for the whole monitor. Existing baselines and history remain readable. Cancellation cannot be undone. To start checks again, create a new monitor with a new idempotency key. To stop checks temporarily, [pause the monitor](#update-monitor) instead.

```http theme={null}
POST https://api.sixtyfour.ai/monitors/{monitor_id}/cancel
```

Returns the monitor with `status: "cancelled"`, `is_active: false`, `disabled_reason: "cancelled"`, and `next_run_times: []`. Cancelling again returns the cancelled monitor.

***

## Get row

Retrieve one row, including the values its watched fields currently hold in `baseline`.

```http theme={null}
GET https://api.sixtyfour.ai/monitors/{monitor_id}/rows/{row_id}
```

***

## Switch a row on or off

Include or exclude one row from checks.

```http theme={null}
POST https://api.sixtyfour.ai/monitors/{monitor_id}/rows/{row_id}
Content-Type: application/json

{"is_active": false}
```

`is_active` is a required boolean in the JSON body. Send `true` to include the row again. Rows of a cancelled monitor cannot be changed. A switched-off row is skipped on every tick, is not billed, and keeps its baseline and history. Its `disabled_reason` is `excluded`.

***

## List row events

Retrieve one row's events, newest first.

```http theme={null}
GET https://api.sixtyfour.ai/monitors/{monitor_id}/rows/{row_id}/events
```

| Query parameter | Default | Description |
| - | - | - |
| `event_group_id` | None | Only the events from one check, for example the `event_group_id` from a notification. |
| `field` | None | Only one field's history. |
| `include_completions` | `false` | Include `completion` events for checks that found no change. |
| `limit` | `20` | 1–500. |

There is no cursor: a request returns at most the newest 500 events that match its filters. Narrow it with `field` or `event_group_id`, or read older values from [snapshots](#list-snapshots) or [Export history](#export-history).

### Example response

```json theme={null}
[
  {
    "id": "e41c7a2b-9d3f-4b6e-8a1c-5f2d7e9b3a60",
    "event_group_id": "a7d2e9f1-3c5b-4e8a-9b1d-6f4c2e8a0b37",
    "event_type": "change",
    "field": "ceo_name",
    "previous_value": "Dana Lee",
    "current_value": "Priya Raman",
    "payload": {
      "sources": ["https://acmerobotics.com/about/leadership"],
      "confidence": 92,
      "justification": "The company's leadership page lists Priya Raman as CEO.",
      "hint": "Leadership page updated with a new CEO.",
      "metadata": { "portfolio_id": "p_42" }
    },
    "created_at": "2026-10-02T00:04:51.118Z"
  }
]
```

See [Events](https://docs.sixtyfour.ai/api-reference/legacy/monitors-overview.md#events) for every event type.

***

## List snapshots

List every moment the monitor's data changed, newest first, each with a download link. A snapshot is recorded for each second in which a value was established or changed, so one run of a large monitor records many snapshots.

```http theme={null}
GET https://api.sixtyfour.ai/monitors/{monitor_id}/snapshots
```

| Query parameter | Default | Description |
| - | - | - |
| `limit` | `100` | Snapshots per page, 1–500. |
| `before` | None | Only snapshots before this ISO 8601 timestamp. Pass the last `as_of` from the previous page to read the next page. |
| `start` | None | Only snapshots at or after this ISO 8601 timestamp. |
| `end` | None | Only snapshots at or before this ISO 8601 timestamp. Must not be earlier than `start`. |

### Example response

```json theme={null}
[
  {
    "as_of": "2026-10-02T00:04:51+00:00",
    "changed_fields": ["ceo_name"],
    "subjects_changed": 1,
    "url": "https://api.sixtyfour.ai/monitors/0b7f2c6e-4a1d-4a8e-9f3b-2d5c8e1a7b90/snapshots/2026-10-02T00%3A04%3A51%2B00%3A00"
  }
]
```

***

## Download snapshot

Download the table as it stood at a moment, as CSV: one row per subject, with the key columns followed by the watched fields.

```http theme={null}
GET https://api.sixtyfour.ai/monitors/{monitor_id}/snapshots/{as_of}
```

`as_of` is an `as_of` value from the snapshot list, URL-encoded, or `latest` for the current values. Any ISO 8601 timestamp is accepted and returns the values held at that time.

| Query parameter | Default | Description |
| - | - | - |
| `limit` | None | Return only the first 1–1000 rows, for a preview. Omit it for the whole table. |

Cells hold the stored values unchanged, including any a spreadsheet would run as a formula.

***

## Export history

Download many snapshots at once as a ZIP of CSVs, one file per snapshot. Each file has the same columns as [Download snapshot](#download-snapshot) and is named after its timestamp, with `:` replaced by `-`.

```http theme={null}
POST https://api.sixtyfour.ai/monitors/{monitor_id}/history-export
```

Send the snapshot selection in the JSON body. CSV cells hold the stored values unchanged, as in [Download snapshot](#download-snapshot).

| Field | Type | Required | Description |
| - | - | - | - |
| `timestamps` | array of strings | No | Snapshot `as_of` values to export, 1–5,000. Omit to export every snapshot between `start` and `end`. |
| `start` | string | No | ISO 8601 timestamp, inclusive. Omit to start from the first snapshot. |
| `end` | string | No | ISO 8601 timestamp, inclusive. Defaults to now. Must not be earlier than `start`. |
| `exclude` | array of strings | No | Snapshot `as_of` values to leave out, up to 5,000. |

Timestamps without a time zone are read as UTC. An export is limited to 5,000 snapshots and 50 MiB of CSV. A larger export, one that takes too long to build, or a range with no snapshots is refused before any data is sent; select fewer snapshots or a shorter range.

Exports are rate limited; see [Rate Limits](https://docs.sixtyfour.ai/api-reference/rate-limits.md#monitors). On `429` or `503`, wait for `Retry-After` and send the request again, as the examples do.

```bash cURL theme={null}
# --retry waits for Retry-After on 429 and 503 responses (curl 7.66 or later).
curl -X POST "https://api.sixtyfour.ai/monitors/MONITOR_ID/history-export" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"start": "2026-01-01T00:00:00Z", "end": "2026-03-31T23:59:59Z"}' \
  --retry 5 \
  -o monitor-history.zip
```

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

import requests

for _ in range(5):
    response = requests.post(
        "https://api.sixtyfour.ai/monitors/MONITOR_ID/history-export",
        headers={"x-api-key": "YOUR_API_KEY"},
        json={"start": "2026-01-01T00:00:00Z", "end": "2026-03-31T23:59:59Z"},
    )
    if response.status_code not in (429, 503):
        break
    time.sleep(int(response.headers.get("Retry-After", "15")))
response.raise_for_status()
with open("monitor-history.zip", "wb") as f:
    f.write(response.content)
```

```javascript JavaScript theme={null}
import { writeFile } from "node:fs/promises";

let response;
for (let attempt = 0; attempt < 5; attempt++) {
  response = await fetch(
    "https://api.sixtyfour.ai/monitors/MONITOR_ID/history-export",
    {
      method: "POST",
      headers: { "x-api-key": "YOUR_API_KEY", "Content-Type": "application/json" },
      body: JSON.stringify({ start: "2026-01-01T00:00:00Z", end: "2026-03-31T23:59:59Z" }),
    },
  );
  if (response.status !== 429 && response.status !== 503) break;
  const waitSeconds = Number(response.headers.get("Retry-After") ?? 15);
  await new Promise((resolve) => setTimeout(resolve, waitSeconds * 1000));
}
if (!response.ok) throw new Error(`Export failed: ${response.status}`);
await writeFile("monitor-history.zip", Buffer.from(await response.arrayBuffer()));
```

***

## Example usage

### Create from a file

Upload a file, then wait until every row is added.

```bash cURL theme={null}
curl -X POST "https://api.sixtyfour.ai/monitors/upload" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@companies.csv" \
  -F 'config={"name": "Portfolio leadership", "key_columns": ["company_name", "domain"], "struct": {"ceo_name": "Full name of the current CEO"}, "frequency": "1d", "subject_type": "company"}'

curl "https://api.sixtyfour.ai/monitors/MONITOR_ID" \
  -H "x-api-key: YOUR_API_KEY"
```

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

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.sixtyfour.ai"
headers = {"x-api-key": API_KEY}

config = {
    "name": "Portfolio leadership",
    "key_columns": ["company_name", "domain"],
    "struct": {"ceo_name": "Full name of the current CEO"},
    "frequency": "1d",
    "subject_type": "company",
}

with open("companies.csv", "rb") as f:
    response = requests.post(
        f"{BASE_URL}/monitors/upload",
        headers=headers,
        files={"file": ("companies.csv", f, "text/csv")},
        data={"config": json.dumps(config)},
    )
response.raise_for_status()
monitor = response.json()

while monitor["status"] == "starting":
    time.sleep(10)
    poll = requests.get(f"{BASE_URL}/monitors/{monitor['id']}", headers=headers)
    if poll.status_code in (429, 503):
        time.sleep(int(poll.headers.get("Retry-After", "10")))
        continue
    poll.raise_for_status()
    monitor = poll.json()

if monitor["status"] == "failed":
    raise RuntimeError(monitor["disabled_reason"])
print(monitor["status"], monitor["row_count"])
```

```javascript JavaScript theme={null}
import { readFile } from "node:fs/promises";

const API_KEY = "YOUR_API_KEY";
const BASE_URL = "https://api.sixtyfour.ai";
const headers = { "x-api-key": API_KEY };

const form = new FormData();
form.append(
  "file",
  new Blob([await readFile("companies.csv")], { type: "text/csv" }),
  "companies.csv",
);
form.append(
  "config",
  JSON.stringify({
    name: "Portfolio leadership",
    key_columns: ["company_name", "domain"],
    struct: { ceo_name: "Full name of the current CEO" },
    frequency: "1d",
    subject_type: "company",
  }),
);

const response = await fetch(`${BASE_URL}/monitors/upload`, {
  method: "POST",
  headers,
  body: form,
});
if (!response.ok) {
  throw new Error(`Failed to create monitor: ${await response.text()}`);
}
let monitor = await response.json();

while (monitor.status === "starting") {
  await new Promise((resolve) => setTimeout(resolve, 10000));
  const poll = await fetch(`${BASE_URL}/monitors/${monitor.id}`, { headers });
  if (poll.status === 429 || poll.status === 503) {
    const waitSeconds = Number(poll.headers.get("Retry-After") ?? 10);
    await new Promise((resolve) => setTimeout(resolve, waitSeconds * 1000));
    continue;
  }
  if (!poll.ok) {
    throw new Error(`Failed to read monitor: ${await poll.text()}`);
  }
  monitor = await poll.json();
}

if (monitor.status === "failed") {
  throw new Error(monitor.disabled_reason);
}
console.log(monitor.status, monitor.row_count);
```

### Create from rows

Create a monitor, then read the changes for one of its rows.

```bash cURL theme={null}
curl -X POST "https://api.sixtyfour.ai/monitors" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Portfolio leadership",
    "key_columns": ["company_name", "domain"],
    "rows": [
      {"company_name": "Acme Robotics", "domain": "acmerobotics.com", "ceo_name": "Dana Lee"}
    ],
    "struct": {"ceo_name": "Full name of the current CEO"},
    "frequency": "1d",
    "subject_type": "company"
  }'

curl "https://api.sixtyfour.ai/monitors/MONITOR_ID/rows" \
  -H "x-api-key: YOUR_API_KEY"

curl "https://api.sixtyfour.ai/monitors/MONITOR_ID/rows/ROW_ID/events?field=ceo_name" \
  -H "x-api-key: YOUR_API_KEY"
```

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

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.sixtyfour.ai"
headers = {"x-api-key": API_KEY, "Content-Type": "application/json"}

response = requests.post(
    f"{BASE_URL}/monitors",
    headers=headers,
    json={
        "name": "Portfolio leadership",
        "key_columns": ["company_name", "domain"],
        "rows": [
            {"company_name": "Acme Robotics", "domain": "acmerobotics.com", "ceo_name": "Dana Lee"}
        ],
        "struct": {"ceo_name": "Full name of the current CEO"},
        "frequency": "1d",
        "subject_type": "company",
    },
)
response.raise_for_status()
monitor = response.json()

rows = requests.get(f"{BASE_URL}/monitors/{monitor['id']}/rows", headers=headers)
rows.raise_for_status()
row_id = rows.json()["rows"][0]["id"]

events = requests.get(
    f"{BASE_URL}/monitors/{monitor['id']}/rows/{row_id}/events",
    headers=headers,
    params={"field": "ceo_name"},
)
events.raise_for_status()
for event in events.json():
    print(event["event_type"], event["previous_value"], "->", event["current_value"])
```

```javascript JavaScript theme={null}
const API_KEY = "YOUR_API_KEY";
const BASE_URL = "https://api.sixtyfour.ai";
const headers = { "x-api-key": API_KEY, "Content-Type": "application/json" };

const response = await fetch(`${BASE_URL}/monitors`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    name: "Portfolio leadership",
    key_columns: ["company_name", "domain"],
    rows: [
      { company_name: "Acme Robotics", domain: "acmerobotics.com", ceo_name: "Dana Lee" },
    ],
    struct: { ceo_name: "Full name of the current CEO" },
    frequency: "1d",
    subject_type: "company",
  }),
});
if (!response.ok) {
  throw new Error(`Failed to create monitor: ${await response.text()}`);
}
const monitor = await response.json();

const rowsResponse = await fetch(`${BASE_URL}/monitors/${monitor.id}/rows`, {
  headers,
});
if (!rowsResponse.ok) {
  throw new Error(`Failed to read rows: ${await rowsResponse.text()}`);
}
const rowId = (await rowsResponse.json()).rows[0].id;

const eventsResponse = await fetch(
  `${BASE_URL}/monitors/${monitor.id}/rows/${rowId}/events?field=ceo_name`,
  { headers },
);
const events = await eventsResponse.json();
for (const event of events) {
  console.log(event.event_type, event.previous_value, "->", event.current_value);
}
```

## Create a LinkedIn monitor from multiple profiles

`POST /monitors` accepts multiple profiles with `monitor_type: "linkedin"`, `subject_type: "lead"`, and `key_columns: ["linkedin_url"]`. Each row contains only a LinkedIn person URL. The `struct` keys are selected field keys from discovery. There is one monitor ID and one schedule for the table.

```json theme={null}
{
  "name": "Profile changes",
  "monitor_type": "linkedin",
  "subject_type": "lead",
  "key_columns": ["linkedin_url"],
  "rows": [
    { "linkedin_url": "https://www.linkedin.com/in/example-one" },
    { "linkedin_url": "https://www.linkedin.com/in/example-two" }
  ],
  "struct": { "headline": "Headline", "skills": "Skills" },
  "frequency": "1w",
  "first_check": "next_tick"
}
```

Frequency, upload, and duplicate-profile rules for LinkedIn monitors are in [LinkedIn Monitors](https://docs.sixtyfour.ai/api-reference/legacy/linkedin-monitors.md#csv-upload).

## Pricing

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

## Related

* [Monitors Overview](https://docs.sixtyfour.ai/api-reference/legacy/monitors-overview.md)
* [Monitor Notifications](https://docs.sixtyfour.ai/api-reference/legacy/monitor-notifications.md)
* [Handling Errors](https://docs.sixtyfour.ai/api-reference/legacy/errors.md)


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