Free Beta Live

ChatGPT Web
API Platform

Scale your automation with private web workers. Execute native browser instances, retain ChatGPT login sessions, and query them via structured API endpoints.

Get Started Free Read API Docs

Responses

Style API Contract

Stateful

Persistent Profiles

Trusted

Computer Routing

API Sandbox

curl -X POST "http://localhost:8080/v1/chat/completions" \
  -H "Authorization: Bearer cgpt_beta_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": "List 3 top features of ChatGPT Web API"
      }
    ]
  }'

curl -X POST "http://localhost:8080/v1/messages" \
  -H "Authorization: Bearer cgpt_beta_key" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Find latest tech news on Google",
    "searchWeb": true
  }'

curl -X POST "http://localhost:8080/v1/chat/completions" \
  -H "Authorization: Bearer cgpt_beta_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      {"role": "user", "content": "Extract name and age from: John is 30"}
    ],
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "person",
        "strict": true,
        "schema": {
          "type": "object",
          "properties": {
            "name": {"type": "string"},
            "age": {"type": "integer"}
          },
          "required": ["name", "age"]
        }
      }
    }
  }'

Ready to invoke sandbox request

Architected for Resiliency

State-of-the-Art Core Features

Unlike basic wrappers, our architecture deploys fully isolated worker pipelines to ensure maximum reliability and throughput.

Isolated Worker Profiles

Each ChatGPT account maps to its own persistent browser profile, queue, login state, and continuation history.

Trusted Computer Companion

Keeps the visible browser and persistent profile on the user's normal network while the cloud manager relays approved operations over outbound WSS.

Structured Output Validation

Leverage response schema structures. Ensure downstream JSON strings matches exact validation rules strictly.

Web Search Automation

Perform real-time searches via ChatGPT Web search. Scrape live data dynamically before responding.

OpenAI SDK Compatibility

Standardized API shapes make it fully compatible with existing libraries like LangChain and LiteLLM.

Robust Session Recovery

Failsafe worker recovery handles Cloudflare challenges, worker restarts, and token rotations transparently.

Interactive Pipeline

How Request Routing Works

Click each step to visualize the backend workflow and traffic routes.

Client Application

Triggers standard completion API request

API Gateway & Manager

Authenticates the key and selects the paired worker transport

Persistent Browser Worker

A visible Chromium profile runs on the selected trusted transport

JSON Validator & Result

Parses result, verifies schema, returns payload

[01] Endpoint Request Ingest

The consumer client requests `/v1/chat/completions` with authorization headers and structural parameters. Gateway validates format instantly.

[02] Manager Lifecycle Dispatch

The manager authenticates the tenant, restores encrypted continuation state, and dispatches only to that tenant's selected worker transport.

[03] Trusted Browser Execution

The paired companion or configured server worker uses an isolated, persistent Chromium profile. Login challenges remain visible and manual.

[04] Structured Extraction & Response

The target text is extracted from ChatGPT Web interface, fed to the internal JSON Schema parser, verified against constraints, and returned to client.

Transport Simulation

Worker Status at a Glance

These examples show how trusted-computer, shared-cloud, and legacy Docker transports are reported.

Worker Transport Examples Illustration

trusted-computer

Outbound WSS | Companion connected

HEALTHY

shared-cloud

Shared worker | VPN inactive

READY

docker-vpn

Legacy optional transport | Stopped

STOPPED

Back

Login to your API workspace

Manage the worker, complete ChatGPT login steps only when needed, and test message requests before using the API key in production.

No account yet? Create one.

Back

Create your free SaaS account

The portal password protects this dashboard. Your ChatGPT login is encrypted at rest and is only unlocked for your authenticated requests.

Already registered? Login.

Worker stopped

Email -

Transport -

VPN -

ChatGPT unknown

Workspace

Start the worker to read ChatGPT login status.

API key

Use this from backend jobs or integrations. Full keys are shown only when generated.

No API key

Open docs

Send a test message

Flow status

If the worker is stopped, the manager starts it before sending. If ChatGPT asks for login, go to Manage worker and complete the website prompt.

ChatGPT login unknown

