# Parallel AI

> Search the web and images, read pages as clean markdown, get cited answers, run deep research, build verified lists of companies and people, and keep watching the web for changes, using Parallel's APIs built for AI agents.

App · AI Search & Memory · 17 actions. Web page: https://docs.lodol.com/docs/integrations/parallel-ai

## Actions

### Ask a question

Ask Parallel a question and get a written answer researched on the live web, with the sources it cites, in about 5 to 60 seconds. Quicker than a research task; use a research task when the question needs deep, multi-step research or per-field confidence.

**Inputs**

- Question (`question`, text, required): The question, written so it stands on its own, for example, 'Which G7 country has the highest corporate tax rate this year?'.
- Research effort (`reasoning_effort`, text): How much research Parallel does before answering. 'Low' suits simple facts (about 5-10 seconds), 'Medium' questions that need a few lookups (about 15-20 seconds), and 'High' questions that need broad research and synthesis (up to a minute, and the most expensive). One of: `low` (Low (simple facts)), `medium` (Medium (recommended)), `high` (High (deep questions)). Default: `medium`.
- Instructions (`instructions`, text): Optional guidance on how to answer, for example, 'Answer in two sentences' or 'Give amounts in euros'.
- Answer format (JSON Schema) (`output_schema`, text): Optional JSON Schema the answer must follow, so later steps can read each field, for example '{"type": "object", "properties": {"capital": {"type": "string"}, "population": {"type": "integer"}}, "required": ["capital", "population"], "additionalProperties": false}'. Leave blank for a written answer.
- Websites to include (`include_domains`, list): Only use sources from these websites (for example, sec.gov or nytimes.com). A bare extension such as .edu or .gov also works. Leave blank to search the whole web.
- Websites to exclude (`exclude_domains`, list): Leave out sources from these websites (for example, reddit.com or pinterest.com).
- Follow up on (`previous_response_id`, text): To ask a follow-up, the response ID an earlier 'Ask a question' step returned. The question can then say 'its population' or 'the second one' without restating what came before.

**Outputs**

- `answer` (object): The answer: text, or an object following the answer format when one was given.
- `citation_count` (number): How many sources the answer cites.
- `citations` (list): The sources behind the answer, each with its web address, title, and the parts of the answer it supports.
- `output_type` (text): Whether the answer is 'text' or 'json'.
- `pages_read` (list): The web pages Parallel opened to answer.
- `response_id` (text): Parallel's ID for this answer. Pass it to another 'Ask a question' step as 'Follow up on'.
- `search_queries` (list): The searches Parallel ran to answer.
- `status` (text): 'completed', or 'incomplete' if cut short.

**Example output**

```json
{
  "answer": "France has the highest headline corporate tax rate in the G7 this year, at 25.8%.",
  "citation_count": 1,
  "citations": [
    {
      "cited_text": [
        "France has the highest headline corporate tax rate"
      ],
      "title": "Corporate tax rates in the G7",
      "url": "https://example.com/g7-corporate-tax-rates"
    }
  ],
  "output_type": "text",
  "pages_read": [
    "https://example.com/g7-corporate-tax-rates"
  ],
  "response_id": "resp_a0fa0e42fa1b4bf0ae62baca311fd5b6",
  "search_queries": [
    "G7 corporate tax rates 2026"
  ],
  "status": "completed"
}
```

### Cancel a FindAll run

Stop a FindAll run that is still going, so it finds and bills no more matches. A run that has already finished is left as it is, and the step still succeeds.

**Inputs**

- FindAll run ID (`findall_id`, text, required): The FindAll run's ID, as returned by 'Find all matching companies or people', for example, 'findall_40e0ab8c10754be0b7a16477abb38a2f'.

**Outputs**

- `already_finished` (true/false): True when the run had already finished, so there was nothing to stop.
- `cancelled` (true/false): True when this step stopped the run.
- `findall_id` (text): The FindAll run's ID.

**Example output**

```json
{
  "already_finished": false,
  "cancelled": true,
  "findall_id": "findall_40e0ab8c10754be0b7a16477abb38a2f"
}
```

### Cancel a monitor

Stop a monitor for good. This can't be undone: to start watching again, create a new monitor. Its past events stay readable.

**Inputs**

- Monitor ID (`monitor_id`, text, required): The monitor's ID, as returned by 'Create a monitor' or 'List monitors', for example, 'monitor_b0079f70195e4258a3b982c1b6d8bd3a'.

**Outputs**

- `created_at` (text): When it was created.
- `frequency` (text): How often it runs.
- `include_backfill` (true/false): Whether its first run reported recent past events.
- `last_run_at` (text): When it last ran.
- `latest_snapshot` (object): For a snapshot monitor, the latest answer to the research task: text, or an object with the task's fields.
- `latest_snapshot_type` (text): Whether the latest snapshot is 'text' or 'json'.
- `monitor_id` (text): The monitor's ID.
- `processor` (text): The processor it runs on.
- `query` (text): What the monitor watches the web for.
- `status` (text): Whether the monitor is 'active' or 'cancelled'.
- `task_run_id` (text): For a snapshot monitor, the research task it re-checks.
- `type` (text): 'event_stream' for a monitor that watches a query, 'snapshot' for one that keeps re-checking a research task's answer.
- `webhook_url` (text): Where it reports new events, if anywhere.

