Skip to content
Back to search

ChatGPT-Web2API

OpenAI-compatible API proxy for ChatGPT web — expose ChatGPT as an MCP server, REST API, and OpenAI SDK endpoint via CDP-driven browser automation

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Octo-Lex/ChatGPT-Web2API with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Octo-Lex/ChatGPT-Web2API'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/octo-lex--chatgpt-web2api/badge.svg)](/listings/octo-lex--chatgpt-web2api)

HTML

<a href="/listings/octo-lex--chatgpt-web2api"><img src="/api/listings/octo-lex--chatgpt-web2api/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

pip install chatgpt-web2api

# Start — opens Chrome, waits for login on first run
chatgpt-web2api

# Then use it:
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"auto","messages":[{"role":"user","content":"What is 2+2?"}]}'
# → {"choices":[{"message":{"content":"4"}}]}

That's it. **One install, one command, one endpoint.**

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 565 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ![Project Banner](https://github.com/Elephant-Rock-Lab/ChatGPT-Web2API/blob/6c825632520652e20adbabf9dde55d37b7e1cfa0/Banner.png)
  2. <div align="center">
  3. # ChatGPT-Web2API
  4. **Turn ChatGPT into an API. No API key. No token extraction. No sentinel solving.**
  5. One command starts a Chrome browser, logs into ChatGPT, and exposes an OpenAI-compatible API + MCP server.
  6. [![CI](https://github.com/Elephant-Rock-Lab/ChatGPT-Web2API/actions/workflows/ci.yml/badge.svg)](https://github.com/Elephant-Rock-Lab/ChatGPT-Web2API/actions/workflows/ci.yml)
  7. [![Release](https://img.shields.io/github/v/release/Elephant-Rock-Lab/ChatGPT-Web2API)](https://github.com/Elephant-Rock-Lab/ChatGPT-Web2API/releases)
  8. [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
  9. [![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/downloads/)
  10. [![Tests](https://img.shields.io/badge/tests-29%20passing-brightgreen)](https://github.com/Elephant-Rock-Lab/ChatGPT-Web2API/actions)
  11. </div>
  12. ---
  13. ## Why This Exists
  14. You have a **ChatGPT Plus subscription** but want to use it programmatically:
  15. - **Build AI agents** that chat with ChatGPT via MCP (Model Context Protocol)
  16. - **Use the OpenAI Python SDK** against your ChatGPT account — no separate API key
  17. - **Access ChatGPT Projects** for persistent memory and custom instructions
  18. - **Manage memories, conversations, and projects** from code
  19. Other reverse proxies require token extraction, sentinel challenge solving, or cookie management. This one **drives a real Chrome browser** — anti-bot challenges (Turnstile, PoW) are handled automatically.
  20. ## Demo
  21. ```bash
  22. $ pip install chatgpt-web2api
  23. $ chatgpt-web2api
  24. ✓ Chrome launched on port 9222
  25. ✓ Navigating to chatgpt.com...
  26. ✓ Ready on http://localhost:8080
  27. $ curl -s http://localhost:8080/v1/chat/completions \
  28. -H "Content-Type: application/json" \
  29. -d '{"model":"auto","messages":[{"role":"user","content":"What is 8+7?"}]}'
  30. {"choices":[{"message":{"content":"8 + 7 = 15"},"finish_reason":"stop"}]}
  31. ```
  32. ```python
  33. # OpenAI Python SDK — drop-in replacement
  34. from openai import OpenAI
  35. client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed")
  36. print(client.chat.completions.create(
  37. model="auto",
  38. messages=[{"role": "user", "content": "What is 8+7?"}]
  39. ).choices[0].message.content)
  40. # → "8 + 7 = 15"
  41. ```
  42. ## How It Works
  43. ```
  44. ┌──────────────┐ OpenAI API ┌──────────────┐ CDP ┌──────────────┐
  45. │ Your code │ ──────────────► │ API Server │ ────────► │ Chrome │
  46. │ SDK / curl │ ◄────────────── │ or MCP │ ◄──────── │ chatgpt.com │
  47. │ MCP client │ JSON / SSE │ Server │ events │ (logged in) │
  48. └──────────────┘ └──────────────┘ └──────────────┘
  49. ```
  50. The proxy types messages, clicks send, and reads responses — exactly like a human. The browser handles all anti-bot challenges transparently.
  51. ## Quick Start
  52. ```bash
  53. pip install chatgpt-web2api
  54. # Start — opens Chrome, waits for login on first run
  55. chatgpt-web2api
  56. # Then use it:
  57. curl http://localhost:8080/v1/chat/completions \
  58. -H "Content-Type: application/json" \
  59. -d '{"model":"auto","messages":[{"role":"user","content":"What is 2+2?"}]}'
  60. # → {"choices":[{"message":{"content":"4"}}]}
  61. ```
  62. That's it. **One install, one command, one endpoint.**
  63. ## What You Get
  64. ### 🌐 OpenAI-Compatible REST API
  65. Drop-in replacement for `api.openai.com`:
  66. ```python
  67. from openai import OpenAI
  68. client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed")
  69. response = client.chat.completions.create(
  70. model="auto",
  71. messages=[{"role": "user", "content": "Hello!"}],
  72. stream=True,
  73. )
  74. for chunk in response:
  75. print(chunk.choices[0].delta.content or "", end="")
  76. ```
  77. ### ⏱️ Rate Limits & Agent Retry
  78. ChatGPT occasionally shows a "Too many requests" pop-up when conversations are
  79. accessed rapidly. ChatGPT-Web2API turns this from a silent failure into a
  80. **practical, agent-friendly signal** — so autonomous workflows back off and
  81. recover instead of breaking.
  82. **Transparent by default.** When the pop-up appears, the server dismisses it
  83. (clicks "Got it") and retries your request with exponential backoff — up to
  84. 3 attempts. A *transient* limit is invisible: your agent gets a normal
  85. successful response and never knows it happened.
  86. **A clean pause signal when it persists.** If the limit survives all retries,
  87. the server surfaces a **standard OpenAI `429`** that every major agent framework
  88. already knows how to handle — with **zero client-side integration**:
  89. ```http
  90. HTTP/1.1 429 Too Many Requests
  91. Retry-After: 60
  92. {"error": {"type": "rate_limit_exceeded", "code": "rate_limit_exceeded", ...}}
  93. ```
  94. The OpenAI SDK, LangChain, LlamaIndex, and similar frameworks auto-retry on
  95. `429` + `Retry-After` by default. The wait (`Retry-After`) is parsed from the
  96. pop-up text when ChatGPT gives an exact number, otherwise a conservative 60s.
  97. **MCP clients** (Claude Desktop, Cursor) get the same signal semantically: a
  98. `CallToolResult` with `isError=True` and a machine-readable `structuredContent`
  99. payload an agent can read to decide "pause, then retry this tool":
  100. ```json
  101. {"rate_limited": true, "retry_after": 60, "error": "rate_limit_exceeded"}
  102. ```
  103. > **Streaming caveat:** a 429 can be sent *before* streaming begins (a pre-flight
  104. > check), but a limit that appears *mid-stream* (after the 200 is committed) is
  105. > surfaced as an inline `[Error: rate_limit_exceeded — retry in Ns]` chunk,
  106. > since the HTTP status can no longer change. Non-streaming requests are
  107. > unaffected.
  108. ### 🩺 Troubleshooting API/UI Drift
  109. ChatGPT changes its web API over time, which can silently break driver functions
  110. (the unit-test mocks can't detect this). ChatGPT-Web2API ships a **reactive
  111. diagnostic** that captures evidence at the moment a function breaks, plus a
  112. `doctor` command that auto-discovers the breakage and prints the evidence for
  113. fast repair.
  114. **Enable capture** (off by default) so breakage in the wild is recorded:
  115. ```bash
  116. W2A_DIAGNOSE=1 chatgpt-web2api start
  117. ```
  118. When a function returns a broken shape, a redacted artifact is written to
  119. `~/.chatgpt-web2api/diagnostics/<function>-<timestamp>-<seq>.json` with the
  120. exact request, live response, expected-vs-actual mismatch (secrets stripped).
  121. **Auto-discover + diagnose:**
  122. ```bash
  123. chatgpt-web2api doctor # which functions have captured breakage?
  124. chatgpt-web2api doctor create_project# print the captured evidence for one
  125. chatgpt-web2api doctor --verify get_models # re-run a read function live to test a fix
  126. ```
  127. `doctor` (no args) **auto-discovers** which functions are broken — no human
  128. needs to name them. It then prints the evidence an AI coding agent (or you)
  129. reads to propose the corrected payload/selector/parse. `--verify` confirms a
  130. read-path fix against the live account before you commit it. No AI is bundled —
  131. the project captures deterministic evidence; the fix is human-applied.
  132. ### 🤖 MCP Server (16 Tools for AI Agents)
  133. Expose ChatGPT to Claude Desktop, Cursor, Craft Agent, or any MCP client. Two
  134. transports are supported — **SSE is recommended** for persistent clients like
  135. ZCode; stdio is kept as a compatibility/dev mode.
  136. #### SSE transport (persistent server; single active session until B1)
  137. SSE is useful for one long-lived MCP server, but **current master does not yet
  138. provide per-client tab/session isolation inside one SSE process**. Multiple MCP
  139. clients may attach to the same SSE endpoint, but they share one MCP server, one
  140. `CDPDriver`, one Chrome tab, and one browser conversation surface. Running
  141. parallel agent sessions through the same SSE server can cause cross-session
  142. interference: one session may navigate, continue, or mutate the browser state
  143. expected by another.
  144. Until the B1 MCP session-affine tab pool is implemented and enabled, use SSE
  145. for a **single active agent session at a time**. For parallel agent sessions
  146. today, use separate MCP processes with `parallel_tabs=true` and
  147. `tab_mode=owned`, and ensure the Chrome-owning `chatgpt-web2api` REST process
  148. is started with the same parallel config or is not serving REST traffic on
  149. that CDP port. Otherwise, wait for B1.
  150. Start it (in a dedicated terminal — Chrome must already be running with an
  151. authenticated session, i.e. `chatgpt-web2api` started first):
  152. ```bash
  153. chatgpt-web2api-mcp --transport sse --port 8090
  154. ```
  155. Then add the client config:
  156. ```json
  157. {
  158. "mcpServers": {
  159. "chatgpt-web2api-sse": {
  160. "type": "sse",
  161. "url": "http://localhost:8090/sse"
  162. }
  163. }
  164. }
  165. ```
  166. Every client session that attaches to that URL currently shares the single MCP
  167. server and Chrome connection. This avoids per-session process growth, but it is
  168. **not safe for parallel independent agent sessions** until B1's session-affine
  169. driver/tab pool is available and explicitly enabled.
  170. > **Multi-session warning:** A2 prevents stale-return by anchoring responses to
  171. > the submitted turn, but it does not isolate multiple MCP SSE clients from each
  172. > other. Shared SSE remains a single browser-control surface today.
  173. #### Alternative: stdio transport (per-session, dev/debug)
  174. Stdio spawns one MCP child process per client session, so it is not
  175. recommended for many concurrent ZCode sessions. It is useful for single-client
  176. setups, local development, and debugging (logs go straight to stderr):
  177. ```json
  178. {
  179. "mcpServers": {
  180. "chatgpt": {
  181. "command": "chatgpt-web2api-mcp",
  182. "args": ["--cdp-port", "9222"]
  183. }
  184. }
  185. }
  186. ```
  187. **16 tools** give the agent full control:
  188. | Tool | What it does |
  189. |------|-------------|
  190. | `chat_completion` | Send message, get response (multi-turn, streaming) |
  191. | `list_models` | 17 live model slugs (GPT-5.5, 5.4 Thinking, etc.) |
  192. | `list_projects` | ChatGPT projects with persistent memory |
  193. | `create_project` | Create isolated workspace with dedicated memory |
  194. | `delete_project` | Permanently remove a project (gated: `W2A_ENABLE_DESTRUCTIVE`) |
  195. | `list_conversations` | Recent chats with pagination |
  196. | `get_conversation` | Full message history |
  197. | `archive_conversation` | Archive/unarchive (reversible) |
  198. | `delete_conversation` | Delete permanently |
  199. | `list_memories` | Facts ChatGPT remembers (41 found in testing) |
  200. | `create_memory` | Tell ChatGPT to remember something |
  201. | `delete_memory` | Remove a memory |
  202. | `list_gpts` | Discover Custom GPTs |
  203. | `chat_with_gpt` | Chat with a specific Custom GPT |
  204. | `update_project_instructions` | Change project system prompt |
  205. | `list_project_files` | Files in a project's knowledge base |
  206. Every tool includes rich descriptions with domain knowledge, Pydantic-validated input, structured output schemas, and proper `ToolAnnotations` — agents understand *how* and *when* to use each one without prompting.
  207. ### 🔒 MCP Tool Access Control
  208. The MCP server has **no authentication of its own** — any client that can reach it can call its tools. Since several tools mutate or delete data on your *real* ChatGPT account, tools are gated by risk tier so the dangerous ones are never exposed by accident:
  209. | Tier | Tools | Exposed when |
  210. |------|-------|--------------|
  211. | **Safe** (always visible) | `chat_completion`, `chat_with_gpt`, `list_models`, `list_projects`, `list_conversations`, `get_conversation`, `list_memories`, `list_gpts`, `list_project_files` | Out of the box |
  212. | **Write** (account mutation) | `create_project`, `update_project_instructions`, `create_memory`, `archive_conversation` | `W2A_ENABLE_WRITE=1` |
  213. | **Destructive** (irreversible) | `delete_conversation`, `delete_memory` | `W2A_ENABLE_DESTRUCTIVE=1` |
  214. ```bash
  215. # Default: safe reads + core chat only — nothing can mutate your account
  216. chatgpt-web2api-mcp
  217. # Enable project/memory/archive creation
  218. W2A_ENABLE_WRITE=1 chatgpt-web2api-mcp
  219. # Full surface (also exposes deletes)
  220. W2A_ENABLE_WRITE=1 W2A_ENABLE_DESTRUCTIVE=1 chatgpt-web2api-mcp
  221. ```
  222. Gated tools are **hidden** from `list_tools` *and* **refused at call time** — a client that calls a gated tool by name gets an error result rather than silent execution. Binding the SSE transport to a non-loopback address with no `api_keys` configured logs a prominent warning.
  223. ### 🔌 ZCode Hook: One-Line Bootstrap with `ensure`
  224. Instead of manually starting REST and SSE in separate terminals, run a single
  225. command that reconciles both and exits — ideal for a ZCode session-start hook:
  226. ```bash
  227. chatgpt-web2api ensure
  228. ```
  229. `ensure` is **point-in-time reconciliation**, not a supervisor: it checks REST
  230. (`/health`) and SSE, starts whichever is missing, verifies SSE with a real MCP
  231. handshake, and exits `0` when both are ready (nonzero with a diagnostic if not).
  232. If a service dies later, re-run `ensure` from the next hook/session.
  233. ```bash
  234. # Reconcile REST on 8080 + SSE on 8090 (defaults)
  235. chatgpt-web2api ensure
  236. # Custom ports / config (propagated to the child processes)
  237. chatgpt-web2api ensure --rest-port 8081 --mcp-sse-port 8091 --config ~/.my-config.json
  238. ```
  239. Degraded-REST policy: `ensure` does **not** restart REST immediately on
  240. `degraded` (Chrome alive, driver disconnected) — it polls for up to 20s first,
  241. since that may be a transient CDP reconnect. Only `missing` or `broken` trigger
  242. an immediate (re)start. This avoids a destructive Chrome bounce on transients.
  243. ### 🔧 Three Interfaces, One Chrome Session
  244. ```bash
  245. # Terminal 1: Start Chrome + API
  246. chatgpt-web2api
  247. # Terminal 2: MCP server (SSE recommended for ZCode; stdio also supported)
  248. chatgpt-web2api-mcp --transport sse --port 8090
  249. # or: chatgpt-web2api-mcp # stdio (one MCP child per client)
  250. # Terminal 3: Any OpenAI SDK, curl, or HTTP client
  251. curl http://localhost:8080/v1/chat/completions ...
  252. ```
  253. ## What Makes This Different
  254. | | ChatGPT-Web2API | chat2api | ChatGPTReversed | Official API |
  255. |---|---|---|---|---|
  256. | **Anti-bot handling** | ✅ Automatic (CDP) | ❌ Manual (PoW/Turnstile) | ❌ Manual | N/A |
  257. | **Token extraction** | ❌ None needed | ✅ Required | ✅ Required | N/A |
  258. | **Project memory** | ✅ Full CRUD | ❌ | ❌ | ❌ |
  259. | **MCP server** | ✅ 16 tools | ❌ | ❌ | ❌ |
  260. | **ChatGPT memories** | ✅ List/create/delete | ❌ | ❌ | ❌ |
  261. | **Custom GPTs** | ✅ Chat with any GPT | ❌ | ❌ | ❌ |
  262. | **OpenAI SDK compat** | ✅ Drop-in | ✅ | ❌ | ✅ (native) |
  263. | **Streaming** | ✅ SSE | ✅ | ❌ | ✅ |
  264. | **Multi-turn** | ✅ Auto-continue | ✅ | ❌ | ✅ |
  265. | **Installation** | `pip install` | Docker | npm | `pip install openai` |
  266. | **Cost** | Free (uses your subscription) | Free | Free | Pay-per-token |
  267. **Key insight**: Other proxies fight the anti-bot system. This one *uses the browser as the solution* — Chrome handles Turnstile, PoW, and session management automatically.
  268. ## MCP Tools in Action
  269. An AI agent connected via MCP can:
  270. ```python
  271. # Create an isolated project with dedicated memory
  272. create_project(name="Python Async Specialist", memory_scope="project_v2")
  273. # Chat within the project (persistent memory across conversations)
  274. chat_completion(message="What are Python coroutines?", project_id="g-p-abc123")
  275. # Manage memories
  276. list_memories() # → 41 facts ChatGPT remembers
  277. create_memory(content="Always use type hints in Python code")
  278. delete_memory(memory_id="abc-123")
  279. # List and manage conversations
  280. list_conversations(limit=10)
  281. archive_conversation(conversation_id="xyz", archive=True)
  282. # Chat with a Custom GPT
  283. chat_with_gpt(gpt_id="g-hkJGhxxx", message="Analyze this data")
  284. ```
  285. ## Configuration
  286. ### CLI Flags
  287. | Flag | Default | Description |
  288. |------|---------|-------------|
  289. | `--port` | 8080 | API server port |
  290. | `--cdp-port` | 9222 | Chrome debugging port |
  291. | `--headless` | false | Run Chrome headless (may trigger detection) |
  292. | `--log-level` | INFO | DEBUG, INFO, WARNING, ERROR |
  293. ### Config File (`config.json`)
  294. ```json
  295. {
  296. "port": 8080,
  297. "host": "127.0.0.1",
  298. "cdp_port": 9222,
  299. "headless": false,
  300. "default_model": "auto",
  301. "default_project_id": null,
  302. "tab_mode": "owned",
  303. "parallel_tabs": false,
  304. "api_keys": [],
  305. "request_timeout": 120
  306. }
  307. ```
  308. See [`config.example.json`](config.example.json) for all available keys.
  309. ### MCP Session Pool (B1 — experimental, default off)
  310. When `mcp_session_pool_enabled=true`, the MCP SSE server does **not** connect to
  311. Chrome at startup. Instead, each MCP client session gets its own owned
  312. `CDPDriver`/Chrome tab on first request (lazy materialization). Different
  313. sessions get different tabs, capped by pool size. This enables parallel
  314. multi-session use of one shared SSE endpoint.
  315. Requires `parallel_tabs=true` + `tab_mode=owned` (validated at load).
  316. ```json
  317. {
  318. "parallel_tabs": true,
  319. "tab_mode": "owned",
  320. "mcp_session_pool_enabled": true,
  321. "mcp_session_pool_size": 2
  322. }
  323. ```
  324. Or via environment:
  325. ```bash
  326. W2A_PARALLEL_TABS=1 \
  327. W2A_MCP_SESSION_POOL_ENABLED=1 \
  328. W2A_MCP_SESSION_POOL_SIZE=2 \
  329. chatgpt-web2api-mcp --transport sse --port 8090
  330. ```
  331. Pool defaults are conservative (size=2, TTL=30min). Raise the size only after
  332. the account-level burst canary shows no token-rotation errors or hard account
  333. challenges from genuinely simultaneous multi-tab use.
  334. ### Environment Variables
  335. ```bash
  336. W2A_PORT=8080 W2A_CDP_PORT=9222 chatgpt-web2api
  337. ```
  338. See [`.env.example`](.env.example) for all available variables.
  339. ## Tested Models
  340. Live models from a ChatGPT Plus account (June 2025):
  341. | Slug | Type | Best For |
  342. |------|------|----------|
  343. | `auto` | Reasoning | General use (default) |
  344. | `gpt-5-5` | Reasoning, 34K context | Complex analysis |
  345. | `gpt-5-4-thinking` | Extended reasoning | Step-by-step logic |
  346. | `gpt-5-3-mini` | Fast, 34K context | Simple tasks, speed |
  347. | `gpt-5-mini` | Fast, 8K context | Quick answers |
  348. Use `list_models` to get the current catalog.
  349. ## Performance
  350. | Operation | Time |
  351. |-----------|------|
  352. | Simple question ("2+2?") | 7s |
  353. | Complex reasoning | 15–36s |
  354. | Multi-turn follow-up | 3–6s faster (auto-continue) |
  355. | Model listing | <1s |
  356. | Memory listing | <1s |
  357. ## Requirements
  358. - Python 3.11+
  359. - Chrome or Chromium installed
  360. - ChatGPT Plus subscription
  361. ## Project Structure
  362. ```
  363. src/chatgpt_web2api/
  364. ├── __main__.py CLI entrypoint (chatgpt-web2api)
  365. ├── config.py Configuration from file/env/CLI
  366. ├── chrome.py Chrome subprocess lifecycle
  367. ├── cdp_driver.py CDP primitives (24 methods)
  368. ├── api_server.py OpenAI-compatible HTTP server
  369. ├── mcp_server.py MCP server (16 tools, resources, prompts)
  370. └── service.py Orchestrator: Chrome → CDP → API/MCP
  371. ```
  372. ## Testing
  373. The suite has two tiers:
  374. **Unit tests (default, CI)** — fast, no browser, fully mocked. Run with `pytest`.
  375. These cover structure, business logic, MCP protocol-level behavior, and access gating.
  376. ```bash
  377. pytest -v # all unit tests (CI runs: pytest -m "not e2e")
  378. ```
  379. **End-to-end tests (opt-in)** — drive a *real* ChatGPT account via Chrome CDP.
  380. These are the only tests that exercise the driver↔ChatGPT boundary, which is
  381. exactly where latent bugs hide (the E2E suite has already found four). They
  382. mutate the account, so they are **deselected by default** and never run in CI.
  383. ```bash
  384. # 1. Launch Chrome with CDP (reuses your logged-in profile)
  385. # "chrome.exe" --remote-debugging-port=9222 \
  386. # --user-data-dir=~/.chatgpt-web2api/chrome-profile https://chatgpt.com/
  387. # 2. Run the E2E suite
  388. W2A_E2E_RUN=1 pytest -m e2e -v
  389. ```
  390. E2E safety model:
  391. - **Snapshot-before / diff-after** for every destructive op — no test ever
  392. deletes state it didn't create in the same session.
  393. - A session registry + **guaranteed-cleanup finalizer** removes anything a test
  394. created, even on crash.
  395. - **Pacing** (`W2A_E2E_PACE`, default 12s) between tests to avoid ChatGPT's
  396. "Too many requests" rate limit.
  397. - Reads are zero-risk; chat/memory operations create throwaway state that's
  398. cleaned up; `create_project`/`update_project_instructions` are `xfail` (broken
  399. against the current live API — see CHANGELOG).
  400. If not logged in, the suite opens a headed window and waits up to 10 minutes
  401. for you to log in.
  402. ## Documentation
  403. **[📋 Full documentation index](docs/INDEX.md)** — start here if you're unsure which doc to read.
  404. Key docs:
  405. - [Deployment Guide](docs/deployment.md) — pip install, Docker, cookie injection, multi-instance, sharing
  406. - [OS Supervision Guide](docs/os-supervision.md) — systemd / launchd / Task Scheduler / NSSM for always-on deployments
  407. - [Production Runbook](docs/runbook.md) — health interpretation, failure modes, breaker states, auth recovery, safe restart
  408. - [API Reference](docs/api-reference.md) — OpenAI-compatible REST endpoints + MCP server surface
  409. - [Architecture](docs/architecture.md) — codebase structure and the CDPDriver hub-and-spoke module layout
  410. - [Protocol Reference](docs/protocol-reference.md) — captured ChatGPT web API endpoints
  411. - [Roadmap](docs/ROADMAP.md) — phases 1–6, what landed, what's deferred
  412. - [Contributing](CONTRIBUTING.md) — how to contribute
  413. - [Changelog](CHANGELOG.md) — version history
  414. ## Limitations
  415. - **Single browser session** — one Chrome profile = one ChatGPT account (scale with nginx round-robin)
  416. - **No headless** — headless Chrome triggers ChatGPT's bot detection; use VNC on servers
  417. - **Cookie expiry** — auth cookies expire ~2 weeks; re-login needed
  418. - **Serial requests** — one chat at a time through the browser *by default* (concurrent reads are fine). For per-tab parallelism on one shared Chrome, set `parallel_tabs: true` (requires `tab_mode: "owned"`); see [docs/deployment.md](docs/deployment.md) → "Parallel mode (one Chrome, many tabs)".
  419. - **Memory writes** — ChatGPT's `/backend-api/memories` is read-only; creating memories works via chat interface
  420. - **No image input** — text only (CDP file upload not yet implemented)
  421. ## Roadmap
  422. - [ ] Image/file upload to conversations via CDP drag-and-drop
  423. - [ ] Headless mode with anti-detection patches
  424. - [ ] Concurrent chat pooling across multiple Chrome instances (per-tab parallelism on one Chrome landed via `parallel_tabs`; the cross-instance pool/router is still future work)
  425. - [ ] Web search mode (trigger ChatGPT's built-in search)
  426. - [ ] DALL-E image generation via ChatGPT
  427. - [ ] Canvas/code execution support
  428. - [ ] Retry logic with exponential backoff for Chrome failures
  429. ## License
  430. [MIT](LICENSE) © Elephant Rock Lab

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.