Can ChatGPT Read Web Pages, and Why Does It Need a Proxy?

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.

Short Answer: When ChatGPT Can Read a Web Page and When It Cannot

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.

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.

How ChatGPT Actually Reads a Page

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:

• ChatGPT decides whether it needs to access the website. Much depends on the quality of the source and the level of trust assigned to it.
• ChatGPT does not return the page content or source code like a typical parser. It only analyzes the page and may then use the information in its answers.
• Some websites or pages may be closed to access. This may happen when login and password authorization is required or when anti-bot systems, firewalls, and similar protections are enabled. In such cases, ChatGPT is powerless.
• In some cases, errors may occur when reading large amounts of JavaScript, particularly on PWA websites built with React, Vue, Angular, and other frameworks.
• The number of pages examined is always limited. ChatGPT will not scrape an entire website or a product catalog section. It mainly examines key pages such as About, Pricing, and similar sections.
• The model does not “open” a page like a browser. It receives text through fetch or ChatGPT retrieval, reads the code in chunks through a sliding window, discards CSS, JavaScript, and images, and then works with cleaned text to save internal tokens and server computing resources.

Why ChatGPT Cannot Read Many Pages

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:

• The target website may block AI bots based on the User-Agent and other characteristics.
• Pages may be protected by Cloudflare or other anti-bot systems, including web application firewalls. A ChatGPT Cloudflare access problem cannot be solved from the standard chat interface. See also our separate article about ethically bypassing WAF protection during scraping.
• The number of requests made by ChatGPT Search may exceed the limits established for users or visitors, such as the number of requests or simultaneous sessions allowed from one IP address within a given period.
• Target pages may be protected by passwords, authorization forms, paywalls, and similar restrictions.

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.

When Proxies Are Used

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:

• Bypassing blocks. Sessions and users are most often blocked by IP address. An IP address may also be one of the most important factors when a visitor profile is analyzed.
• Bypassing limits on the number of requests from one address. You can run any number of connections in parallel, with each connection using its own proxy and IP address.
• Retrieving current content from target websites for different regions, countries, or cities.
• Imitating different user profiles while concealing your own.
• And so on.

Related article: Every Link in the Chain: Proxies, Scrapers, and Data-Processing Pipelines.

Practical Guide: Sending Web Data to ChatGPT Through a Proxy

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.

Ethics and Limitations

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.

FAQ

Can Free ChatGPT Read Links?

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.

Why Does ChatGPT Say That It Cannot Access a Link?

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.

Does ChatGPT Use Proxies by Default?

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.

How Can I Make ChatGPT Read a Blocked Website?

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.