**Example output**

```json
{
  "created_at": "2026-10-14T09:00:00Z",
  "frequency": "1d",
  "include_backfill": false,
  "last_run_at": "2026-10-14T09:00:05Z",
  "latest_snapshot": null,
  "latest_snapshot_type": null,
  "monitor_id": "monitor_b0079f70195e4258a3b982c1b6d8bd3a",
  "processor": "lite",
  "query": "Funding rounds announced by open source vector database companies",
  "status": "cancelled",
  "task_run_id": null,
  "type": "event_stream",
  "webhook_url": null
}
```

### Check a FindAll run

Check a FindAll run by its ID and get the matches found so far. Use it to collect a run that outlasted the wait on 'Find all matching companies or people'.

**Inputs**

- FindAll run ID (`findall_id`, text, required): The FindAll run's ID, as returned by 'Find all matching companies or people', for example, 'findall_40e0ab8c10754be0b7a16477abb38a2f'.

**Outputs**

- `candidate_count` (number): How many candidates have been evaluated so far.
- `completed` (true/false): Whether the run has finished searching.
- `entity_type` (text): What kind of entity the run looked for.
- `findall_id` (text): Parallel's ID for this FindAll run. Pass it to 'Check a FindAll run' to collect more matches later.
- `generated_count` (number): How many candidates the run has considered.
- `generator` (text): The generator tier the run used.
- `match_conditions` (list): The conditions every match had to meet, each with a name and a description.
- `match_count` (number): How many matches so far.
- `matches` (list): The entities that met every condition, each with its name, web address, description, the value found for each condition (under 'fields'), and the sources behind them.
- `status` (text): The run's status: queued, running, completed, failed, cancelling, or cancelled.
- `termination_reason` (text): Why a finished run stopped, such as match_limit_met or candidates_exhausted.
- `timed_out` (true/false): True when the wait ran out before the run finished. It keeps going on Parallel's side.

**Example output**

```json
{
  "candidate_count": 3,
  "completed": false,
  "entity_type": null,
  "findall_id": "findall_40e0ab8c10754be0b7a16477abb38a2f",
  "generated_count": 3,
  "generator": "core",
  "match_conditions": null,
  "match_count": 1,
  "matches": [
    {
      "candidate_id": "candidate_a062dd17-d77a-4b1b-ad0e-de113e82f838",
      "citations": [
        {
          "excerpts": [
            "Qdrant today announced a $28M Series A..."
          ],
          "field": "condition_2",
          "title": "Qdrant raises $28M",
          "url": "https://qdrant.tech/blog/series-a"
        }
      ],
      "description": "Open source vector database and similarity search engine.",
      "fields": {
        "condition_1": "Qdrant is released under the Apache 2.0 license.",
        "condition_2": "Raised a $28M Series A in January 2024."
      },
      "match_status": "matched",
      "name": "Qdrant",
      "url": "https://qdrant.tech"
    }
  ],
  "status": "running",
  "termination_reason": null,
  "timed_out": false
}
```

### Check a research task

Check a research task by its run ID and get the result once it has finished. Use this to collect a long Pro or Ultra run that outlasted the wait on 'Run a research task'.

**Inputs**

- Run ID (`run_id`, text, required): The research run's ID, as returned by 'Run a research task', for example, 'trun_9f2c1b4e6a7d4f8b9c0d1e2f3a4b5c6d'.

**Outputs**

- `basis` (list): Parallel's reasoning and confidence for each field of the output.
- `citation_count` (number): How many sources the answer cites.
- `citations` (list): The sources behind the answer.
- `completed` (true/false): Whether the research finished and an output is included.
- `interaction_id` (text): Pass this to another research task as 'Follow up on' to build on this research.
- `output` (object): The researched answer, once the run has completed.
- `output_type` (text): Whether the output is 'text' or 'json'.
- `processor` (text): The processor tier the run used.
- `run_id` (text): Parallel's ID for this research run.
- `status` (text): The run's status: queued, running, completed, failed, cancelled, or action_required.
- `timed_out` (true/false): Always false here: this step doesn't wait.
- `warnings` (list): Anything Parallel flagged about the request, such as a setting it adjusted.

**Example output**

```json
{
  "basis": [],
  "citation_count": 0,
  "citations": [],
  "completed": false,
  "interaction_id": "trun_9f2c1b4e6a7d4f8b9c0d1e2f3a4b5c6d",
  "output": null,
  "output_type": null,
  "processor": "pro",
  "run_id": "trun_9f2c1b4e6a7d4f8b9c0d1e2f3a4b5c6d",
  "status": "running",
  "timed_out": false,
  "warnings": []
}
```

