Parallel API reference

New to Corsair? See API access, authentication, and error handling.

Chat

create

chat.create Create a non-streaming chat completion Risk: destructive

await corsair.parallel.api.chat.create({});

Input

Name	Type	Required	Description
`model`	`string`	Yes	—
`messages`	`object[]`	Yes	—
`stream`	`false \| null`	No	—
`response_format`	`JsonValue \| null`	No	—
`max_tokens`	`number \| null`	No	—
`temperature`	`number \| null`	No	—
`top_p`	`number \| null`	No	—
`n`	`number \| null`	No	—
`presence_penalty`	`number \| null`	No	—
`frequency_penalty`	`number \| null`	No	—
`previous_interaction_id`	`string \| null`	No	—

messages full type

{
  role: system | user | assistant,
  content: string,
  name?: string | null
}[]

Output

Name	Type	Required	Description
`id`	`string`	Yes	—
`choices`	`object[]`	Yes	—
`created`	`number`	Yes	—
`model`	`string`	Yes	—
`object`	`chat.completion`	Yes	—
`moderation`	`JsonValue \| null`	No	—
`service_tier`	`string \| null`	No	—
`system_fingerprint`	`string \| null`	No	—
`usage`	`JsonValue \| null`	No	—
`basis`	`object[]`	No	—
`interaction_id`	`string \| null`	No	—

choices full type

{
  index: number,
  delta: {
    content?: string | null,
    refusal?: string | null,
    role?: string | null
  },
  finish_reason?: string | null,
  logprobs?: JsonValue | null
}[]

basis full type

{
  field: string,
  reasoning: string,
  confidence?: string | null,
  citations?: {
    url: string,
    title?: string | null,
    excerpts?: string[] | null
  }[]
}[]

Decisions

create

decisions.create Answer grounded decision questions Risk: destructive

await corsair.parallel.api.decisions.create({});

Input

Name	Type	Required	Description
`state`	`JsonValue`	Yes	—
`questions`	`object`	Yes	—
`mode`	`fast`	No	—
`advanced_settings`	`object \| null`	No	—

questions full type

Record<string, {
  type: choice,
  instructions: string,
  criteria: Record<string, string>
} | {
  type: score,
  instructions: string,
  criteria: string[]
} | {
  type: noul,
  instructions: string,
  criteria?: {
    true: string,
    false: string
  } | null
}>

advanced_settings full type

{
  location?: string | null,
  after_date?: string | null,
  include_excerpts?: boolean
} | null

Output

Name	Type	Required	Description
`mode`	`fast`	Yes	—
`answers`	`object`	Yes	—
`usage`	`object`	Yes	—
`citations`	`object[]`	Yes	—
`decision_id`	`string`	Yes	—

answers full type

Record<string, {
  type?: choice,
  choice: string,
  probabilities: Record<string, number>,
  confidence?: number | null
} | {
  type?: score,
  score: number,
  legend: Record<string, string>,
  probabilities: Record<string, number>,
  confidence?: number | null
} | {
  type?: noul,
  noul: number
} | {
  type: refusal
}>

usage full type

{
  input_tokens: number,
  output_tokens: 0
}

citations full type

{
  url: string,
  title?: string | null,
  excerpts: string[]
}[]

Extract

extract

extract.extract Extract content from web URLs Risk: read

await corsair.parallel.api.extract.extract({});

Input

Name	Type	Required	Description
`urls`	`string[]`	Yes	—
`objective`	`string \| null`	No	—
`search_queries`	`string[] \| null`	No	—
`max_chars_total`	`number \| null`	No	—
`session_id`	`string \| null`	No	—
`client_model`	`string \| null`	No	—
`advanced_settings`	`object \| null`	No	—

advanced_settings full type

{
  fetch_policy?: {
    max_age_seconds?: number | null,
    timeout_seconds?: number | null,
    disable_cache_fallback?: boolean
  } | null,
  excerpt_settings?: {
    max_chars_per_result?: number | null
  } | null,
  full_content?: boolean | {
    max_chars_per_result?: number | null
  },
  links?: boolean | null
} | null

Output

Name	Type	Required	Description
`extract_id`	`string`	Yes	—
`results`	`object[]`	Yes	—
`errors`	`object[]`	Yes	—
`warnings`	`object[] \| null`	No	—
`usage`	`object[] \| null`	No	—
`session_id`	`string`	Yes	—

results full type

{
  url: string,
  title?: string | null,
  publish_date?: string | null,
  excerpts: string[],
  full_content?: string | null,
  acquired_at?: string | null,
  links?: string[] | null
}[]

errors full type

{
  url: string,
  error_type: string,
  http_status_code: number | null,
  content: string | null
}[]

warnings full type

{
  type: string,
  message: string,
  detail?: Record<string, any> | null
}[] | null

usage full type

{
  name: string,
  count: number
}[] | null

Findall

cancel

findall.cancel Cancel a FindAll run Risk: destructive · Irreversible

await corsair.parallel.api.findall.cancel({});

Input

Name	Type	Required	Description
`findall_id`	`string`	Yes	—

Output: undefined

createRun

findall.createRun Create a FindAll run Risk: destructive

await corsair.parallel.api.findall.createRun({});

Input

Name	Type	Required	Description
`objective`	`string`	Yes	—
`entity_type`	`string`	Yes	—
`match_conditions`	`object[]`	Yes	—
`generator`	`base \| core \| pro \| preview`	Yes	—
`match_limit`	`number`	Yes	—
`exclude_list`	`object[] \| null`	No	—
`metadata`	`Record<string, string \| number \| boolean> \| null`	No	—
`webhook`	`object \| null`	No	—
`memory_scope_key`	`string \| null`	No	—

