Wie sich eine Headless-Browser-Farm für ChatGPT im großen Stil betreiben lässt
Eine Headless-Browser-Farm für ChatGPT benötigt pro Browser fünf Komponenten sowie drei umgebende Systeme. Dazu zählen ein stealth-gepatchtes Chromium, eine stabile residential Proxy-Sitzung, ein Netzwerk-Interceptor am Conversation-Endpoint, ein Completion-Detector und eine Citation-Erweiterung.
Veröffentlicht am 9. Oktober • Zuerst erschienen auf cloro.dev • KI-unterstützt
Eine headless Browser-Farm für ChatGPT im großen Maßstab benötigt fünf Komponenten in jedem Browser und drei Systeme um die Browser herum. Jeder Browser braucht ein mit Stealth-Patches versehenes Chromium, eine klebrige Residential-Proxy-Session, einen Netzwerk-Interceptor auf dem Conversation-Endpunkt, einen Completion-Detektor und einen Citation-Expander. Rundherum benötigt die Farm einen Pool warmer Sessions, Routing pro Region und Monitoring pro Feld.
Der Aufbau ist der kleinere Kostenfaktor. Eine veröffentlichte Schätzung von cloro beziffert einen selbst betriebenen ChatGPT-Scraper auf etwa 4.800 bis 14.100 Dollar pro Monat bei 500.000 bis 1 Million Anfragen, wobei die Ingenieurszeit der größte Posten ist. Die Alternativen sind gemietete Browser-Infrastruktur wie Bright Data oder Browserbase, bei der der Parser in eigener Hand bleibt, und ein verwalteter Endpunkt wie cloro, der 5 Credits pro ChatGPT-Web-Suche-Antwort berechnet.
Jeder Browser in der Farm läuft mit denselben fünf Teilen. Jeder Teil beantwortet einen bestimmten Fehlerfall.
Der Interceptor ist ein Playwright-Response-Handler:
async def setup_page_interceptor ( self, page: Page ): """ Set up network request interception. """ async def handle_response ( response ): # Capture conversation API responses if ' backend-api/f/conversation ' in response. url: response_body = await response. text () self. captured_responses. append ( response_body ) page. on ( ' response ', handle_response ) Enter fullscreen mode Exit fullscreen mode Der erfasste Body ist roher SSE-Text. Der Parser teilt ihn an data:-Zeilen, verwirft den Sentinel und behält die gültigen JSON-Objekte:
import json from typing import List, Dict, Any def extract_raw_response ( input_string: str ) -> List [ Dict [ str, Any ]]: """ Parse ChatGPT ' s Server-Sent Events stream. """ json_objects = [] # Split by lines that start with "data: " lines = input_string. split ( " \n " ) for line in lines: # Skip empty lines and non-data lines if not line. strip () or not line. startswith ( " data: " ): continue # Remove "data: " prefix json_str = line [ 6:]. strip () # Skip special markers like [DONE] if json_str == " [DONE] ": continue # Try to parse as JSON try: json_obj = json. loads ( json_str ) # Only include if it's a dictionary (object), not string or other types if isinstance ( json_obj, dict ): json_objects. append ( json_obj ) except json. JSONDecodeError: # Skip invalid JSON continue return json_objects Enter fullscreen mode Exit fullscreen mode Die vollständige Scraper-Klasse, aus der diese beiden Auszüge stammen, startet Chromium mit headless=False.
Diese Wahl ist bewusst getroffen. Headless-Standardeinstellungen sind das erste Signal, das die Bot-Erkennung liest, daher läuft eine Produktions-Farm vollständige Browser-Umgebungen mit konsistenten Canvas-, Font- und TLS-Fingerprints.
Fünf Fehlerarten treffen einen ChatGPT-Scraper im Produktionsbetrieb. Wir führen täglich etwa 1.000 Engine-Antworten über sechs Engines für cloros eigenes Tracking-Korpus durch, und dies sind die Fehler, denen der Betrieb begegnet.
Die erste und letzte Zeile kosten am meisten. Ein Parser, der gegen ein Format gebaut wurde, meldet das andere als Teilerfolg, und ein Teilerfolg löst keinen Alarm aus.
Auch die Ziele bewegen sich. Die URL backend-api/f/conversation hat sich 2025 zweimal geändert. Das Shopping-Card-Event wechselte von einem flachen products-Array zu einem verschachtelten offers-Block. OpenAIs Build-Pipeline generiert CSS-Klassennamen, die sich zwischen Deployments ändern, sodass ein Scraper, der auf Klassenselektoren setzt, ungefähr wöchentlich bricht. ARIA-Labels, Rollen-Attribute und Textinhalte halten länger als Klassennamen, und beide brechen dennoch irgendwann.
Die Farm muss aussehen und sich verhalten wie die ausgeloggten Nutzer, die ChatGPT bereits bedient. Tun Sie diese vier Dinge.
Der IP-Typ setzt die Obergrenze. In von proxies.sx veröffentlichten Tests hielten echte mobile IPs 50 bis 100 oder mehr Abfragen durch, während Datacenter-IPs innerhalb der ersten wenigen Anfragen blockiert wurden. Diese Zahl stammt vom Anbieter und wurde für diesen Artikel nicht reproduziert.
Statuscodes zeigen die beiden teuersten Fehler nicht, daher überwachen Sie die Felder. Verfolgen Sie diese Raten pro Tag:
Eine Änderung bei einer der drei ist eine Formatänderung oder eine Modell-Rotation in Ihrer Stichprobe.
Eine Invariante hilft bei ChatGPT. Wir haben das Grounding bei etwa 2.500 Prompts pro Engine gemessen, und ChatGPT stützte 98,4 Prozent seiner Antworten auf Live-Quellen mit jeweils 14,1 Quellen. Eine erneute Messung am 19.08.2026 ergab 78,9 Prozent und 12,7 Quellen. Eine leere Zitatliste aus einem ChatGPT-Scrape ist häufiger ein Parse-Fehler als eine unbelegte Antwort, also prüfen Sie in Ihren Tests, dass die Quellenliste nicht leer ist.
Playwright ist die richtige Wahl, wenn Answer-Daten Ihr Produkt sind, Ihr Volumen ein dediziertes Team trägt und Sie Kontrolle benötigen, die ein Anbieter nicht geben kann. Es ist frei und Open Source, jede Schicht gehört Ihnen und es gibt keinen Vendor-Lock-in. Ein Team ohne Budget mit starken Ingenieuren kann es ebenfalls bei geringem Volumen betreiben. Die unten verlinkte Übersicht veranschlagt 8 bis 15 Ingenieurstunden pro Monat für einen Playwright-Stack bei 1.000 Abfragen pro Tag.
Eine bezahlte API ist die richtige Wahl, wenn Answer-Daten ein Input für ein anderes Produkt sind. Unter etwa 1.000 Antworten pro Tag ist ein Anbieter günstiger, sobald Sie Ihre eigene Zeit einpreisen. Es gibt zwei Arten bezahlter APIs, und es ist nicht derselbe Kauf:
import requests import json # Your prompt prompt = " Compare the top 3 programming languages for web development in 2026 " # API request to cloro response = requests. post ( ' https://api.cloro.dev/v1/monitor/chatgpt ', headers = { ' Authorization ': ' Bearer YOUR_API_KEY ' }, json = { ' prompt ': prompt, ' country ': ' US ', ' include ': { ' markdown ': True, ' rawResponse ': True, ' searchQueries ': True } } ) result = response. json () print ( json. dumps ( result, indent = 2 )) Enter fullscreen mode Exit fullscreen mode Eine ChatGPT-Web-Suche-Antwort kostet dort 5 Credits als asynchrone Anfrage. Eine synchrone Anfrage wie im Beispiel oben kostet 2 Credits zusätzlich. 5.000 Prompts pro Tag sind etwa 750.000 Credits pro Monat, was in den Growth-Plan mit 500 Dollar pro Monat für 1.350.000 Credits passt.
Das sind 1,85 Dollar pro 1.000 Antworten. Fehlgeschlagene Anfragen werden nicht abgerechnet. Der Kompromiss ist die Kontrolle: Sie können keinen Session-Pool abstimmen, den Sie nicht selbst betreiben.
Keine der beiden Optionen passt, wenn Sie die Ausgabe des Modells und nicht die Antwort möchten, die ChatGPT seinen Nutzern zeigt. Das ist die Aufgabe der OpenAI API, abgerechnet in Tokens.
Die Fehlerarten stammen aus cloros eigenem Tracking-Betrieb mit etwa 1.000 Engine-Antworten pro Tag über sechs Engines. Die Komponenten und der Code stammen von einem funktionierenden Playwright-Scraper für die ausgeloggte ChatGPT-Oberfläche. Die Zahl von 4.800 bis 14.100 Dollar ist eine Schätzung und keine gemessene Rechnung. Sie addiert Listenpreise (999 Dollar für 332 GB Residential-Proxy-Bandbreite bei Bright Data, 496 Dollar pro Monat für jede c6i.4xlarge-Browser-Instanz) zu einem Fünftel bis einer Hälfte eines Ingenieurs beim US-Mediangehalt für Softwareentwickler von 131.450 Dollar, voll belastet.
Dieser Artikel wird von cloro veröffentlicht, das eine der verwalteten Optionen darin ist. Zahlen anderer Anbieter sind die von diesen Anbietern veröffentlichten Zahlen. Die cloro-Preise sind selbst angegeben und wurden am 07.10.2026 gegen die Preisliste geprüft.
Automatisch übersetzt. Das Original auf Englisch ist unten aufklappbar.
Original (Englisch) anzeigen
Posted on Oct 9 • Originally published at cloro.dev • AI-assisted
A headless browser farm for ChatGPT at scale takes five components in every browser and three systems around the browsers. Each browser needs a stealth-patched Chromium, a sticky residential proxy session, a network interceptor on the conversation endpoint, a completion detector and a citation expander. Around them, the farm needs a pool of warm sessions, routing per region and monitoring per field.
The build is the smaller cost. One published estimate from cloro puts a self-run ChatGPT scraper at roughly $4,800 to $14,100 a month at 500,000 to 1 million requests, with engineer time as the largest line. The alternatives are rented browser infrastructure such as Bright Data or Browserbase, where the parser stays yours, and a managed endpoint such as cloro, which bills 5 credits for each ChatGPT web-search answer.
Each browser in the farm runs the same five parts. Each part answers one specific failure.
The interceptor is a Playwright response handler:
async def setup_page_interceptor ( self, page: Page ): """ Set up network request interception. """ async def handle_response ( response ): # Capture conversation API responses if ' backend-api/f/conversation ' in response. url: response_body = await response. text () self. captured_responses. append ( response_body ) page. on ( ' response ', handle_response ) Enter fullscreen mode Exit fullscreen mode The captured body is raw SSE text. The parser splits it on data: lines, drops the sentinel and keeps the valid JSON objects:
import json from typing import List, Dict, Any def extract_raw_response ( input_string: str ) -> List [ Dict [ str, Any ]]: """ Parse ChatGPT ' s Server-Sent Events stream. """ json_objects = [] # Split by lines that start with "data: " lines = input_string. split ( " \n " ) for line in lines: # Skip empty lines and non-data lines if not line. strip () or not line. startswith ( " data: " ): continue # Remove "data: " prefix json_str = line [ 6:]. strip () # Skip special markers like [DONE] if json_str == " [DONE] ": continue # Try to parse as JSON try: json_obj = json. loads ( json_str ) # Only include if it's a dictionary (object), not string or other types if isinstance ( json_obj, dict ): json_objects. append ( json_obj ) except json. JSONDecodeError: # Skip invalid JSON continue return json_objects Enter fullscreen mode Exit fullscreen mode The full scraper class that these two excerpts come from launches Chromium with headless=False.
That choice is deliberate. Headless defaults are the first signal that bot detection reads, so a production farm runs full browser environments with consistent canvas, font and TLS fingerprints.
Five failure modes hit a ChatGPT scraper in production. We run about 1,000 engine answers a day across six engines for cloro's own tracking corpus, and these are the failures that operation meets.
The first and last rows cost the most. A parser built against one format reports the other as a partial success, and a partial success sends no alert.
The targets also move. The backend-api/f/conversation URL changed twice in 2025. The shopping-card event moved from a flat products array to a nested offers block. OpenAI's build pipeline generates CSS class names that change between deploys, so a scraper that relies on class selectors breaks roughly weekly. ARIA labels, role attributes and text content last longer than class names, and both still break.
The farm must look and behave like the logged-out users that ChatGPT already serves. Do these four things.
The IP type sets the ceiling. In testing published by proxies.sx, real mobile IPs lasted 50 to 100 or more queries, and datacenter IPs were blocked within the first few requests. That figure is the vendor's and was not reproduced for this article.
Status codes do not show the two failures that cost the most, so monitor the fields. Track these rates per day:
A change in any of the three is a format change or a model rotation in your sample.
One invariant helps with ChatGPT. We measured grounding on roughly 2,500 prompts per engine, and ChatGPT grounded 98.4% of its answers in live sources at 14.1 sources each. A re-measurement on 2026-08-19 gave 78.9% and 12.7 sources. An empty citation list from a ChatGPT scrape is more often a parse failure than an ungrounded answer, so assert a source list that is not empty in your tests.
Playwright is the correct choice when answer data is your product, your volume pays for a dedicated team and you need control that a vendor cannot give. It is free and open source, every layer is yours to tune and there is no vendor lock-in. A team with no budget and strong engineers can also run it at low volume. The roundup linked below budgets 8 to 15 engineer hours a month for a Playwright stack at 1,000 queries a day.
A paid API is the correct choice when answer data is an input to another product. Under roughly 1,000 answers a day, a provider costs less as soon as you price your own time. Two kinds of paid API exist, and they are not the same purchase:
import requests import json # Your prompt prompt = " Compare the top 3 programming languages for web development in 2026 " # API request to cloro response = requests. post ( ' https://api.cloro.dev/v1/monitor/chatgpt ', headers = { ' Authorization ': ' Bearer YOUR_API_KEY ' }, json = { ' prompt ': prompt, ' country ': ' US ', ' include ': { ' markdown ': True, ' rawResponse ': True, ' searchQueries ': True } } ) result = response. json () print ( json. dumps ( result, indent = 2 )) Enter fullscreen mode Exit fullscreen mode A ChatGPT web-search answer costs 5 credits there as an async request. A synchronous request, as in the sample above, adds 2 credits. 5,000 prompts a day is about 750,000 credits a month, which fits in the Growth plan at $500 a month for 1,350,000 credits.
That is $1.85 per 1,000 answers. Failed requests are not billed. The trade is control: you cannot tune a session pool that you do not run.
Neither option fits if you want the model's output and not the answer that ChatGPT shows its users. That is the OpenAI API's job, priced in tokens.
The failure modes come from cloro's own tracking operation, about 1,000 engine answers a day across six engines. The components and the code come from a working Playwright scraper for the logged-out ChatGPT surface. The $4,800 to $14,100 figure is an estimate and not a measured bill. It adds list prices ($999 for 332 GB of residential proxy bandwidth on Bright Data, $496 a month for each c6i.4xlarge browser instance) to a fifth to a half of one engineer at the US median software developer salary of $131,450, loaded.
This article is published by cloro, which is one of the managed options in it. Figures for other vendors are those vendors' published figures. The cloro prices are self-reported and were checked against its price list on 2026-10-07.