### Create a monitor

Have Parallel keep watching the web for something, such as news about a company or a price change, and record each new development as an event. It checks once straight away and then on your schedule; each check is billed.

**Inputs**

- What to watch for (`query`, text): What to look out for, written as a request, for example, 'New funding rounds announced by open source vector database companies'. Leave blank only when re-checking a research task below.
- Frequency (`frequency`, text, required): How often the monitor checks the web: a number and a unit, h for hours, d for days or w for weeks, such as 6h, 1d or 1w. Anything from 1h to 30d. Default: `1d`.
- Processor (`processor`, text): 'Lite' suits a narrow topic such as one company; 'Base' a wide one such as a whole industry or region, and costs more per check. One of: `lite` (Lite (narrow topics, cheaper)), `base` (Base (broad topics, more thorough)). Default: `lite`.
- Include recent past events (`include_backfill`, true/false): Have the first check also report a sample of recent events from before the monitor was created. Otherwise only new developments are reported. Default: `false`.
- Event format (JSON Schema) (`output_schema`, text): Optional JSON Schema each event must follow, so later steps can read its fields, for example '{"type": "object", "properties": {"company": {"type": "string"}, "amount": {"type": "string"}}}'. Leave blank for a written description of each event.
- Websites to include (`include_domains`, list): Only use sources from these websites (for example, sec.gov or nytimes.com). A bare extension such as .edu or .gov also works. Leave blank to search the whole web.
- Websites to exclude (`exclude_domains`, list): Leave out sources from these websites (for example, reddit.com or pinterest.com).
- Country (`location`, text): Favor results from one country, as a two-letter country code such as us, gb, de or jp. Leave blank for no preference.
- Webhook URL (`webhook_url`, text): Optional web address Parallel calls when the monitor finds something new or a run fails. Leave blank to read events with 'List monitor events'.
- Re-check a research task (`task_run_id`, text): Instead of a query: the run ID of a finished research task. The monitor re-runs it on the schedule and reports which parts of its answer changed. The event format, websites and country settings don't apply.

**Outputs**

- `created_at` (text): When it was created.
- `frequency` (text): How often it runs.
- `include_backfill` (true/false): Whether its first run reported recent past events.
- `last_run_at` (text): When it last ran.
- `latest_snapshot` (object): For a snapshot monitor, the latest answer to the research task: text, or an object with the task's fields.
- `latest_snapshot_type` (text): Whether the latest snapshot is 'text' or 'json'.
- `monitor_id` (text): The monitor's ID.
- `processor` (text): The processor it runs on.
- `query` (text): What the monitor watches the web for.
- `status` (text): Whether the monitor is 'active' or 'cancelled'.
- `task_run_id` (text): For a snapshot monitor, the research task it re-checks.
- `type` (text): 'event_stream' for a monitor that watches a query, 'snapshot' for one that keeps re-checking a research task's answer.
- `webhook_url` (text): Where it reports new events, if anywhere.

**Example output**

```json
{
  "created_at": "2026-10-14T09:00:00Z",
  "frequency": "1d",
  "include_backfill": false,
  "last_run_at": "2026-10-14T09:00:05Z",
  "latest_snapshot": null,
  "latest_snapshot_type": null,
  "monitor_id": "monitor_b0079f70195e4258a3b982c1b6d8bd3a",
  "processor": "lite",
  "query": "Funding rounds announced by open source vector database companies",
  "status": "active",
  "task_run_id": null,
  "type": "event_stream",
  "webhook_url": null
}
```

### Find all matching companies or people

Describe the companies, people or other things you want in a sentence and Parallel builds the list from the web, checking every candidate against each of your conditions and citing its sources. Runs take from a few minutes to much longer; a run still going when the wait ends hands back an ID to collect later.

**Inputs**

- What to find (`objective`, text, required): What to find, as one sentence with every condition in it, for example, 'Fintech companies in Brazil that offer earned-wage access' or 'AI infrastructure startups that raised a Series B in the last 6 months'.
- Generator (`generator`, text): How hard Parallel looks, which sets the price. 'Let Parallel choose' picks the tier that suits the query. 'Preview' checks about ten candidates to test a query cheaply; 'Base' suits broad queries with many matches; 'Core' specific ones; 'Pro' rare, hard-to-find matches. One of: `auto` (Let Parallel choose), `preview` (Preview (test a query)), `base` (Base (broad queries)), `core` (Core (specific queries)), `pro` (Pro (rare matches)). Default: `auto`.
- Maximum matches (`match_limit`, number): Stop once this many matches are found, from 5 to 1000. Each match is billed, so start small. A preview checks at most 10 candidates. From 5 to 1000. Default: `10`.
- Conditions (`match_conditions`, list): Optional: the conditions every match must meet, one sentence each, for example, 'Headquartered in Brazil' and 'Offers earned-wage access to employers'. Leave blank and Parallel works them out from 'What to find'.
- Kind of thing to find (`entity_type`, text): Optional: what kind of thing each match is, such as companies, people or products. Leave blank and Parallel works it out.
- How long to wait (`max_wait_seconds`, number): How long this step waits for the run to finish, in seconds (default 300, maximum 900). If it is still going, the step succeeds with the matches so far and the run's ID, so use 'Check a FindAll run' later for the rest. From 1 to 900. Default: `300`.