match_conditions full type

{
  name: string,
  description: string
}[]

exclude_list full type

{
  name: string,
  url: string
}[] | null

webhook full type

{
  url: string,
  event_types?: task_run.status[]
} | null

Output

Name	Type	Required	Description
`findall_id`	`string`	Yes	—
`generator`	`base \| core \| pro \| preview \| string`	Yes	—
`status`	`object`	Yes	—
`metadata`	`Record<string, string \| number \| boolean> \| null`	No	—
`created_at`	`string \| null`	No	—
`modified_at`	`string \| null`	No	—

status full type

{
  status: queued | action_required | running | completed | failed | cancelling | cancelled | string,
  is_active: boolean,
  metrics: {
    generated_candidates_count?: number,
    matched_candidates_count?: number
  },
  termination_reason?: low_match_rate | match_limit_met | candidates_exhausted | user_cancelled | error_occurred | timeout | insufficient_funds | string | null
}

enrich

findall.enrich Enrich a FindAll run Risk: destructive

await corsair.parallel.api.findall.enrich({});

Input

Name	Type	Required	Description
`findall_id`	`string`	Yes	—
`body`	`object`	Yes	—

body full type

{
  processor?: string,
  output_schema: {
    json_schema: Record<string, JsonValue>,
    type?: json
  },
  mcp_servers?: {
    type?: url,
    url: string,
    name: string,
    headers?: Record<string, string> | null,
    allowed_tools?: string[] | null
  }[] | null
}

Output

Name	Type	Required	Description
`objective`	`string`	Yes	—
`entity_type`	`string`	Yes	—
`match_conditions`	`object[]`	Yes	—
`enrichments`	`object[] \| null`	No	—
`generator`	`base \| core \| pro \| preview \| string`	No	—
`match_limit`	`number \| null`	No	—

match_conditions full type

{
  name: string,
  description: string
}[]

enrichments full type

{
  processor?: string,
  output_schema: {
    json_schema: Record<string, JsonValue>,
    type?: json
  },
  mcp_servers?: {
    type?: url,
    url: string,
    name: string,
    headers?: Record<string, string> | null,
    allowed_tools?: string[] | null
  }[] | null
}[] | null

entitySearch

findall.entitySearch Search for entities Risk: read

await corsair.parallel.api.findall.entitySearch({});

Input

Name	Type	Required	Description
`entity_type`	`people \| companies`	Yes	—
`objective`	`string`	Yes	—
`match_limit`	`number`	No	—

Output

Name	Type	Required	Description
`entity_set_id`	`string`	Yes	—
`entities`	`object[]`	Yes	—

entities full type

{
  name: string,
  url: string,
  description: string
}[]

extend

findall.extend Extend a FindAll run Risk: destructive

await corsair.parallel.api.findall.extend({});

Input

Name	Type	Required	Description
`findall_id`	`string`	Yes	—
`body`	`object`	Yes	—

body full type

{
  additional_match_limit: number
}

Output

Name	Type	Required	Description
`objective`	`string`	Yes	—
`entity_type`	`string`	Yes	—
`match_conditions`	`object[]`	Yes	—
`enrichments`	`object[] \| null`	No	—
`generator`	`base \| core \| pro \| preview \| string`	No	—
`match_limit`	`number \| null`	No	—

match_conditions full type

{
  name: string,
  description: string
}[]

enrichments full type

{
  processor?: string,
  output_schema: {
    json_schema: Record<string, JsonValue>,
    type?: json
  },
  mcp_servers?: {
    type?: url,
    url: string,
    name: string,
    headers?: Record<string, string> | null,
    allowed_tools?: string[] | null
  }[] | null
}[] | null

getRun

findall.getRun Get a FindAll run Risk: read

await corsair.parallel.api.findall.getRun({});

Input

Name	Type	Required	Description
`findall_id`	`string`	Yes	—

Output

Name	Type	Required	Description
`findall_id`	`string`	Yes	—
`generator`	`base \| core \| pro \| preview \| string`	Yes	—
`status`	`object`	Yes	—
`metadata`	`Record<string, string \| number \| boolean> \| null`	No	—
`created_at`	`string \| null`	No	—
`modified_at`	`string \| null`	No	—

status full type

{
  status: queued | action_required | running | completed | failed | cancelling | cancelled | string,
  is_active: boolean,
  metrics: {
    generated_candidates_count?: number,
    matched_candidates_count?: number
  },
  termination_reason?: low_match_rate | match_limit_met | candidates_exhausted | user_cancelled | error_occurred | timeout | insufficient_funds | string | null
}

ingest

findall.ingest Create an entity search specification Risk: destructive

await corsair.parallel.api.findall.ingest({});

Input

Name	Type	Required	Description
`objective`	`string`	Yes	—

Output

Name	Type	Required	Description
`objective`	`string`	Yes	—
`entity_type`	`string`	Yes	—
`match_conditions`	`object[]`	Yes	—
`enrichments`	`object[] \| null`	No	—
`generator`	`base \| core \| pro \| preview \| string`	No	—
`match_limit`	`number \| null`	No	—

match_conditions full type

{
  name: string,
  description: string
}[]

enrichments full type

