Documentation Python quickstart Blog Free tools Enterprise solutions hello@quanticdata.ioLog in

Screen scraping: what it means, with one page read three ways

One public page of 10 quotes read three ways through a residential proxy: the JSON API answered in 2,860 bytes, the HTML page in 11,064 bytes, and rendering the screen in a browser took 6 responses and 269,173 bytes; the card says all three reads returned the same 10 records.
One public page of 10 quotes read three ways through a residential proxy: the JSON API answered in 2,860 bytes, the HTML page in 11,064 bytes, and rendering the screen in a browser took 6 responses and 269,173 bytes; the card says all three reads returned the same 10 records.

Screen scraping is collecting data by reading what a program displays on screen, the way a person would, instead of asking for the data through an API or a file. A script opens the page or application, lets it draw, then copies the visible text, by element, by position or with character recognition. It is the fallback when no structured source exists.

The term is older than the web and today it covers three different jobs. Below we define them, then read the same ten records from one public page three ways on 20 November 2026 through a QuanticData Residential Premium proxy, and count what each way cost.

Screen scraping meaning: three uses of one term

Where the term is usedWhat is readTypical tool
Legacy systemsThe character screen of a mainframe or terminal application, field by field at fixed rows and columnsTerminal emulators, robotic process automation (RPA) software
Web pagesThe page as a browser draws it, after its JavaScript has runBrowser automation: Playwright, Puppeteer, Selenium
Banking and fintechA customer's account pages, opened by a third-party app with the customer's own loginBeing replaced by open banking APIs

What the three share is the direction of travel: the data was formatted for human eyes, and the scraper works backwards from the display to the values. That is the difference from an API, which hands over the values with their names, and from classic web scraping, which reads the page source and never draws anything.

Screen scraping vs web scraping vs API

Screen scrapingWeb scraping (HTML)API
ReadsWhat is drawn on screenThe HTML the server sendsJSON or XML made for programs
Needs a browserYesNoNo
Finds a value byVisible text, element or positionSelectors on the sourceField name
Works when data is drawn by JavaScriptYesOnly if the data is in the sourceYes, if the site has one
Bytes for 10 records in our run269,17311,0642,860

In everyday speech the first two overlap, and many people say "screen scraping" for any scraping of a website. The distinction matters when you choose a tool, because it decides whether you pay for a browser.

A screen scraping example: one page, three reads

quotes.toscrape.com is a public practice site built for scraping exercises. It publishes the same ten quotes per page in three forms: plain HTML at /, a JavaScript-drawn page at /js/, and a JSON API at /api/quotes. We read all three from Node 22 through one Residential Premium line in the United States.

Read 1: the API

const { ProxyAgent, fetch } = require('undici');
const agent = new ProxyAgent({ uri: 'http://residentialpremium.quanticdata.io:8080',
  token: 'Basic ' + Buffer.from('USER-country-us:PASS').toString('base64') });

const res = await fetch('https://quotes.toscrape.com/api/quotes?page=1', { dispatcher: agent });
const j = JSON.parse(await res.text());
console.log(res.status, res.headers.get('content-type'), j.quotes.length, Object.keys(j.quotes[0]));
200 application/json 10 [ 'author', 'tags', 'text' ]

2,860 bytes, and every value arrives with its name: author.name is "Albert Einstein", tags is a list of four strings. Nothing to locate, nothing to clean.

Read 2: the HTML with selectors

const cheerio = require('cheerio');
const $ = cheerio.load(html);               // html = body of https://quotes.toscrape.com/
const rows = $('.quote').map((i, q) => ({
  text: $(q).find('.text').text(),
  author: $(q).find('.author').text(),
  tags: $(q).find('.tag').map((i, t) => $(t).text()).get(),
})).get();
console.log(rows.length, rows[0].author, rows[0].tags);
10 Albert Einstein [ 'change', 'deep-thoughts', 'thinking', 'world' ]

11,064 bytes of HTML for the same ten records. This is classic web scraping: no screen is involved, the script reads the source and picks elements by class. More on the technique in web scraping with cheerio and CSS selectors and XPath.