**Outputs**

- `candidate_count` (number): How many candidates have been evaluated so far.
- `completed` (true/false): Whether the run has finished searching.
- `entity_type` (text): What kind of entity the run looked for.
- `findall_id` (text): Parallel's ID for this FindAll run. Pass it to 'Check a FindAll run' to collect more matches later.
- `generated_count` (number): How many candidates the run has considered.
- `generator` (text): The generator tier the run used.
- `match_conditions` (list): The conditions every match had to meet, each with a name and a description.
- `match_count` (number): How many matches so far.
- `matches` (list): The entities that met every condition, each with its name, web address, description, the value found for each condition (under 'fields'), and the sources behind them.
- `status` (text): The run's status: queued, running, completed, failed, cancelling, or cancelled.
- `termination_reason` (text): Why a finished run stopped, such as match_limit_met or candidates_exhausted.
- `timed_out` (true/false): True when the wait ran out before the run finished. It keeps going on Parallel's side.

**Example output**

```json
{
  "candidate_count": 8,
  "completed": true,
  "entity_type": "companies",
  "findall_id": "findall_40e0ab8c10754be0b7a16477abb38a2f",
  "generated_count": 8,
  "generator": "base",
  "match_conditions": [
    {
      "description": "Builds an open source vector database.",
      "name": "condition_1"
    },
    {
      "description": "Has raised venture funding.",
      "name": "condition_2"
    }
  ],
  "match_count": 1,
  "matches": [
    {
      "candidate_id": "candidate_a062dd17-d77a-4b1b-ad0e-de113e82f838",
      "citations": [
        {
          "excerpts": [
            "Qdrant today announced a $28M Series A..."
          ],
          "field": "condition_2",
          "title": "Qdrant raises $28M",
          "url": "https://qdrant.tech/blog/series-a"
        }
      ],
      "description": "Open source vector database and similarity search engine.",
      "fields": {
        "condition_1": "Qdrant is released under the Apache 2.0 license.",
        "condition_2": "Raised a $28M Series A in January 2024."
      },
      "match_status": "matched",
      "name": "Qdrant",
      "url": "https://qdrant.tech"
    }
  ],
  "status": "completed",
  "termination_reason": "match_limit_met",
  "timed_out": false
}
```

### Get a monitor

Get one monitor's settings and status, and for a monitor that re-checks a research task, its latest answer.

**Inputs**

- Monitor ID (`monitor_id`, text, required): The monitor's ID, as returned by 'Create a monitor' or 'List monitors', for example, 'monitor_b0079f70195e4258a3b982c1b6d8bd3a'.

**Outputs**

- `created_at` (text): When it was created.
- `frequency` (text): How often it runs.
- `include_backfill` (true/false): Whether its first run reported recent past events.
- `last_run_at` (text): When it last ran.
- `latest_snapshot` (object): For a snapshot monitor, the latest answer to the research task: text, or an object with the task's fields.
- `latest_snapshot_type` (text): Whether the latest snapshot is 'text' or 'json'.
- `monitor_id` (text): The monitor's ID.
- `processor` (text): The processor it runs on.
- `query` (text): What the monitor watches the web for.
- `status` (text): Whether the monitor is 'active' or 'cancelled'.
- `task_run_id` (text): For a snapshot monitor, the research task it re-checks.
- `type` (text): 'event_stream' for a monitor that watches a query, 'snapshot' for one that keeps re-checking a research task's answer.
- `webhook_url` (text): Where it reports new events, if anywhere.

**Example output**

```json
{
  "created_at": "2026-10-14T09:00:00Z",
  "frequency": "1d",
  "include_backfill": false,
  "last_run_at": "2026-10-14T09:00:05Z",
  "latest_snapshot": null,
  "latest_snapshot_type": null,
  "monitor_id": "monitor_b0079f70195e4258a3b982c1b6d8bd3a",
  "processor": "lite",
  "query": "Funding rounds announced by open source vector database companies",
  "status": "active",
  "task_run_id": null,
  "type": "event_stream",
  "webhook_url": null
}
```

### List monitor events

List what a monitor has found, newest first: each new development with its sources, or, for a monitor that re-checks a research task, which parts of the answer changed.

**Inputs**