{
  processor?: string,
  output_schema: {
    json_schema: Record<string, JsonValue>,
    type?: json
  },
  mcp_servers?: {
    type?: url,
    url: string,
    name: string,
    headers?: Record<string, string> | null,
    allowed_tools?: string[] | null
  }[] | null
}[] | null

result

findall.result Get FindAll results Risk: read

await corsair.parallel.api.findall.result({});

Input

Name	Type	Required	Description
`findall_id`	`string`	Yes	—

Output

Name	Type	Required	Description
`run`	`object`	Yes	—
`candidates`	`object[]`	Yes	—
`last_event_id`	`string \| null`	No	—

run full type

{
  findall_id: string,
  generator: base | core | pro | preview | string,
  status: {
    status: queued | action_required | running | completed | failed | cancelling | cancelled | string,
    is_active: boolean,
    metrics: {
      generated_candidates_count?: number,
      matched_candidates_count?: number
    },
    termination_reason?: low_match_rate | match_limit_met | candidates_exhausted | user_cancelled | error_occurred | timeout | insufficient_funds | string | null
  },
  metadata?: Record<string, string | number | boolean> | null,
  created_at?: string | null,
  modified_at?: string | null
}

candidates full type

{
  candidate_id: string,
  name: string,
  url: string,
  match_status: generated | matched | unmatched | discarded | string,
  description?: string | null,
  output?: Record<string, JsonValue> | null,
  basis?: {
    field: string,
    reasoning: string,
    confidence?: string | null,
    citations?: {
      url: string,
      title?: string | null,
      excerpts?: string[] | null
    }[]
  }[] | null
}[]

schema

findall.schema Get the FindAll schema Risk: read

await corsair.parallel.api.findall.schema({});

Input

Name	Type	Required	Description
`findall_id`	`string`	Yes	—

Output

Name	Type	Required	Description
`objective`	`string`	Yes	—
`entity_type`	`string`	Yes	—
`match_conditions`	`object[]`	Yes	—
`enrichments`	`object[] \| null`	No	—
`generator`	`base \| core \| pro \| preview \| string`	No	—
`match_limit`	`number \| null`	No	—

match_conditions full type

{
  name: string,
  description: string
}[]

enrichments full type

{
  processor?: string,
  output_schema: {
    json_schema: Record<string, JsonValue>,
    type?: json
  },
  mcp_servers?: {
    type?: url,
    url: string,
    name: string,
    headers?: Record<string, string> | null,
    allowed_tools?: string[] | null
  }[] | null
}[] | null

Images

search

images.search Search for images Risk: read

await corsair.parallel.api.images.search({});

Input

Name	Type	Required	Description
`objective`	`string \| null`	No	—
`search_queries`	`string[]`	Yes	—
`mode`	`fast \| advanced \| null`	No	—
`session_id`	`string \| null`	No	—
`client_model`	`string \| null`	No	—
`advanced_settings`	`object \| null`	No	—

advanced_settings full type

{
  location?: string | null,
  max_results?: number | null
} | null

Output

Name	Type	Required	Description
`search_id`	`string`	Yes	—
`warnings`	`object[] \| null`	No	—
`usage`	`object[] \| null`	No	—
`session_id`	`string`	Yes	—
`results`	`object[]`	Yes	—

warnings full type

{
  type: string,
  message: string,
  detail?: Record<string, any> | null
}[] | null

usage full type

{
  name: string,
  count: number
}[] | null

results full type

{
  title: string,
  image_url: string,
  source_page_url: string,
  width?: number | null,
  height?: number | null
}[]

Memory

clear

memory.clear Clear a memory scope Risk: destructive

await corsair.parallel.api.memory.clear({});

Input

Name	Type	Required	Description
`memory_scope_key`	`string \| null`	No	—

Output: undefined

evict

memory.evict Evict a memory source Risk: destructive

await corsair.parallel.api.memory.evict({});

Input

Name	Type	Required	Description
`memory_scope_key`	`string \| null`	No	—
`kind`	`task \| monitor \| findall`	Yes	—
`id`	`string`	Yes	—

Output: undefined

retrieve

memory.retrieve Retrieve memories Risk: read

await corsair.parallel.api.memory.retrieve({});

Input

Name	Type	Required	Description
`memory_scope_key`	`string \| null`	No	—
`query`	`string \| null`	No	—
`limit`	`number`	No	—
`kind`	`task \| monitor \| findall \| null`	No	—
`since`	`string \| null`	No	—

Output

Name	Type	Required	Description
`results`	`object[]`	Yes	—

results full type

(
  {
    kind: task,
    id: string,
    updated_at: string,
    input_excerpt: string,
    output_excerpt: string
  } | {
    kind: monitor,
    id: string,
    updated_at: string,
    input_excerpt: string,
    status: active | cancelled | string,
    matched_events?: {
      event_id: string,
      event_group_id: string,
      detected_at: string,
      excerpt: string
    }[]
  } | {
    kind: findall,
    id: string,
    updated_at: string,
    input_excerpt: string,
    matched_count: number
  } | {
    kind: string,
    id: string,
    updated_at: string,
    input_excerpt: string
  }
)[]

Monitors

cancel

monitors.cancel Permanently cancel a monitor Risk: destructive · Irreversible

await corsair.parallel.api.monitors.cancel({});

Input

Name	Type	Required	Description
`monitor_id`	`string`	Yes	—

Output

