OpenAI Compatibility (Beta)

With a few code changes, you can use the OpenAI SDK to test the Task API. Parallel provides a compatibility layer that lets you quickly evaluate Parallel processors’ capabilities with minimal effort.

One important thing to note is that we only offer a single Speed processor, which is designed for interactive workflows where latency is paramount. For the best quality outputs, use the Task API.

Before You Begin

This compatibility is in beta and only offers the Speed processor. We provide a rate limit of 30 requests per minute for Speed out of the box. Contact us for production capacity.

For the best experience and access to Parallel’s best processors, we recommend using the Parallel Task API.

Getting Started with the OpenAI SDK

To use the OpenAI SDK compatibility feature, you’ll need to:

Use an official OpenAI SDK
Make these changes:
- Update your base URL to point to Parallel’s beta API endpoint
- Replace your API key with a Parallel API key
- Update your model name to “speed”
Review the documentation below for supported features

Performance and Rate Limits

Speed is optimized for interactive applications requiring low latency responses:

Performance: With stream=true, achieves 3 second p50 TTFT (median time to first token)
Default Rate Limit: 30 requests per minute
Use Cases: Chat interfaces, interactive tools

For production deployments requiring consistent performance at scale (reliable p99 latency) or higher throughput, contact our team.

Quick Start Examples

from openai import OpenAI

client = OpenAI(
    api_key="PARALLEL_API_KEY",  # Your Parallel API key
    base_url="https://beta.parallel.ai"  # Parallel's API beta endpoint
)

response = client.chat.completions.create(
    model="speed", # Parallel model name
    messages=[
        {"role": "user", "content": "What does Parallel Web Systems do?"}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "reasoning_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "reasoning": {
                        "type": "string",
                        "description": "Think step by step to arrive at the answer",
                    },
                    "answer": {
                        "type": "string",
                        "description": "The direct answer to the question",
                    },
                    "citations": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "Sources cited to support the answer",
                    },
                },
            },
        },
    },
)

print(response.choices[0].message.content)

from openai import OpenAI

client = OpenAI(
    api_key="PARALLEL_API_KEY",  # Your Parallel API key
    base_url="https://beta.parallel.ai"  # Parallel's API beta endpoint
)

response = client.chat.completions.create(
    model="speed", # Parallel model name
    messages=[
        {"role": "user", "content": "What does Parallel Web Systems do?"}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "reasoning_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "reasoning": {
                        "type": "string",
                        "description": "Think step by step to arrive at the answer",
                    },
                    "answer": {
                        "type": "string",
                        "description": "The direct answer to the question",
                    },
                    "citations": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "Sources cited to support the answer",
                    },
                },
            },
        },
    },
)

print(response.choices[0].message.content)

from openai import OpenAI

client = OpenAI(
    api_key="PARALLEL_API_KEY",  # Your Parallel API key
    base_url="https://beta.parallel.ai"  # Parallel's API beta endpoint
)

stream = client.chat.completions.create(
    model="speed", # Parallel model name
    messages=[
        {"role": "user", "content": "What does Parallel Web Systems do?"}
    ],
    stream=True,
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "reasoning_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "reasoning": {
                        "type": "string",
                        "description": "Think step by step to arrive at the answer",
                    },
                    "answer": {
                        "type": "string",
                        "description": "The direct answer to the question",
                    },
                    "citations": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "Sources cited to support the answer",
                    },
                },
            },
        },
    },
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="")

print()

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'PARALLEL_API_KEY', // Your Parallel API key
  baseURL: 'https://beta.parallel.ai', // Parallel's API beta endpoint
});

async function main() {
  const response = await client.chat.completions.create({
    model: 'speed', // Parallel model name
    messages: [
      { role: 'user', content: 'What does Parallel Web Systems do?' }
    ],
    response_format: {
      type: 'json_schema',
      json_schema: {
        name: 'reasoning_schema',
        schema: {
          type: 'object',
          properties: {
            reasoning: {
              type: 'string',
              description: 'Think step by step to arrive at the answer',
            },
            answer: {
              type: 'string',
              description: 'The direct answer to the question',
            },
            citations: {
              type: 'array',
              items: { type: 'string' },
              description: 'Sources cited to support the answer',
            },
          },
        },
      },
    },
  });

  console.log(response.choices[0].message.content);
}

main();

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'PARALLEL_API_KEY', // Your Parallel API key
  baseURL: 'https://beta.parallel.ai', // Parallel's API beta endpoint
});