- Monitor ID (`monitor_id`, text, required): The monitor's ID, as returned by 'Create a monitor' or 'List monitors', for example, 'monitor_b0079f70195e4258a3b982c1b6d8bd3a'.
- Maximum events (`limit`, number): How many events to list, up to 100. From 1 to 100. Default: `20`.
- Include quiet checks (`include_completions`, true/false): Also list the checks that found nothing new, to see when the monitor ran. Failed checks are always listed. Default: `false`.
- Event group ID (`event_group_id`, text): Optional: list only the events from one check, by the event group ID a webhook or an earlier listing gave.
- Next cursor (`cursor`, text): To list older events, the next cursor an earlier 'List monitor events' step returned.

**Outputs**

- `event_count` (number): How many events were listed.
- `events` (list): The events, newest first. Each has an event_type ('event_stream' for a new development, 'snapshot' for a changed answer, 'completion' for a quiet check, 'error' for a failed one), its date, the output describing it, and its citations.
- `next_cursor` (text): Pass this as 'Next cursor' to list older events; empty when there are no more.
- `warnings` (list): Anything Parallel flagged about the request, such as a setting it adjusted.

**Example output**

```json
{
  "event_count": 1,
  "events": [
    {
      "citations": [
        {
          "excerpts": [],
          "field": "output",
          "title": "Qdrant raises $50M",
          "url": "https://example.com/qdrant-series-b"
        }
      ],
      "error_message": null,
      "event_date": "2026-10-13",
      "event_group_id": "mevtgrp_2d4f6a8c0e1b3d5f",
      "event_id": "mevt_6b1f0e2a9c3d4e5f",
      "event_type": "event_stream",
      "output": "Qdrant announced a $50M Series B.",
      "output_type": "text",
      "previous_output": null,
      "timestamp": null
    }
  ],
  "next_cursor": null,
  "warnings": []
}
```

### List monitors

List your Parallel monitors, newest first.

**Inputs**

- Show (`status`, text): Which monitors to list. One of: `active` (Active monitors), `cancelled` (Cancelled monitors), `all` (All monitors). Default: `active`.
- Maximum monitors (`limit`, number): How many to list, up to 1000. From 1 to 1000. Default: `50`.
- Next cursor (`cursor`, text): To list the next page, the next cursor an earlier 'List monitors' step returned.

**Outputs**

- `monitor_count` (number): How many monitors were listed.
- `monitors` (list): The monitors, newest first.
- `next_cursor` (text): Pass this as 'Next cursor' to list more; empty when there are no more.

**Example output**

```json
{
  "monitor_count": 1,
  "monitors": [
    {
      "created_at": "2026-10-14T09:00:00Z",
      "frequency": "1d",
      "include_backfill": false,
      "last_run_at": "2026-10-14T09:00:05Z",
      "latest_snapshot": null,
      "latest_snapshot_type": null,
      "monitor_id": "monitor_b0079f70195e4258a3b982c1b6d8bd3a",
      "processor": "lite",
      "query": "Funding rounds announced by open source vector database companies",
      "status": "active",
      "task_run_id": null,
      "type": "event_stream",
      "webhook_url": null
    }
  ],
  "next_cursor": null
}
```

### Read web pages

Read one or more web pages and get them back as clean markdown: either the passages that matter for your objective, or the whole page.

**Inputs**

- Web page addresses (`urls`, list, required): The web addresses (URLs) of the pages to read, such as those from an earlier search. Up to 20 at a time. Pass a list even when there is only one page.
- Objective (`objective`, text): What you want out of these pages, so Parallel can pick the passages that matter. Leave blank to get a general read of each page.
- Keywords to look for (`search_queries`, list): Optional short keyword queries used alongside the objective to pick which passages of each page are worth returning.
- Return the whole page (`full_content`, true/false): Return each page in full instead of just the relevant passages. Leave off unless a later step needs the entire page; excerpts are usually enough and far shorter. Default: `false`.
- Character limit per page (`max_chars_per_result`, number): Trim each page to roughly this many characters. Leave blank to let Parallel decide. At least 1.
- Total character limit (`max_chars_total`, number): Cap the excerpts across all pages at roughly this many characters. Leave blank for no overall cap. At least 1.
- Refresh pages older than (seconds) (`max_age_seconds`, number): Fetch a page live when Parallel's copy of it is older than this many seconds (at least 600, which is ten minutes). Use it when the step needs up-to-the-minute content such as prices or scores; it makes the step noticeably slower. Leave blank to let Parallel decide. At least 600.
- Session ID (`session_id`, text): The session ID an earlier search or page read returned. Passing it tells Parallel the calls belong to the same task, which can sharpen the results. Leave blank to start a new session.

**Outputs**

- `error_count` (number): How many pages could not be read.
- `errors` (list): The pages that could not be read: each with its web address, the kind of error, the HTTP status, and the start of what the site sent back.
- `extract_id` (text): Parallel's ID for this read.
- `result_count` (number): How many pages were read.
- `results` (list): One entry per page that could be read, with its excerpts and, when requested, its full content.
- `session_id` (text): Session ID tying related searches and page reads together. Pass it to a later search or page read that belongs to the same task.
- `warnings` (list): Anything Parallel flagged about the request, such as a setting it adjusted.

**Example output**