Name	Type	Required	Description
`type`	`event_stream \| snapshot \| string`	Yes	—
`monitor_id`	`string`	Yes	—
`status`	`active \| cancelled \| string`	Yes	—
`frequency`	`string`	Yes	—
`processor`	`lite \| base \| core \| string`	Yes	—
`created_at`	`string`	Yes	—
`webhook`	`object \| null`	No	—
`metadata`	`Record<string, string> \| null`	No	—
`last_run_at`	`string \| null`	No	—
`settings`	`object`	Yes	—
`output`	`object \| null`	No	—

webhook full type

{
  url: string,
  event_types?: (monitor.event.detected | monitor.execution.completed | monitor.execution.failed | string)[]
} | null

settings full type

{
  task_run_id: string,
  query: string,
  output_schema?: {
    json_schema: Record<string, JsonValue>,
    type?: json
  } | null
} | {
  query: string,
  output_schema?: {
    json_schema: Record<string, JsonValue>,
    type?: json
  } | null,
  include_backfill?: boolean | null,
  advanced_settings?: {
    source_policy?: {
      include_domains?: string[],
      exclude_domains?: string[],
      after_date?: string | null
    } | null,
    location?: string | null
  } | null
}

output full type

{
  latest_snapshot?: JsonValue | null
} | null

create

monitors.create Create a monitor Risk: destructive

await corsair.parallel.api.monitors.create({});

Input: object

Input full type

{
  type: event_stream,
  frequency: string,
  processor?: lite | base | core,
  webhook?: {
    url: string,
    event_types?: (monitor.event.detected | monitor.execution.completed | monitor.execution.failed)[]
  } | null,
  metadata?: Record<string, string> | null,
  memory_scope_key?: string | null,
  settings: {
    query: string,
    output_schema?: {
      json_schema: Record<string, JsonValue>,
      type?: json
    } | null,
    include_backfill?: boolean | null,
    advanced_settings?: {
      source_policy?: {
        include_domains?: string[],
        exclude_domains?: string[],
        after_date?: string | null
      } | null,
      location?: string | null
    } | null
  }
} | {
  type: snapshot,
  frequency: string,
  processor?: lite | base | core,
  webhook?: {
    url: string,
    event_types?: (monitor.event.detected | monitor.execution.completed | monitor.execution.failed)[]
  } | null,
  metadata?: Record<string, string> | null,
  memory_scope_key?: string | null,
  settings: {
    task_run_id: string
  }
}

Output

Name	Type	Required	Description
`type`	`event_stream \| snapshot \| string`	Yes	—
`monitor_id`	`string`	Yes	—
`status`	`active \| cancelled \| string`	Yes	—
`frequency`	`string`	Yes	—
`processor`	`lite \| base \| core \| string`	Yes	—
`created_at`	`string`	Yes	—
`webhook`	`object \| null`	No	—
`metadata`	`Record<string, string> \| null`	No	—
`last_run_at`	`string \| null`	No	—
`settings`	`object`	Yes	—
`output`	`object \| null`	No	—

webhook full type

{
  url: string,
  event_types?: (monitor.event.detected | monitor.execution.completed | monitor.execution.failed | string)[]
} | null

settings full type

{
  task_run_id: string,
  query: string,
  output_schema?: {
    json_schema: Record<string, JsonValue>,
    type?: json
  } | null
} | {
  query: string,
  output_schema?: {
    json_schema: Record<string, JsonValue>,
    type?: json
  } | null,
  include_backfill?: boolean | null,
  advanced_settings?: {
    source_policy?: {
      include_domains?: string[],
      exclude_domains?: string[],
      after_date?: string | null
    } | null,
    location?: string | null
  } | null
}

output full type

{
  latest_snapshot?: JsonValue | null
} | null

events

monitors.events List monitor events Risk: read

await corsair.parallel.api.monitors.events({});

Input

Name	Type	Required	Description
`monitor_id`	`string`	Yes	—
`event_group_id`	`string \| null`	No	—
`cursor`	`string \| null`	No	—
`limit`	`number \| null`	No	—
`include_completions`	`boolean`	No	—

Output

Name	Type	Required	Description
`events`	`object[]`	Yes	—
`next_cursor`	`string \| null`	No	—
`warnings`	`object[] \| null`	No	—

events full type

{
  event_type: event_stream | snapshot | completion | error | string,
  event_id?: string,
  event_group_id?: string,
  event_date?: string | null,
  timestamp?: string,
  error_message?: string,
  output?: JsonValue,
  changed_output?: JsonValue,
  previous_output?: JsonValue
}[]

warnings full type

{
  type: string,
  message: string,
  detail?: Record<string, any> | null
}[] | null

get

monitors.get Get a monitor Risk: read

await corsair.parallel.api.monitors.get({});

Input

Name	Type	Required	Description
`monitor_id`	`string`	Yes	—

Output

Name	Type	Required	Description
`type`	`event_stream \| snapshot \| string`	Yes	—
`monitor_id`	`string`	Yes	—
`status`	`active \| cancelled \| string`	Yes	—
`frequency`	`string`	Yes	—
`processor`	`lite \| base \| core \| string`	Yes	—
`created_at`	`string`	Yes	—
`webhook`	`object \| null`	No	—
`metadata`	`Record<string, string> \| null`	No	—
`last_run_at`	`string \| null`	No	—
`settings`	`object`	Yes	—
`output`	`object \| null`	No	—

webhook full type

{
  url: string,
  event_types?: (monitor.event.detected | monitor.execution.completed | monitor.execution.failed | string)[]
} | null

settings full type