async function main() {
  const stream = await client.chat.completions.create({
    model: 'speed', // Parallel model name
    messages: [
      { role: 'user', content: 'What does Parallel Web Systems do?' }
    ],
    stream: true,
    response_format: {
      type: 'json_schema',
      json_schema: {
        name: 'reasoning_schema',
        schema: {
          type: 'object',
          properties: {
            reasoning: {
              type: 'string',
              description: 'Think step by step to arrive at the answer',
            },
            answer: {
              type: 'string',
              description: 'The direct answer to the question',
            },
            citations: {
              type: 'array',
              items: { type: 'string' },
              description: 'Sources cited to support the answer',
            },
          },
        },
      },
    },
  });

  for await (const chunk of stream) {
    process.stdout.write(chunk.choices[0]?.delta?.content || '');
  }
  process.stdout.write('\\n');
}

main();

Important OpenAI Compatibility Limitations

API Behavior

Here are the most substantial differences from using OpenAI:

Multimodal input (images/audio) is not supported and will be ignored.
Prompt caching is not supported.
Most unsupported fields are silently ignored rather than producing errors. These are all documented below.

Detailed OpenAI Compatible API Support

Request Fields

Simple Fields

Field	Support Status
model	Use “speed”
response_format	Fully supported
stream	Fully supported
max_tokens	Ignored
max_completion_tokens	Ignored
stream_options	Ignored
top_p	Ignored
parallel_tool_calls	Ignored
stop	Ignored
temperature	Ignored
n	Ignored
logprobs	Ignored
metadata	Ignored
prediction	Ignored
presence_penalty	Ignored
frequency_penalty	Ignored
seed	Ignored
service_tier	Ignored
audio	Ignored
logit_bias	Ignored
store	Ignored
user	Ignored
modalities	Ignored
top_logprobs	Ignored
reasoning_effort	Ignored

Tools / Functions Fields

Tools are ignored.

Messages Array Fields

Field	Support Status
messages[].role	Fully supported
messages[].content	Fully supported
messages[].name	Fully supported
messages[].tool_calls	Ignored
messages[].tool_call_id	Ignored
messages[].function_call	Ignored
messages[].audio	Ignored
messages[].modalities	Ignored

Response Fields

Field	Support Status
id	Always empty
choices[]	Will always have a length of 1
choices[].finish_reason	Always empty
choices[].index	Fully supported
choices[].message.role	Fully supported
choices[].message.content	Fully supported
choices[].message.tool_calls	Always empty
object	Always empty
created	Fully supported
model	Fully supported
finish_reason	Always empty
content	Fully supported
usage.completion_tokens	Always empty
usage.prompt_tokens	Always empty
usage.total_tokens	Always empty
usage.completion_tokens_details	Always empty
usage.prompt_tokens_details	Always empty
choices[].message.refusal	Always empty
choices[].message.audio	Always empty
logprobs	Always empty
service_tier	Always empty
system_fingerprint	Always empty

Error Message Compatibility

The compatibility layer maintains approximately the same error formats as the OpenAI API.

Header Compatibility

While the OpenAI SDK automatically manages headers, here is the complete list of headers supported by Parallel’s API for developers who need to work with them directly.

Field	Support Status
authorization	Fully supported
x-ratelimit-limit-requests	Ignored
x-ratelimit-limit-tokens	Ignored
x-ratelimit-remaining-requests	Ignored
x-ratelimit-remaining-tokens	Ignored
x-ratelimit-reset-requests	Ignored
x-ratelimit-reset-tokens	Ignored
retry-after	Ignored
x-request-id	Ignored
openai-version	Ignored
openai-processing-ms	Ignored

Introduction

Core Concepts

Resources

OpenAI Compatibility (Beta)

Before You Begin

Getting Started with the OpenAI SDK

Performance and Rate Limits

Quick Start Examples

Important OpenAI Compatibility Limitations

API Behavior

Detailed OpenAI Compatible API Support

Request Fields

Simple Fields

Tools / Functions Fields

Messages Array Fields

Response Fields

Error Message Compatibility

Header Compatibility

Introduction

Core Concepts

Resources

​Before You Begin

​Getting Started with the OpenAI SDK

​Performance and Rate Limits

​Quick Start Examples

​Important OpenAI Compatibility Limitations

​API Behavior

​Detailed OpenAI Compatible API Support

​Request Fields

​Simple Fields

​Tools / Functions Fields

​Messages Array Fields

​Response Fields

​Error Message Compatibility

​Header Compatibility

Before You Begin

Getting Started with the OpenAI SDK

Performance and Rate Limits

Quick Start Examples

Important OpenAI Compatibility Limitations

API Behavior

Detailed OpenAI Compatible API Support

Request Fields

Simple Fields

Tools / Functions Fields

Messages Array Fields

Response Fields

Error Message Compatibility

Header Compatibility