```json
{
  "error_count": 0,
  "errors": [],
  "extract_id": "extract_cad0a6d2dec046bd95ae900527d880e7",
  "result_count": 1,
  "results": [
    {
      "excerpts": [
        "The entry tier bills at $0.034 per..."
      ],
      "full_content": null,
      "publish_date": "2026-05-14",
      "title": "Managed Postgres pricing, compared",
      "url": "https://example.com/managed-postgres-pricing"
    }
  ],
  "session_id": "session_fcb2b4f3c75e418687bccaa1a8381331",
  "warnings": []
}
```

### Run a monitor now

Have a monitor check the web now, outside its schedule. Its schedule is unchanged, and the check is billed like any other. Anything new appears in 'List monitor events' once it finishes.

**Inputs**

- Monitor ID (`monitor_id`, text, required): The monitor's ID, as returned by 'Create a monitor' or 'List monitors', for example, 'monitor_b0079f70195e4258a3b982c1b6d8bd3a'.

**Outputs**

- `monitor_id` (text): The monitor's ID.
- `triggered` (true/false): True once Parallel has queued the check.

**Example output**

```json
{
  "monitor_id": "monitor_b0079f70195e4258a3b982c1b6d8bd3a",
  "triggered": true
}
```

### Run a research task

Hand Parallel a research question and get back a researched answer with citations, reasoning, and per-field confidence. Parallel plans the search, reads the sources, and returns structured output.

**Inputs**

- Research question (`objective`, text, required): What to research, written as a self-contained request, for example, 'Summarize how each major cloud provider prices managed Postgres, and note the cheapest entry tier'.
- Processor (`processor`, text): How much research to do. 'Base' suits most questions (about a minute). The higher tiers read more sources and reason further but take much longer and cost more: Pro and Ultra take several minutes, and the Ultra 2x, 4x and 8x tiers can run for up to two hours. A run that outlasts the wait below hands back a run ID to collect later with 'Check a research task'. One of: `lite` (Lite (fastest, cheapest)), `base` (Base (recommended)), `core` (Core (more thorough)), `core2x` (Core 2x (complex questions)), `pro` (Pro (deep research, slow)), `ultra` (Ultra (deeper research)), `ultra2x` (Ultra 2x (difficult research)), `ultra4x` (Ultra 4x (very difficult research)), `ultra8x` (Ultra 8x (hardest research, up to 2 hours)). Default: `base`.
- Describe the output you want (`output_schema`, text): Plain-language description of what the answer should contain, for example 'A one-paragraph summary plus a list of providers with their entry price'. Leave blank to let Parallel choose the shape. A JSON Schema can be pasted here instead to pin the exact fields.
- Websites to include (`include_domains`, list): Only use sources from these websites (for example, sec.gov or nytimes.com). A bare extension such as .edu or .gov also works. Leave blank to search the whole web.
- Websites to exclude (`exclude_domains`, list): Leave out sources from these websites (for example, reddit.com or pinterest.com).
- Published after (`after_date`, date): Only use pages published on or after this date, in YYYY-MM-DD format. Useful for keeping research to recent sources.
- How long to wait (`max_wait_seconds`, number): How long this step waits for the research to finish, in seconds (default 300, maximum 900). If the run is still going when the wait runs out, the step succeeds and returns its run ID, so use 'Check a research task' later to collect the result. From 1 to 900. Default: `300`.
- Follow up on (`previous_interaction_id`, text): To ask a follow-up question, the interaction ID an earlier research task returned. Parallel then builds on that research, so the question can say 'these companies' or 'the second one' without restating it. Leave blank for a fresh question.
- Country (`location`, text): Favor results from one country, as a two-letter country code such as us, gb, de or jp. Leave blank for no preference.

**Outputs**

- `basis` (list): Parallel's reasoning and confidence for each field of the output.
- `citation_count` (number): How many sources the answer cites.
- `citations` (list): The sources behind the answer, each with its web address and the output field it supports.
- `completed` (true/false): Whether the research finished and an output is included.
- `interaction_id` (text): Pass this to another research task as 'Follow up on' to ask a follow-up question that builds on this research.
- `output` (object): The researched answer: text when no shape was requested, otherwise a structured object.
- `output_type` (text): Whether the output is 'text' or 'json'.
- `processor` (text): The processor tier the run used.
- `run_id` (text): Parallel's ID for this research run. Pass it to 'Check a research task' to collect a result later.
- `status` (text): The run's status: queued, running, completed, failed, cancelled, or action_required.
- `timed_out` (true/false): True when the wait ran out before the research finished. The run keeps going on Parallel's side.
- `warnings` (list): Anything Parallel flagged about the request, such as a setting it adjusted.

**Example output**