{
  task_run_id: string,
  query: string,
  output_schema?: {
    json_schema: Record<string, JsonValue>,
    type?: json
  } | null
} | {
  query: string,
  output_schema?: {
    json_schema: Record<string, JsonValue>,
    type?: json
  } | null,
  include_backfill?: boolean | null,
  advanced_settings?: {
    source_policy?: {
      include_domains?: string[],
      exclude_domains?: string[],
      after_date?: string | null
    } | null,
    location?: string | null
  } | null
}

output full type

{
  latest_snapshot?: JsonValue | null
} | null

list

monitors.list List monitors Risk: read

await corsair.parallel.api.monitors.list({});

Input

Name	Type	Required	Description
`cursor`	`string \| null`	No	—
`limit`	`number \| null`	No	—
`type`	`(event_stream \| snapshot)[] \| null`	No	—
`status`	`(active \| cancelled)[] \| null`	No	—

Output

Name	Type	Required	Description
`monitors`	`object[]`	Yes	—
`next_cursor`	`string \| null`	No	—

monitors full type

{
  type: event_stream | snapshot | string,
  monitor_id: string,
  status: active | cancelled | string,
  frequency: string,
  processor: lite | base | core | string,
  created_at: string,
  webhook?: {
    url: string,
    event_types?: (monitor.event.detected | monitor.execution.completed | monitor.execution.failed | string)[]
  } | null,
  metadata?: Record<string, string> | null,
  last_run_at?: string | null,
  settings: {
    task_run_id: string,
    query: string,
    output_schema?: {
      json_schema: Record<string, JsonValue>,
      type?: json
    } | null
  } | {
    query: string,
    output_schema?: {
      json_schema: Record<string, JsonValue>,
      type?: json
    } | null,
    include_backfill?: boolean | null,
    advanced_settings?: {
      source_policy?: {
        include_domains?: string[],
        exclude_domains?: string[],
        after_date?: string | null
      } | null,
      location?: string | null
    } | null
  },
  output?: {
    latest_snapshot?: JsonValue | null
  } | null
}[]

stats

monitors.stats Get monitor statistics Risk: read

await corsair.parallel.api.monitors.stats({});

Input: empty object Output

Name	Type	Required	Description
`total`	`number`	Yes	—
`processor_counts`	`Record<string, Record<string, Record<string, number>>>`	Yes	—

trigger

monitors.trigger Trigger a monitor run Risk: destructive

await corsair.parallel.api.monitors.trigger({});

Input

Name	Type	Required	Description
`monitor_id`	`string`	Yes	—

Output: undefined

update

monitors.update Update a monitor Risk: destructive

await corsair.parallel.api.monitors.update({});

Input

Name	Type	Required	Description
`monitor_id`	`string`	Yes	—
`body`	`object`	Yes	—

body full type

{
  type?: event_stream,
  frequency?: string,
  processor?: lite | base | core,
  webhook?: {
    url: string,
    event_types?: (monitor.event.detected | monitor.execution.completed | monitor.execution.failed)[]
  } | null,
  metadata?: Record<string, string> | null,
  settings?: {
    query?: string,
    advanced_settings?: {
      source_policy?: {
        include_domains?: string[],
        exclude_domains?: string[],
        after_date?: string | null
      } | null,
      location?: string | null
    } | null
  }
}

Output

Name	Type	Required	Description
`type`	`event_stream \| snapshot \| string`	Yes	—
`monitor_id`	`string`	Yes	—
`status`	`active \| cancelled \| string`	Yes	—
`frequency`	`string`	Yes	—
`processor`	`lite \| base \| core \| string`	Yes	—
`created_at`	`string`	Yes	—
`webhook`	`object \| null`	No	—
`metadata`	`Record<string, string> \| null`	No	—
`last_run_at`	`string \| null`	No	—
`settings`	`object`	Yes	—
`output`	`object \| null`	No	—

webhook full type

{
  url: string,
  event_types?: (monitor.event.detected | monitor.execution.completed | monitor.execution.failed | string)[]
} | null

settings full type

{
  task_run_id: string,
  query: string,
  output_schema?: {
    json_schema: Record<string, JsonValue>,
    type?: json
  } | null
} | {
  query: string,
  output_schema?: {
    json_schema: Record<string, JsonValue>,
    type?: json
  } | null,
  include_backfill?: boolean | null,
  advanced_settings?: {
    source_policy?: {
      include_domains?: string[],
      exclude_domains?: string[],
      after_date?: string | null
    } | null,
    location?: string | null
  } | null
}

output full type

{
  latest_snapshot?: JsonValue | null
} | null

Places

search

places.search Search for places by location Risk: read

await corsair.parallel.api.places.search({});

Input

Name	Type	Required	Description
`query`	`string`	Yes	—
`location`	`string \| null`	No	—
`latitude`	`number \| null`	No	—
`longitude`	`number \| null`	No	—
`max_distance_km`	`number \| null`	No	—
`open_now`	`boolean`	No	—
`max_results`	`number \| null`	No	—
`mode`	`fast \| advanced \| null`	No	—
`session_id`	`string \| null`	No	—
`client_model`	`string \| null`	No	—

Output

Name	Type	Required	Description
`search_id`	`string`	Yes	—
`warnings`	`object[] \| null`	No	—
`usage`	`object[] \| null`	No	—
`session_id`	`string`	Yes	—
`results`	`object[]`	Yes	—

warnings full type

{
  type: string,
  message: string,
  detail?: Record<string, any> | null
}[] | null

usage full type