Read 3: the screen

The /js/ version of the page is where reading the source stops working. Fetched without a browser it is 5,808 bytes and holds 0 elements with the class quote: the quotes sit inside a script that builds the page after it loads. To get them the way a visitor does, the page has to be drawn. We opened it in Chromium with Playwright at 1280 by 800 pixels and read the screen three ways:

const { chromium } = require('playwright');
const browser = await chromium.launch({ proxy: {
  server: 'http://residentialpremium.quanticdata.io:8080',
  username: 'USER-country-us', password: 'PASS' } });
const page = await browser.newPage({ viewport: { width: 1280, height: 800 } });
await page.goto('https://quotes.toscrape.com/js/', { waitUntil: 'domcontentloaded' });
await page.waitForSelector('.quote');

// 1. all the text a visitor can read
const screenText = await page.evaluate(() => document.body.innerText);

// 2. where each record sits on screen
const boxes = await page.evaluate(() => [...document.querySelectorAll('.quote')].map(q => {
  const b = q.getBoundingClientRect();
  return { x: Math.round(b.x), y: Math.round(b.y), w: Math.round(b.width), h: Math.round(b.height) };
}));

// 3. what is under one point of the screen
const atPoint = await page.evaluate(() => {
  const el = document.elementFromPoint(200, 150);
  return { tag: el.tagName, cls: el.className, text: el.innerText.slice(0, 40) };
});
await page.screenshot({ path: 'screen.png' });
screenText: 1499 characters, 35 lines
  Quotes to Scrape
  Login
  “The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”
  by Albert Einstein
  Tags: change deep-thoughts thinking world
  “It is our choices, Harry, that show what we truly are, far more than our abilities.”
  by J.K. Rowling
  Tags: abilities choices
boxes: 10, first four
  { x: 70, y: 118, w: 1140, h: 108 }
  { x: 70, y: 256, w: 1140, h: 108 }
  { x: 70, y: 395, w: 1140, h: 108 }
  { x: 70, y: 533, w: 1140, h: 108 }
atPoint: { tag: 'SPAN', cls: 'text', text: '“The world as we have created it is a pr' }
screen.png: 54743 bytes

The browser made 6 requests and downloaded 269,173 bytes to draw the page. On screen the data is plain text again: 35 lines in reading order, each record a block 1,140 pixels wide starting 70 pixels from the left, 5 of the 10 inside the first 800 pixels of height. The point test works like a finger on the glass: at x 200, y 150 sits the text of the first quote.

Turning the screen back into records

Screen text has no field names, so the layout is the schema. On this page every record is three lines: the quote in curly quotation marks, then "by" and the author, then "Tags:" and the tags. A dozen lines rebuild the table:

const lines = screenText.split('\n').map(s => s.trim()).filter(Boolean);
const recs = [];
for (let i = 0; i < lines.length; i++) if (/^\u201c/.test(lines[i])) recs.push({
  text: lines[i],
  author: (lines[i + 1] || '').replace(/^by\s+/, ''),
  tags: (lines[i + 2] || '').replace(/^Tags:\s*/, ''),
});
console.log(recs.length, recs[0].author, '|', recs[0].tags);
10 Albert Einstein | change deep-thoughts thinking world

We then compared the three reads record by record. The authors and texts read off the screen matched the API on 10 of 10 records, and so did the ones read from the HTML. Same data, three costs:

ReadRequestsBytesRecordsStructure you get
JSON API12,86010Named fields, tags as a list
HTML and selectors111,06410Elements with classes
Rendered screen6269,17310Lines of text and positions

This is one run on one small page: to draw it, the browser also loaded the styles and scripts the page links to. On a metered proxy plan, bytes are the bill, so the order to try is the order of the table.

