This article explains how ChatGPT works through a proxy, when such a setup may be required, and how it can be implemented. It also covers what ChatGPT can do without a proxy and what limitations apply to ChatGPT scraping. The common search query “can ChatGPT read WebP?” refers to this same question.
If you are asking “can ChatGPT read webps” or “can ChatGPT access websites?”, the answer is yes, but with several significant limitations.
ChatGPT has recently gained its own search engine and website-parsing mechanism. However, the parameters and technical description of this stack cannot be found in public sources. It is therefore impossible to know exactly what it can and cannot do.
A great deal also depends on the ChatGPT mode being used and the additional tools involved.
|
ChatGPT mode |
How it works with data |
|
Basic chat |
Can read only what the user pastes into the chat or attaches as files. It does not make direct requests to websites. |
|
Web Search mode |
Can read information from specified websites, but with the usual limitations of basic parsers: no authorization and possible difficulties with JavaScript. In addition, data is collected only from individual pages; it cannot scrape an entire website. |
|
API |
Web search has been supported since GPT-4o Search Preview. There is also a separate Web Search tool for the Responses API. The limitations are the same as in search mode. |
|
Custom pipeline, custom GPTs, and agents |
An external parser is responsible for reading pages or retrieving their source code. The data may be cleaned first or sent to the AI for analysis without modification. ChatGPT is responsible only for extracting data from the code, not for retrieving that code. |
In general, if you need direct reading of live pages, ChatGPT still cannot help you in every case. Accordingly, when building complex ChatGPT scraping systems, you need a separate module for retrieving website code. Once the raw data are available, ChatGPT can work with them more effectively than many other solutions.
When used in a standard chat or through the API, ChatGPT cannot access links directly. Most of its data comes from its internal knowledge base – information that was scraped earlier and provided to the LLM during training. At some point, those data may become outdated, especially when prices or other dynamic content are involved.
However, if you use the dedicated Web Search mechanism, the LLM connects to an internal search tool. This is the layer responsible for ChatGPT web browsing.
The new Responses API for integrating web search through web_search and gpt-5.5 supports separate web-search controls: filters, source specification, real-time access management, and longer research chains carried out as part of reasoning.
In other words, if you give ChatGPT a direct link to a website or one of its pages, it may access it directly. However, everything depends on the capabilities of OpenAI’s search layer:
The main reason is the need to conserve computing resources. To understand a product, a company’s range of services, its features, prices, and similar information, it is enough to review the key pages of the official website. That is what ChatGPT does. Web browsing in ChatGPT is intended exclusively to update individual pieces of information when answering user requests. The question “does ChatGPT browse the internet” therefore has a qualified answer: it can use a search layer, but it does not operate as an unrestricted crawler. Nothing more. All additional tasks that go beyond those goals are restricted by the algorithms of the built-in search engine.
If generating an answer requires too much time and too many resources, it becomes financially impractical.
Other limitations of built-in ChatGPT scraping should also be considered, especially when ChatGPT scraping involves several target pages:
In summary, ChatGPT cannot bypass Cloudflare protection, and AI cannot view restricted areas of a website. The number of pages visited depends on the user’s task, but it is always optimized to conserve resources. Search results are used first, and individual pages of the target website are visited only afterward to clarify details. This is also why users sometimes report that ChatGPT can't access links.
ChatGPT’s built-in scraping system does not allow users to connect third-party proxies. If proxies are used at all, they operate inside OpenAI’s own search layer.
The ability to connect a proxy for LLM workflows appears only when you build your own pipelines using the API or AI agents. In this setup, proxies solve many problems:
Related article: Every Link in the Chain: Proxies, Scrapers, and Data-Processing Pipelines.
Feed clean data into ChatGPT: bypass Cloudflare and rate limits while your scraper collects pages.
As explained above, proxies for LLMs are connected only when ChatGPT is used as one of the modules in a data-processing chain. To make the principle easier to understand, here are two practical examples of ChatGPT scraping.
The first example uses the requests library. It cannot render JavaScript, so it is suitable only for simple websites that include their data directly in the HTML:
import json
import requests
from openai import OpenAI
OPENAI_API_KEY = "sk-..."
PROXY = "http://login:password@127.0.0.1:8080"
URL = "https://example-shop.com/catalog"
# Retrieve HTML through the proxy
response = requests.get(
URL,
proxies={
"http": PROXY,
"https": PROXY,
},
timeout=30,
)
html = response.text
client = OpenAI(api_key=OPENAI_API_KEY)
prompt = f"""
Extract all products and prices from the HTML code.
Return only a JSON array in the following format:
[
]
HTML:
{html[:150000]}
"""
result = client.responses.create(
model="gpt-5.5",
input=prompt
)
print(result.output_text)The second example is intended for dynamic pages and uses a headless browser through the Playwright web driver:
import asyncio
from playwright.async_api import async_playwright
from openai import OpenAI
OPENAI_API_KEY = "sk-..."
client = OpenAI(api_key=OPENAI_API_KEY)
URL = "https://example-shop.com/catalog"
PROXY_SERVER = "http://127.0.0.1:8080"
PROXY_USER = "login"
PROXY_PASSWORD = "password"
async def get_html():
async with async_playwright() as p:
browser = await p.chromium.launch(
headless=True,
proxy={
"server": PROXY_SERVER,
"username": PROXY_USER,
"password": PROXY_PASSWORD
}
)
page = await browser.new_page()
await page.goto(
URL,
wait_until="networkidle",
timeout=60000
)
html = await page.content()
await browser.close()
return html
async def main():
html = await get_html()
prompt = f"""
Extract products and prices from the online store's HTML code.
Return only JSON.
Format:
[
]
HTML:
{html[:150000]}
"""
response = client.responses.create(
model="gpt-5.5",
input=prompt
)
print(response.output_text)
asyncio.run(main())Please note that the examples send the original page source code without cleaning it first. As a result, the requests will consume a very large number of ChatGPT tokens. If you want to reduce processing costs, you should remove all unnecessary elements from the code beforehand.
All scraping must comply with moral and ethical standards. It must not violate the law and must respect the requirements of the target website. For example, a script should not crawl pages prohibited in the robots.txt file. It should not create a heavy load on the hosting infrastructure that could cause a denial of service for other users.
In most cases, legal problems do not begin when you scrape someone’s website, but when the collected data are handled incorrectly. For example, many countries prohibit storing personal information without the consent of its owners. You also cannot claim other people’s intellectual work: texts, images, videos, and similar content as your own.
The limitations of ChatGPT itself should not be forgotten either. We described them above. An LLM does not reproduce target pages in full; the AI only summarizes or describes them.
Related article: How to Make Your Web Scraping Script Legal in 2026.
Yes, in Web Search mode. However, you should remember the limitations described in this article: the AI decides for itself whether the specified URL should be visited. There is no guarantee that it will access the page.
In any case, ChatGPT relies on the capabilities of its search layer, which operates independently of the LLM as a separate black-box service. Only its developers know exactly what it can do.
The most likely reasons are that the page or website is password-protected, access is blocked by a web application firewall or anti-bot system, the website is unavailable in the region or from the IP addresses used by ChatGPT’s search layer, the page or website is temporarily unavailable when OpenAI’s search bot attempts to access it, or the page contains too much JavaScript for the search layer to generate the final data.
No, not when you use ChatGPT in the chat interface or through the official API. Proxies can be connected only when you build your own parser or create a pipeline involving AI agents. In that setup, ChatGPT acts as one of the agents in the chain. Technically, the proxies are connected to the scraping tool, while ChatGPT receives only the data that needs to be analyzed.
There is only one solution: bypass the protection using third-party tools. For example, you can build a chain consisting of proxy servers and a scraping module. The module accesses the website, copies the page’s original HTML code, and sends it to ChatGPT for analysis.
See also: How to Choose AI for Data Analysis: BI, AutoML, or LLM.