{
  name: string,
  count: number
}[] | null

results full type

{
  name: string,
  url?: string | null,
  address?: string | null,
  phone?: string | null,
  latitude?: number | null,
  longitude?: number | null,
  distance_km?: number | null,
  rating?: fair | good | great | excellent | string | null,
  price_level?: number | null,
  opening_hours?: {
    monday?: {
      opens: string,
      closes: string
    }[] | null,
    tuesday?: {
      opens: string,
      closes: string
    }[] | null,
    wednesday?: {
      opens: string,
      closes: string
    }[] | null,
    thursday?: {
      opens: string,
      closes: string
    }[] | null,
    friday?: {
      opens: string,
      closes: string
    }[] | null,
    saturday?: {
      opens: string,
      closes: string
    }[] | null,
    sunday?: {
      opens: string,
      closes: string
    }[] | null
  } | null,
  timezone?: string | null,
  open_now?: boolean | null
}[]

Responses

create

responses.create Create a non-streaming response Risk: destructive

await corsair.parallel.api.responses.create({});

Input

Name	Type	Required	Description
`model`	`string`	Yes	—
`input`	`string \| object[]`	Yes	—
`instructions`	`string \| null`	No	—
`previous_response_id`	`string \| null`	No	—
`stream`	`false \| null`	No	—
`text`	`Record<string, JsonValue> \| null`	No	—
`metadata`	`Record<string, string> \| null`	No	—
`reasoning`	`object \| null`	No	—
`background`	`false \| null`	No	—
`tools`	`Record<string, JsonValue>[] \| null`	No	—
`data_sources`	`object \| null`	No	—

input full type

string | {
  role: user | assistant | system | developer,
  content: string | {
    type?: string | null,
    text?: string | null
  }[]
}[]

reasoning full type

{
  effort?: low | medium | high | auto | null
} | null

data_sources full type

{
  pay_per_use?: string[],
  free?: string[],
  excluded?: string[]
} | null

Output

Name	Type	Required	Description
`id`	`string`	Yes	—
`created_at`	`number`	Yes	—
`object`	`response`	Yes	—
`output`	`object[]`	Yes	—
`parallel_tool_calls`	`boolean`	Yes	—
`model`	`parallel`	No	—
`status`	`string \| null`	No	—
`metadata`	`Record<string, string> \| null`	No	—
`previous_response_id`	`string \| null`	No	—
`usage`	`null`	No	—

output full type

(
  {
    id: string,
    type: message,
    role: assistant,
    status: string,
    content: {
      type: output_text,
      text: string,
      annotations: JsonValue[]
    }[]
  } | {
    id: string,
    type: web_search_call,
    status: string,
    action: Record<string, JsonValue>
  } | {
    id: string,
    type: mcp_call,
    status: string,
    arguments: string,
    name: string,
    server_label: string,
    output?: string | null,
    error?: JsonValue | null
  } | {
    id: string,
    type: mcp_list_tools,
    server_label: string,
    tools: JsonValue[],
    error?: string | null
  } | {
    type: string
  }
)[]

Search

search

search.search Search the web for relevant sources and excerpts Risk: read

await corsair.parallel.api.search.search({});

Input

Name	Type	Required	Description
`objective`	`string \| null`	No	—
`search_queries`	`string[]`	Yes	—
`mode`	`turbo \| fast \| basic \| advanced \| null`	No	—
`max_chars_total`	`number \| null`	No	—
`session_id`	`string \| null`	No	—
`client_model`	`string \| null`	No	—
`advanced_settings`	`object \| null`	No	—

advanced_settings full type

{
  source_policy?: {
    include_domains?: string[],
    exclude_domains?: string[],
    after_date?: string | null
  } | null,
  fetch_policy?: {
    max_age_seconds?: number | null,
    timeout_seconds?: number | null,
    disable_cache_fallback?: boolean
  } | null,
  excerpt_settings?: {
    max_chars_per_result?: number | null
  } | null,
  location?: string | null,
  max_results?: number | null
} | null

Output

Name	Type	Required	Description
`search_id`	`string`	Yes	—
`results`	`object[]`	Yes	—
`warnings`	`object[] \| null`	No	—
`usage`	`object[] \| null`	No	—
`session_id`	`string`	Yes	—

results full type

{
  url: string,
  title?: string | null,
  publish_date?: string | null,
  excerpts: string[]
}[]

warnings full type

{
  type: string,
  message: string,
  detail?: Record<string, any> | null
}[] | null

usage full type

{
  name: string,
  count: number
}[] | null

Tasks

addGroupRuns

tasks.addGroupRuns Add runs to a task group Risk: destructive

await corsair.parallel.api.tasks.addGroupRuns({});

Input

Name	Type	Required	Description
`taskgroup_id`	`string`	Yes	—
`refresh_status`	`boolean`	No	—
`parallel_beta`	`string`	No	—
`body`	`object`	Yes	—

body full type