Start the worker to read ChatGPT login status.

Current step Idle

Latest response No response yet

No response yet.

Trusted computer companion

Recommended

Runs the visible, persistent browser on your own computer and normal network. The companion connects outward over encrypted WebSocket; no browser port or DevTools endpoint is exposed.

Connection Not paired

Run this in PowerShell from this project folder. The token is shown once.

Pair this account, start the companion, then choose Start worker and Health check. CAPTCHA, OTP, and unusual account checks remain manual in the visible browser window.

Manage worker

Start the selected browser transport and complete the ChatGPT website login flow when needed.

Worker details

Status: -
Transport: -
Idle timeout: -

Manage account

ChatGPT account

Credentials stay encrypted. OTP, CAPTCHA, and unusual login checks always require your confirmation.

Enable memory has not been checked.

Legacy Docker VPN credentials

These credentials are only active when this installation uses a per-user Docker + VPN worker. They are not used by the shared cloud worker or trusted computer companion.

API docs

Integrate your private worker into external apps and services using standard JSON HTTP calls. The API will automatically wake up and start your worker runtime when an API key request arrives.

Base URLhttp://localhost:8080

AuthenticationBearer API Key

LimitsNo artificial rate limit

POST /v1/responses

Create a response

Primary OpenAI-compatible interface. Supports string or item input, instructions, function tools, web search, structured text, SSE streaming, stored history, previous_response_id, anonymous mode, and idempotency keys.

curl -X POST http://localhost:8080/v1/responses \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"chatgpt-web","input":"Say hello"}'

If ChatGPT Enable memory is on, every response includes a warning and an OpenAI-Warning header. Turn it off with POST /v1/account/personalization/disable; custom instructions and profile fields are preserved.

GET /v1/account

Retrieve account

Returns the portal profile, selected worker transport, companion connection state, and whether saved VPN credentials are actually active.

Headers

Authorization Bearer <YOUR_API_KEY> (Required)

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "http://localhost:8080/v1/account"

const response = await fetch(
  "http://localhost:8080/v1/account",
  {
    headers: {
      "Authorization": "Bearer YOUR_API_KEY"
    }
  }
);
const data = await response.json();
console.log(data);

import requests

url = "http://localhost:8080/v1/account"
headers = {"Authorization": "Bearer YOUR_API_KEY"}

res = requests.get(url, headers=headers)
print(res.json())

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "http://localhost:8080/v1/account"
	req, _ := http.NewRequest("GET", url, nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

Response (200 OK)

{
  "user": {
    "id": "uuid-here",
    "name": "John Doe",
    "email": "john@example.com",
    "age": 28,
    "workerMode": "companion",
    "containerStatus": "running",
    "companionConnected": true,
    "vpnCredentialsSaved": false,
    "vpnEffective": false,
    "hasApiKey": true,
    "apiKeyPreview": "cgpt_..."
  }
}

POST /v1/messages

Send message

Sends a message to ChatGPT and streams the full response back. Reuses existing pages to keep the session alive.

JSON Body Parameters

Parameter	Type	Req	Description
message	string	Yes	The message text prompt.
id	string	No	Active conversation UUID to continue.
searchWeb	boolean	No	Set true to enable ChatGPT Search.

curl -X POST "http://localhost:8080/v1/messages" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message":"Write a short summary","id":"your-conversation-id","searchWeb":true}'

const response = await fetch(
  "http://localhost:8080/v1/messages",
  {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      message: "Write a short summary",
      id: "your-conversation-id",
      searchWeb: true
    })
  }
);
const data = await response.json();
console.log(data);

import requests

url = "http://localhost:8080/v1/messages"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "message": "Write a short summary",
    "id": "your-conversation-id",
    "searchWeb": True
}

res = requests.post(url, headers=headers, json=payload)
print(res.json())

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
)