```json
{
  "basis": [
    {
      "confidence": "high",
      "field": "output",
      "reasoning": "Compared the published price pages for each provider."
    }
  ],
  "citation_count": 1,
  "citations": [
    {
      "excerpts": [
        "The entry tier bills at $0.034 per..."
      ],
      "field": "output",
      "title": "Managed Postgres pricing, compared",
      "url": "https://example.com/managed-postgres-pricing"
    }
  ],
  "completed": true,
  "interaction_id": "trun_9f2c1b4e6a7d4f8b9c0d1e2f3a4b5c6d",
  "output": "Managed Postgres entry pricing lands between $0.03 and $0.05 per vCPU-hour across the major providers.",
  "output_type": "text",
  "processor": "base",
  "run_id": "trun_9f2c1b4e6a7d4f8b9c0d1e2f3a4b5c6d",
  "status": "completed",
  "timed_out": false,
  "warnings": []
}
```

### Search companies or people

Get a ranked list of companies or people matching a description in a few seconds, each with a web address and a short description. Quick and broad; use 'Find all matching companies or people' when every result must be checked against your criteria.

**Inputs**

- Who to find (`objective`, text, required): A description of the companies or people you want, for example, 'Climate tech startups in Berlin' or 'Heads of engineering at Series B fintech companies'.
- Search for (`entity_type`, text, required): Whether to find companies or people. One of: `companies`, `people`. Default: `companies`.
- Number of results (`match_limit`, number): How many to return, from 5 to 1000. Parallel may return fewer. From 5 to 1000. Default: `25`.

**Outputs**

- `entities` (list): The companies or people, best match first, each with a name, web address, and description.
- `entity_count` (number): How many were returned.
- `entity_set_id` (text): Parallel's ID for this search.
- `entity_type` (text): 'companies' or 'people'.

**Example output**

```json
{
  "entities": [
    {
      "description": "Berlin-based company building an open source vector database.",
      "name": "Qdrant",
      "url": "https://qdrant.tech"
    }
  ],
  "entity_count": 1,
  "entity_set_id": "entity_set_cad0a6d2dec046bd95ae900527d880e7",
  "entity_type": "companies"
}
```

### Search images

Search the web for images and get each one's direct link, size, and the page it appears on.

**Inputs**

- Search queries (`search_queries`, list, required): Up to 5 short keyword queries, for example, 'Eames lounge chair' and 'Eames lounge chair product photo'.
- Objective (`objective`, text): Optional description of the images you want, for example, 'Product photos of the Eames lounge chair on a white background'. Parallel uses it to rank the results.
- Search mode (`mode`, text): 'Advanced' gives the best results (about 3 seconds); 'Fast' is quicker and a fifth of the price. One of: `advanced` (Advanced (best quality)), `fast` (Fast (quick and cheaper)). Default: `advanced`.
- Number of images (`max_results`, number): How many images to return, up to 20. From 1 to 20. Default: `10`.
- Country (`location`, text): Favor results from one country, as a two-letter country code such as us, gb, de or jp. Leave blank for no preference.
- Session ID (`session_id`, text): The session ID an earlier search or page read returned. Passing it tells Parallel the calls belong to the same task, which can sharpen the results. Leave blank to start a new session.

**Outputs**

- `result_count` (number): How many images were returned.
- `results` (list): The images, most relevant first, each with its title, direct image address (image_url), the page it appears on (source_page_url), and its width and height when known.
- `search_id` (text): Parallel's ID for this search.
- `session_id` (text): Session ID tying related searches together.
- `warnings` (list): Anything Parallel flagged about the request, such as a setting it adjusted.

**Example output**

```json
{
  "result_count": 1,
  "results": [
    {
      "height": 1200,
      "image_url": "https://example.com/images/eames-lounge.jpg",
      "source_page_url": "https://example.com/eames-lounge-chair",
      "title": "Eames lounge chair and ottoman",
      "width": 1600
    }
  ],
  "search_id": "search_cad0a6d2dec046bd95ae900527d880e7",
  "session_id": "session_8a911eb27c7a4afaa20d0d9dc98d07c0",
  "warnings": []
}
```

### Search the web

Search the web with Parallel and get ranked pages with long, relevant excerpts already pulled out of each one.

**Inputs**