When screen scraping is the right tool

  • The data is drawn by JavaScript and there is no API you may use. Our /js/ page is the small version of this. See scraping dynamic pages in Python and waiting for a page to load in Playwright.
  • What matters is what the visitor sees. Checking that an ad, a price or a search result appears in a given country is a question about the screen, not about the source. A proxy in that country plus a screenshot answers it; see Playwright screenshots.
  • The value exists only as pixels. Text inside an image, a chart or a remote desktop has no element to select. There the screenshot goes to optical character recognition (OCR), which returns text with a confidence score to check.
  • A legacy application has no export. This is the original use: RPA software reads fixed positions of a terminal screen and types into another system.

In every other case, read the API first and the HTML second. If you would rather not run browsers at all, our Web Scraping API renders the page on our side and returns the content, and the ready-made collectors return named fields for common sources. What happens after the read, turning text into typed fields, is data parsing.

Screen scraping in banking and open banking

The banking sense of the term is the one regulators write about. A budgeting or lending app asks the customer for their online banking username and password, logs in as the customer and reads balances and transactions off the account pages. It works without the bank's cooperation, and the weak point is the same: the app holds the customer's full login. Open banking rules, such as PSD2 in the European Union, moved this traffic to dedicated APIs where the customer grants a limited, revocable permission instead of handing over a password. That use is outside what this post covers: everything we ran reads a public page with no login.

The technique itself is neutral; what you read and how decides. Reading public pages that anyone can open without an account is the common, accepted case. Pages behind a login are governed by the site's terms and by the account holder's consent, and personal data is covered by privacy law wherever it is collected. Some sites forbid automated access in their terms. Check the terms and robots.txt before you start, identify your client honestly, and keep the request rate low; crawling a website politely lists the habits that matter. This is general information, not legal advice.

Screen scraping tools, and where a proxy fits

JobTools
Render a web page and read itPlaywright, Puppeteer, Selenium
Read text out of a screenshotAn OCR engine such as Tesseract
Read desktop or terminal applicationsRPA suites, terminal emulators with scripting
Parse HTML without a screencheerio, BeautifulSoup, lxml

A site often draws a different screen depending on where the visitor is: currency, language, stock, local results. Because screen scraping reads exactly what was drawn, the exit country of the request decides what you collect. All three reads above went out through a Residential Premium line set to the United States with -country-us in the username. Our residential proxies place requests on home connections in the country you choose, and our mobile proxies on carrier connections, which is the one to use when the screen you need is the mobile one.

Sources & further reading

FAQ

Quick answers on screen scraping.

Something else? Ask us

What is screen scraping?

Collecting data by reading what a program displays, instead of using an API or reading the source. A script opens the page or application, lets it draw, and copies the visible text by element, by position or with OCR.

What is the difference between screen scraping and web scraping?

Web scraping reads the HTML a server sends and picks values with selectors; no browser is needed. Screen scraping reads the page after a browser has drawn it. In our run the same 10 records cost 11,064 bytes as HTML and 269,173 bytes as a rendered screen.

Screen scraping vs API: which should I use?

The API when one exists and you are allowed to use it. In our test the API returned the 10 records in 2,860 bytes with named fields. Screen scraping is for data that is only drawn on screen.

Can I do screen scraping in Python?

Yes. Playwright has a Python package that opens the same browser. We ran page.inner_text("body") on the same page from Python 3.12 through the same proxy and it returned the same 35 visible lines as the innerText call in our Node example.

Is screen scraping legal?

The technique is neutral. Public pages that need no account are the accepted case; pages behind a login depend on the site's terms and the account holder's consent, and personal data falls under privacy law. Read the terms first. This is not legal advice.

What is screen scraping in banking?

A third-party app logging in to online banking with the customer's own credentials and reading the account pages. Open banking APIs, required in the EU by PSD2, replace it with a limited permission the customer can revoke.

Does screen scraping need OCR?

Only when the value exists as pixels: text in an image, a chart or a remote desktop. On a web page the browser already holds the text, and innerText returned all 35 visible lines in our run.

Read the screen your customers see, from their country

Residential and mobile proxies in the country you choose, or let the Web Scraping API render the page for you.

Related reading