# Screen Scraping: Meaning, Example, vs API

> Screen scraping means reading data off what a program displays. We read one public page three ways (screen, HTML, API) and compare the bytes and the code.

[Home](https://quanticdata.io/) / [Blog](https://quanticdata.io/blog/) / Screen Scraping: Meaning, Example, vs API

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

Web scraping · Nov 20, 2026 · 9 min read · By [Aldo Morese](https://quanticdata.io/about/), founder of QuanticData

![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.](https://quanticdata.io/blog/screen-scraping/hero.webp?v=20261120h)

On this page

- [Screen scraping meaning: three uses of one term](https://quanticdata.io/blog/screen-scraping/#screen-scraping-meaning-three-uses-of-one-term)
- [Screen scraping vs web scraping vs API](https://quanticdata.io/blog/screen-scraping/#screen-scraping-vs-web-scraping-vs-api)
- [A screen scraping example: one page, three reads](https://quanticdata.io/blog/screen-scraping/#a-screen-scraping-example-one-page-three-reads)
- [Turning the screen back into records](https://quanticdata.io/blog/screen-scraping/#turning-the-screen-back-into-records)
- [When screen scraping is the right tool](https://quanticdata.io/blog/screen-scraping/#when-screen-scraping-is-the-right-tool)
- [Screen scraping in banking and open banking](https://quanticdata.io/blog/screen-scraping/#screen-scraping-in-banking-and-open-banking)
- [Is screen scraping legal?](https://quanticdata.io/blog/screen-scraping/#is-screen-scraping-legal)
- [Screen scraping tools, and where a proxy fits](https://quanticdata.io/blog/screen-scraping/#screen-scraping-tools-and-where-a-proxy-fits)

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.

**Run it on the free credit.** Every QuanticData account gets $2 of free API usage per month.

[Start free — $2/month included](https://quanticdata.io/signup/?utm_source=blog&utm_medium=website&utm_campaign=blog-lead&utm_content=screen-scraping) · [Explore Web Scraping API](https://quanticdata.io/web-scraping-api/)

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 used | What is read | Typical tool |
| --- | --- | --- |
| Legacy systems | The character screen of a mainframe or terminal application, field by field at fixed rows and columns | Terminal emulators, robotic process automation (RPA) software |
| Web pages | The page as a browser draws it, after its JavaScript has run | Browser automation: Playwright, Puppeteer, Selenium |
| Banking and fintech | A customer's account pages, opened by a third-party app with the customer's own login | Being 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 scraping | Web scraping (HTML) | API |
| --- | --- | --- | --- |
| Reads | What is drawn on screen | The HTML the server sends | JSON or XML made for programs |
| Needs a browser | Yes | No | No |
| Finds a value by | Visible text, element or position | Selectors on the source | Field name |
| Works when data is drawn by JavaScript | Yes | Only if the data is in the source | Yes, if the site has one |
| Bytes for 10 records in our run | 269,173 | 11,064 | 2,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

```javascript
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

```javascript
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](https://quanticdata.io/blog/cheerio-web-scraping/) and [CSS selectors and XPath](https://quanticdata.io/blog/css-selector-vs-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:

```javascript
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:

```javascript
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:

| Read | Requests | Bytes | Records | Structure you get |
| --- | --- | --- | --- | --- |
| JSON API | 1 | 2,860 | 10 | Named fields, tags as a list |
| HTML and selectors | 1 | 11,064 | 10 | Elements with classes |
| Rendered screen | 6 | 269,173 | 10 | Lines 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.

**Try it on your own targets.** Every QuanticData account gets $2 of free API usage per month.

[Start free — $2/month included](https://quanticdata.io/signup/?utm_source=blog&utm_medium=website&utm_campaign=blog-inline&utm_content=screen-scraping) · [Explore Web Scraping API](https://quanticdata.io/web-scraping-api/)

## 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](https://quanticdata.io/blog/dynamic-web-scraping-python/) and [waiting for a page to load in Playwright](https://quanticdata.io/blog/playwright-wait-for-page-load/).
- **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](https://quanticdata.io/blog/playwright-screenshot/).
- **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](https://quanticdata.io/web-scraping-api/) renders the page on our side and returns the content, and the [ready-made collectors](https://quanticdata.io/collectors/) return named fields for common sources. What happens after the read, turning text into typed fields, is [data parsing](https://quanticdata.io/blog/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.

## Is screen scraping legal?

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](https://quanticdata.io/blog/crawl-a-website-without-getting-blocked/) lists the habits that matter. This is general information, not legal advice.

## Screen scraping tools, and where a proxy fits

| Job | Tools |
| --- | --- |
| Render a web page and read it | Playwright, Puppeteer, Selenium |
| Read text out of a screenshot | An OCR engine such as Tesseract |
| Read desktop or terminal applications | RPA suites, terminal emulators with scripting |
| Parse HTML without a screen | cheerio, 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](https://quanticdata.io/residential-proxies/) place requests on home connections in the country you choose, and our [mobile proxies](https://quanticdata.io/mobile-proxies/) on carrier connections, which is the one to use when the screen you need is the mobile one.

### Sources & further reading

- [MDN: HTMLElement.innerText](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/innerText)
- [MDN: Document.elementFromPoint()](https://developer.mozilla.org/en-US/docs/Web/API/Document/elementFromPoint)
- [Playwright docs: Page.screenshot](https://playwright.dev/docs/api/class-page#page-screenshot)
- [European Commission: Payment services (PSD 2), Directive (EU) 2015/2366](https://eur-lex.europa.eu/eli/dir/2015/2366/oj)
- [Wikipedia: Data scraping, screen scraping](https://en.wikipedia.org/wiki/Data_scraping#Screen_scraping)

## FAQ

Quick answers on screen scraping.

[Something else? Ask us](mailto:hello@quanticdata.io)

### 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.

[Start free — $2/month included](https://quanticdata.io/signup/?utm_source=blog&utm_medium=website&utm_campaign=blog-end&utm_content=screen-scraping) · [Explore Web Scraping API](https://quanticdata.io/web-scraping-api/)

## Related reading

- [Web Scraping Project Ideas, Started for Real](https://quanticdata.io/blog/web-scraping-project-ideas/): Web scraping · Five web scraping project ideas, each one started for real on 20 November 2026: a price tracker, a library release dashboard, a question analysis, an open-source landscape and a topic timeline, with the code, the first run and what to build next.
- [Retry-After Header: Read It, Wait, Retry](https://quanticdata.io/blog/retry-after-header/): Web scraping · Retry-After tells a client how long to wait before the next request, as a number of seconds or as an HTTP date. Below: both formats, a Python and a Node helper we ran against a real 429 on 20 November 2026 (each waited 10 seconds and then got 200), the rate-limit headers of the QuanticData API, and how one batch job replaced 20 calls.
- [How to Use an API Key: curl, Python and JS](https://quanticdata.io/blog/how-to-use-an-api-key/): Web scraping · An API key is a secret string you send with every request so the service knows which account is calling. Nothing is installed: you add one header. Below: the same call in curl, Python, JavaScript and PowerShell, run on 20 November 2026 against the QuanticData API, the exact 401 messages for the usual mistakes, and how to keep the key out of your code.

---

Source: https://quanticdata.io/blog/screen-scraping/ · Site index for AI: https://quanticdata.io/llms.txt