- Search queries (`search_queries`, list, required): Short keyword queries, 3-6 words each. Two or three give the best results, for example, 'managed Postgres pricing' and 'cloud database price per hour'.
- Objective (`objective`, text): What you are trying to find out, written as a self-contained sentence or two, for example, 'Find the latest published pricing for each major cloud provider's managed Postgres offering'. Parallel uses this to judge which parts of each page matter.
- Search mode (`mode`, text): How much work Parallel puts into the search. 'Advanced' is the best quality and the default (about 3 seconds); 'Basic' returns longer excerpts in about a second and works well with two or three sharp queries; 'Fast' gives good results in under a second at a fifth of the price; 'Turbo' is the quickest and cheapest, for simple lookups in English or Japanese. One of: `advanced` (Advanced (best quality)), `basic` (Basic (longer excerpts)), `fast` (Fast (quick and cheaper)), `turbo` (Turbo (fastest, cheapest)). Default: `advanced`.
- Number of results (`max_results`, number): How many pages to return, up to 40. Defaults to 10. From 1 to 40. Default: `10`.
- Websites to include (`include_domains`, list): Only use sources from these websites (for example, sec.gov or nytimes.com). A bare extension such as .edu or .gov also works. Leave blank to search the whole web.
- Websites to exclude (`exclude_domains`, list): Leave out sources from these websites (for example, reddit.com or pinterest.com).
- Published after (`after_date`, date): Only use pages published on or after this date, in YYYY-MM-DD format. Useful for keeping research to recent sources.
- Character limit per page (`max_chars_per_result`, number): Trim each page's excerpts to roughly this many characters. Leave blank to let Parallel decide. At least 1.
- Total character limit (`max_chars_total`, number): Cap the excerpts across all pages at roughly this many characters, to keep the result small enough for a later AI step. Leave blank for no overall cap. At least 1.
- Country (`location`, text): Favor results from one country, as a two-letter country code such as us, gb, de or jp. Leave blank for no preference.
- Refresh pages older than (seconds) (`max_age_seconds`, number): Fetch a page live when Parallel's copy of it is older than this many seconds (at least 600, which is ten minutes). Use it when the step needs up-to-the-minute content such as prices or scores; it makes the step noticeably slower. Leave blank to let Parallel decide. At least 600.
- Session ID (`session_id`, text): The session ID an earlier search or page read returned. Passing it tells Parallel the calls belong to the same task, which can sharpen the results. Leave blank to start a new session.

**Outputs**

- `result_count` (number): How many pages were returned.
- `results` (list): The matching pages, most relevant first, each with its web address, title, publish date, and excerpts.
- `search_id` (text): Parallel's ID for this search.
- `session_id` (text): Session ID tying related searches and page reads together. Pass it to a later search or page read that belongs to the same task.
- `warnings` (list): Anything Parallel flagged about the request, such as a setting it adjusted.

**Example output**

```json
{
  "result_count": 1,
  "results": [
    {
      "excerpts": [
        "Managed Postgres starts at $0.034 per vCPU-hour..."
      ],
      "publish_date": "2026-05-14",
      "title": "Managed Postgres pricing, compared",
      "url": "https://example.com/managed-postgres-pricing"
    }
  ],
  "search_id": "search_fcb2b4f3c75e418687bccaa1a8381331",
  "session_id": "session_fcb2b4f3c75e418687bccaa1a8381331",
  "warnings": []
}
```

### Update a monitor

Change how often a monitor checks, its processor, its webhook, or (for small wording changes) what it watches for. Fields left blank stay as they are.

**Inputs**

- Monitor ID (`monitor_id`, text, required): The monitor's ID, as returned by 'Create a monitor' or 'List monitors', for example, 'monitor_b0079f70195e4258a3b982c1b6d8bd3a'.
- Frequency (`frequency`, text): How often the monitor checks the web: a number and a unit, h for hours, d for days or w for weeks, such as 6h, 1d or 1w. Anything from 1h to 30d.
- Processor (`processor`, text): The processor to use for later checks. One of: `lite` (Lite (narrow topics, cheaper)), `base` (Base (broad topics, more thorough)).
- What to watch for (`query`, text): New wording for what the monitor watches. Keep changes small: the monitor compares new findings with what it has already seen, so a different topic belongs in a new monitor.
- Webhook URL (`webhook_url`, text): Optional web address Parallel calls when the monitor finds something new or a run fails. Leave blank to read events with 'List monitor events'.

**Outputs**

- `created_at` (text): When it was created.
- `frequency` (text): How often it runs.
- `include_backfill` (true/false): Whether its first run reported recent past events.
- `last_run_at` (text): When it last ran.
- `latest_snapshot` (object): For a snapshot monitor, the latest answer to the research task: text, or an object with the task's fields.
- `latest_snapshot_type` (text): Whether the latest snapshot is 'text' or 'json'.
- `monitor_id` (text): The monitor's ID.
- `processor` (text): The processor it runs on.
- `query` (text): What the monitor watches the web for.
- `status` (text): Whether the monitor is 'active' or 'cancelled'.
- `task_run_id` (text): For a snapshot monitor, the research task it re-checks.
- `type` (text): 'event_stream' for a monitor that watches a query, 'snapshot' for one that keeps re-checking a research task's answer.
- `webhook_url` (text): Where it reports new events, if anywhere.

**Example output**

```json
{
  "created_at": "2026-10-14T09:00:00Z",
  "frequency": "1w",
  "include_backfill": false,
  "last_run_at": "2026-10-14T09:00:05Z",
  "latest_snapshot": null,
  "latest_snapshot_type": null,
  "monitor_id": "monitor_b0079f70195e4258a3b982c1b6d8bd3a",
  "processor": "lite",
  "query": "Funding rounds announced by open source vector database companies",
  "status": "active",
  "task_run_id": null,
  "type": "event_stream",
  "webhook_url": null
}
```