{
  default_task_spec?: {
    output_schema: string | {
      json_schema: Record<string, JsonValue>,
      type?: json
    } | {
      type: auto
    } | {
      type?: text,
      description?: string | null
    },
    input_schema?: string | {
      json_schema: Record<string, JsonValue>,
      type?: json
    } | {
      type: auto
    } | {
      type?: text,
      description?: string | null
    } | null
  } | null,
  inputs: {
    processor: string,
    input: string | Record<string, JsonValue>,
    metadata?: Record<string, string | number | boolean> | null,
    memory_scope_key?: string | null,
    source_policy?: {
      include_domains?: string[],
      exclude_domains?: string[],
      after_date?: string | null
    } | null,
    advanced_settings?: {
      location?: string | null,
      fetch_policy?: {
        max_age_seconds?: number | null,
        timeout_seconds?: number | null,
        disable_cache_fallback?: boolean
      } | null,
      data_sources?: {
        pay_per_use?: string[],
        free?: string[],
        excluded?: string[]
      } | null
    } | null,
    task_spec?: {
      output_schema: string | {
        json_schema: Record<string, JsonValue>,
        type?: json
      } | {
        type: auto
      } | {
        type?: text,
        description?: string | null
      },
      input_schema?: string | {
        json_schema: Record<string, JsonValue>,
        type?: json
      } | {
        type: auto
      } | {
        type?: text,
        description?: string | null
      } | null
    } | null,
    previous_interaction_id?: string | null,
    mcp_servers?: {
      type?: url,
      url: string,
      name: string,
      headers?: Record<string, string> | null,
      allowed_tools?: string[] | null
    }[] | null,
    enable_events?: boolean | null,
    webhook?: {
      url: string,
      event_types?: task_run.status[]
    } | null
  }[]
}

Output

Name	Type	Required	Description
`status`	`object`	Yes	—
`run_ids`	`string[]`	Yes	—
`run_cursor`	`string \| null`	Yes	—
`event_cursor`	`string \| null`	Yes	—

status full type

{
  num_task_runs: number,
  task_run_status_counts: Record<string, number>,
  is_active: boolean,
  status_message: string | null,
  modified_at: string | null
}

createGroup

tasks.createGroup Create a task group Risk: write

await corsair.parallel.api.tasks.createGroup({});

Input

Name	Type	Required	Description
`metadata`	`Record<string, string \| number \| boolean> \| null`	No	—

Output

Name	Type	Required	Description
`taskgroup_id`	`string`	Yes	—
`status`	`object`	Yes	—
`created_at`	`string \| null`	Yes	—
`metadata`	`Record<string, string \| number \| boolean> \| null`	No	—

status full type

{
  num_task_runs: number,
  task_run_status_counts: Record<string, number>,
  is_active: boolean,
  status_message: string | null,
  modified_at: string | null
}

createRun

tasks.createRun Create a task run Risk: destructive

await corsair.parallel.api.tasks.createRun({});

Input

Name	Type	Required	Description
`body`	`object`	Yes	—
`parallel_beta`	`string`	No	—

body full type

{
  processor: string,
  input: string | Record<string, JsonValue>,
  metadata?: Record<string, string | number | boolean> | null,
  memory_scope_key?: string | null,
  source_policy?: {
    include_domains?: string[],
    exclude_domains?: string[],
    after_date?: string | null
  } | null,
  advanced_settings?: {
    location?: string | null,
    fetch_policy?: {
      max_age_seconds?: number | null,
      timeout_seconds?: number | null,
      disable_cache_fallback?: boolean
    } | null,
    data_sources?: {
      pay_per_use?: string[],
      free?: string[],
      excluded?: string[]
    } | null
  } | null,
  task_spec?: {
    output_schema: string | {
      json_schema: Record<string, JsonValue>,
      type?: json
    } | {
      type: auto
    } | {
      type?: text,
      description?: string | null
    },
    input_schema?: string | {
      json_schema: Record<string, JsonValue>,
      type?: json
    } | {
      type: auto
    } | {
      type?: text,
      description?: string | null
    } | null
  } | null,
  previous_interaction_id?: string | null,
  mcp_servers?: {
    type?: url,
    url: string,
    name: string,
    headers?: Record<string, string> | null,
    allowed_tools?: string[] | null
  }[] | null,
  enable_events?: boolean | null,
  webhook?: {
    url: string,
    event_types?: task_run.status[]
  } | null
}

Output

Name	Type	Required	Description
`run_id`	`string`	Yes	—
`interaction_id`	`string`	Yes	—
`status`	`queued \| action_required \| running \| completed \| failed \| cancelling \| cancelled \| string`	Yes	—
`is_active`	`boolean`	Yes	—
`processor`	`string`	Yes	—
`created_at`	`string \| null`	Yes	—
`modified_at`	`string \| null`	Yes	—
`warnings`	`object[] \| null`	No	—
`error`	`object \| null`	No	—
`metadata`	`Record<string, string \| number \| boolean> \| null`	No	—
`taskgroup_id`	`string \| null`	No	—

warnings full type

{
  type: string,
  message: string,
  detail?: Record<string, any> | null
}[] | null

error full type

{
  ref_id: string,
  message: string,
  detail?: Record<string, JsonValue> | null
} | null

getGroup

tasks.getGroup Get a task group Risk: read

await corsair.parallel.api.tasks.getGroup({});

Input

Name	Type	Required	Description
`taskgroup_id`	`string`	Yes	—

Output

Name	Type	Required	Description
`taskgroup_id`	`string`	Yes	—
`status`	`object`	Yes	—
`created_at`	`string \| null`	Yes	—
`metadata`	`Record<string, string \| number \| boolean> \| null`	No	—

status full type

{
  num_task_runs: number,
  task_run_status_counts: Record<string, number>,
  is_active: boolean,
  status_message: string | null,
  modified_at: string | null
}

getGroupRun

tasks.getGroupRun Get a run in a task group Risk: read

await corsair.parallel.api.tasks.getGroupRun({});

Input