func main() {
	payload := []byte(`{"message":"Write a short summary","id":"your-conversation-id","searchWeb":true}`)
	url := "http://localhost:8080/v1/messages"
	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

Response (200 OK)

{
  "message": "Write a short summary",
  "response": "Here is a brief summary of...",
  "id": "uuid-chat-thread",
  "status": {
    "mode": "logged-in",
    "email": "user@example.com",
    "loggedIn": true,
    "searchWeb": true,
    "url": "https://chatgpt.com/c/uuid-chat-thread"
  }
}

POST /v1/chat/completions

OpenAI compatible completion

OpenAI SDK compatible endpoint. Drop this URL and your API key directly into your existing LangChain, LiteLLM, or OpenAI client libraries.

JSON Body Parameters

Parameter	Type	Req	Description
messages	array	Yes	Standard message array containing the user prompt.
id	string	No	Active conversation UUID.
searchWeb	boolean	No	Enable ChatGPT web search.
response_format	object	No	Instructs ChatGPT to return structured outputs. Supports `json_object` and strict `json_schema`.

curl -X POST "http://localhost:8080/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Get capital info"}],"response_format":{"type":"json_schema","json_schema":{"name":"capital_info","strict":true,"schema":{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}}}}'

const response = await fetch(
  "http://localhost:8080/v1/chat/completions",
  {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      messages: [{ role: "user", content: "Get capital info" }],
      response_format: {
        type: "json_schema",
        json_schema: {
          name: "capital_info",
          strict: true,
          schema: {
            type: "object",
            properties: { name: { type: "string" } },
            required: ["name"]
          }
        }
      }
    })
  }
);
const data = await response.json();
console.log(data);

import requests

url = "http://localhost:8080/v1/chat/completions"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "messages": [{"role": "user", "content": "Get capital info"}],
    "response_format": {
        "type": "json_schema",
        "json_schema": {
            "name": "capital_info",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"name": {"type": "string"}},
                "required": ["name"]
            }
        }
    }
}

res = requests.post(url, headers=headers, json=payload)
print(res.json())

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
)

func main() {
	payload := []byte(`{"messages":[{"role":"user","content":"Get capital info"}],"response_format":{"type":"json_schema","json_schema":{"name":"capital_info","strict":true,"schema":{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}}}}`)
	url := "http://localhost:8080/v1/chat/completions"
	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

Response (200 OK)

{
  "id": "chat-thread-uuid",
  "object": "chat.completion",
  "created": 1716528000,
  "model": "chatgpt-web",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "This is a one-line assistant reply."
      },
      "finish_reason": "stop"
    }
  ]
}

Error Handling Reference

The developer API uses standard HTTP response codes to denote success or failure states:

Status	Message Type	Typical Reason & Remediation
400 Bad Request	Missing parameters	No prompt was passed in the `message` body or `messages` list is empty. Verify request payload layout.
401 Unauthorized	Invalid authorization	API key is invalid, missing, or has been regenerated. Ensure header is formatted as `Authorization: Bearer YOUR_API_KEY`.
502 Bad Gateway	Worker unreachable	The selected worker returned an upstream error. Check the worker health and browser state in Manage worker.
503 Unavailable	Trusted computer offline	A paired companion is not connected. Start it on the trusted computer; the manager will not fall back to another network.
500 Internal Error	Browser/Puppeteer failure	Puppeteer failed to interact with ChatGPT within the timeout limit (e.g. Cloudflare blockage or network failure). Check the worker logs.

ChatGPT Web API Platform

Architected for Resiliency

State-of-the-Art Core Features

Isolated Worker Profiles

Trusted Computer Companion

Structured Output Validation

Web Search Automation

OpenAI SDK Compatibility

Robust Session Recovery

Interactive Pipeline

How Request Routing Works

[01] Endpoint Request Ingest

[02] Manager Lifecycle Dispatch

[03] Trusted Browser Execution

[04] Structured Extraction & Response

Transport Simulation

Worker Status at a Glance

Login to your API workspace

Create your free SaaS account

Workspace

API key

Send a test message

Flow status

Trusted computer companion

Manage worker

Worker details

Manage account

ChatGPT account

Legacy Docker VPN credentials

API docs

Create a response

Retrieve account

Headers

Send message

JSON Body Parameters

OpenAI compatible completion

JSON Body Parameters

Error Handling Reference

ChatGPT login

ChatGPT Web
API Platform