Name	Type	Required	Description
`taskgroup_id`	`string`	Yes	—
`run_id`	`string`	Yes	—

Output

Name	Type	Required	Description
`run_id`	`string`	Yes	—
`interaction_id`	`string`	Yes	—
`status`	`queued \| action_required \| running \| completed \| failed \| cancelling \| cancelled \| string`	Yes	—
`is_active`	`boolean`	Yes	—
`processor`	`string`	Yes	—
`created_at`	`string \| null`	Yes	—
`modified_at`	`string \| null`	Yes	—
`warnings`	`object[] \| null`	No	—
`error`	`object \| null`	No	—
`metadata`	`Record<string, string \| number \| boolean> \| null`	No	—
`taskgroup_id`	`string \| null`	No	—

warnings full type

{
  type: string,
  message: string,
  detail?: Record<string, any> | null
}[] | null

error full type

{
  ref_id: string,
  message: string,
  detail?: Record<string, JsonValue> | null
} | null

getResult

tasks.getResult Get task run result Risk: read

await corsair.parallel.api.tasks.getResult({});

Input

Name	Type	Required	Description
`run_id`	`string`	Yes	—
`timeout`	`number`	No	—
`parallel_beta`	`string`	No	—

Output

Name	Type	Required	Description
`run`	`object`	Yes	—
`output`	`object`	Yes	—

run full type

{
  run_id: string,
  interaction_id: string,
  status: queued | action_required | running | completed | failed | cancelling | cancelled | string,
  is_active: boolean,
  processor: string,
  created_at: string | null,
  modified_at: string | null,
  warnings?: {
    type: string,
    message: string,
    detail?: Record<string, any> | null
  }[] | null,
  error?: {
    ref_id: string,
    message: string,
    detail?: Record<string, JsonValue> | null
  } | null,
  metadata?: Record<string, string | number | boolean> | null,
  taskgroup_id?: string | null
}

output full type

{
  type: text,
  basis: {
    field: string,
    reasoning: string,
    confidence?: string | null,
    citations?: {
      url: string,
      title?: string | null,
      excerpts?: string[] | null
    }[]
  }[],
  content: string,
  mcp_tool_calls?: JsonValue[] | null
} | {
  type: json,
  basis: {
    field: string,
    reasoning: string,
    confidence?: string | null,
    citations?: {
      url: string,
      title?: string | null,
      excerpts?: string[] | null
    }[]
  }[],
  content: Record<string, JsonValue>,
  output_schema?: Record<string, JsonValue> | null,
  mcp_tool_calls?: JsonValue[] | null
}

getRun

tasks.getRun Get a task run Risk: read

await corsair.parallel.api.tasks.getRun({});

Input

Name	Type	Required	Description
`run_id`	`string`	Yes	—

Output

Name	Type	Required	Description
`run_id`	`string`	Yes	—
`interaction_id`	`string`	Yes	—
`status`	`queued \| action_required \| running \| completed \| failed \| cancelling \| cancelled \| string`	Yes	—
`is_active`	`boolean`	Yes	—
`processor`	`string`	Yes	—
`created_at`	`string \| null`	Yes	—
`modified_at`	`string \| null`	Yes	—
`warnings`	`object[] \| null`	No	—
`error`	`object \| null`	No	—
`metadata`	`Record<string, string \| number \| boolean> \| null`	No	—
`taskgroup_id`	`string \| null`	No	—

warnings full type

{
  type: string,
  message: string,
  detail?: Record<string, any> | null
}[] | null

error full type

{
  ref_id: string,
  message: string,
  detail?: Record<string, JsonValue> | null
} | null

getRunInput

tasks.getRunInput Get task run input Risk: read

await corsair.parallel.api.tasks.getRunInput({});

Input

Name	Type	Required	Description
`run_id`	`string`	Yes	—

Output

Name	Type	Required	Description
`processor`	`string`	Yes	—
`input`	`string \| Record<string, JsonValue>`	Yes	—
`metadata`	`Record<string, string \| number \| boolean> \| null`	No	—
`memory_scope_key`	`string \| null`	No	—
`source_policy`	`object \| null`	No	—
`advanced_settings`	`object \| null`	No	—
`task_spec`	`object \| null`	No	—
`previous_interaction_id`	`string \| null`	No	—
`mcp_servers`	`object[] \| null`	No	—
`enable_events`	`boolean \| null`	No	—
`webhook`	`object \| null`	No	—

source_policy full type

{
  include_domains?: string[],
  exclude_domains?: string[],
  after_date?: string | null
} | null

advanced_settings full type

{
  location?: string | null,
  fetch_policy?: {
    max_age_seconds?: number | null,
    timeout_seconds?: number | null,
    disable_cache_fallback?: boolean
  } | null,
  data_sources?: {
    pay_per_use?: string[],
    free?: string[],
    excluded?: string[]
  } | null
} | null

task_spec full type

{
  output_schema: string | {
    json_schema: Record<string, JsonValue>,
    type?: json
  } | {
    type: auto
  } | {
    type?: text,
    description?: string | null
  },
  input_schema?: string | {
    json_schema: Record<string, JsonValue>,
    type?: json
  } | {
    type: auto
  } | {
    type?: text,
    description?: string | null
  } | null
} | null

mcp_servers full type

{
  type?: url,
  url: string,
  name: string,
  headers?: Record<string, string> | null,
  allowed_tools?: string[] | null
}[] | null

webhook full type

{
  url: string,
  event_types?: task_run.status[]
} | null