Email scraper API

Company data · v1.2.0 · site_contacts

$0.02 / site

$20.00 / 1K · pay per delivered site

The email scraper API takes up to 20 domains and returns one contact record per site: every email, phone number, social profile and postal address published on the homepage and its contact, about and legal pages — with the list of pages each record was built from. $0.02 per delivered site.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.02 per delivered site · $2 free every month · Failed runs never billed

What it does

What an email scraper API does

An email scraper API reads a website the way a person looking for the contact page would, and returns what it found as one structured record per domain. Not a guessed pattern, not a purchased list: the addresses the company itself publishes.

For each domain it loads the homepage, follows the site’s own links to contact, about and legal pages — falling back to the sitemap when the navigation hides them — and merges every email, phone, social profile and postal address it sees across mailto: and tel: links, JSON-LD Organization and LocalBusiness blocks, and visible page text. Deduplicated, one row per site.

You control the depth with max_pages (1–8), and status tells you whether a site was read, was unreachable or blocked us. Don’t have the domains yet? The lead scraper API starts from a trade and a city instead; want the whole company profile rather than the contacts, use the company data API.

Inputs

Inputs: a list of domains

Domains or full URLs, up to 20 per call. Invalid entries are rejected by validation before any page is fetched.

Input	Type	Required	What it does
`domains`	string[]	yes	Up to 200 domains or site URLs — "example.com", "https://example.org".
`max_pages`	integer	no	1–8, default 4: homepage plus up to N−1 contact-ish pages per site.
`country`	string	no	Proxy exit geo — useful for sites that serve different content per region.
`max_results`	integer	no	1–20, default 20 — the number of sites delivered, and billed.

Outputs — 14 fields, one row per site

What comes back for every domain

One record per site, ten published fields, versioned — including how many pages were actually read.

Field	Type	What it holds
`domain` · `url`	string	Registrable host (no www) and the homepage URL fetched.
`site_name`	string	og:site_name, JSON-LD name, or the page title.
`emails`	string[]	Distinct emails found across the scanned pages.
`phones`	string[]	Distinct phone numbers found.
`socials`	object	Facebook, Instagram, LinkedIn, X, YouTube, TikTok URLs.
`addresses`	string[]	Postal addresses from JSON-LD when present.
`contact_pages`	string[]	Contact/about/legal pages that were scanned.
`pages_scanned`	integer	How many pages were fetched for this domain.
`status`	string	ok · unreachable · blocked.
`domain`	string	Registrable host (no www).
`url`	string	Homepage URL fetched.
`description`	string · nullable	The site's own meta description.
`language`	string · nullable	Language of the homepage.
`vat_id`	string · nullable	Italian VAT number (Partita IVA) printed on the scanned pages, check digit verified.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/site_contacts/run.

# contacts for two domains, up to 4 pages each
curl https://api.quanticdata.io/v1/scraper/collectors/site_contacts/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "domains": ["quantumproxies.io", "quanticdata.io"],
        "max_pages": 4 }'

import requests

BASE = "https://api.quanticdata.io/v1/scraper/collectors"
H = {"Authorization": f"Bearer {KEY}"}

domains = ["example.com", "example.org", "example.net"]
r = requests.post(f"{BASE}/site_contacts/run", headers=H,
    json={"domains": domains, "max_pages": 6})

for site in r.json()["data"]["results"]:
    print(site["domain"], site["status"],
          site["emails"], site["socials"].get("linkedin"))

const BASE = "https://api.quanticdata.io/v1/scraper/collectors";
const h = { Authorization: `Bearer ${process.env.QD_API_KEY}`,
            "Content-Type": "application/json" };

// more than two domains → async, poll the run
const start = await (await fetch(`${BASE}/site_contacts/run`, {
  method: "POST", headers: h,
  body: JSON.stringify({ domains: batchOf20, max_pages: 4 })
})).json();

const done = await fetch(`${BASE}/runs/${start.data.run_id}`,
                         { headers: h });
console.log((await done.json()).data.results.length, "records");

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, from the agent:
run_collector  slug="site_contacts"
               input={ "domains": ["example.com"],
                       "max_pages": 4 }

Example response

POST /v1/scraper/collectors/site_contacts/run

$ curl $QD/site_contacts/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{ "domains": ["example.com", "example.org"],
          "max_pages": 4 }'
{ "status": "done", "count": 2,
  "results": [
    { "domain": "example.com",
      "site_name": "Example Ltd",
      "emails": ["[email protected]", "press@…"],
      "phones": ["+1 555…"],
      "socials": { "linkedin": "https://…" },
      "contact_pages": ["https://example.com/contact"],
      "status": "ok" } ],
  "cost": 0.04 }
# 2 sites × $0.02 · unreachable sites are not billed

Try it

Site contacts, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

Email scraper API: from domains and max_pages, QuanticData reads the company website and returns one row per site with site_name, domain and pages_scanned, at $0.02 per delivered site. — You send domains and country; the run goes out through a residential exit and comes back as sites with domain, site_name and pages_scanned — 10 fields on every row — and you are billed $0.02 for each site actually delivered, nothing for a run that delivers none.

$0.02 / site100 sites on the free $2 every month

Up to 200 domainsin a single call, one record each

Contact pages foundfrom the site’s own links, sitemap as fallback

Provenance keptcontact_pages shows where the values came from

Pricing

What contact extraction costs

A delivered site record is $0.02, however many pages it took to build it. Enriching 1,000 domains is $20 at list price and less on a volume tier; the free $2 covers about 100 sites every month, and unreachable domains are not billed.

$0.02per delivered site$20 per 1,000 delivered sites

100 siteson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people run it for

Anywhere a list of domains needs to become a list of ways to reach someone.

CRM enrichment

Push your account domains through in batches of 20 and fill the blank contact fields with values you can trace — contact_pages means a stale record can be re-checked instead of trusted.

Partner and vendor research

A due-diligence pass over a list of suppliers: who publishes a real address, a phone, a company page, and who publishes nothing at all.

Outreach lists you already sourced

You have the domains from a directory or an export; this turns them into contactable rows without a per-seat prospecting tool.

Agent workflows

Give an agent the MCP server and it can go from "who makes this product" to a contact record in two tool calls, with the sources attached.

Collector vs email finders vs your own crawler

Three ways to get contacts from a domain, and what each of them is actually doing.

	Email finder databases	Your own crawler	This collector
Source of the data	a stored database, sometimes guessed patterns	whatever you crawl	the site’s own live pages
Freshness	as fresh as their last crawl	as fresh as your last run	read at request time
Provenance	rarely exposed	yours to log	`contact_pages` on every record
Beyond email	often extra credits	more parsing	phones, socials and addresses included
Billing	monthly credits that expire	proxy and compute burn	$0.02 per delivered site

What people search for

Live autocomplete demand around Site contacts, pulled with our own Keyword ideas collector.

Front door, not a named person

Email-finder services answer "what is this named person's address at this company", usually by pattern inference plus verification against previously seen addresses. That is a hard problem and worth paying for when you need a specific individual.

This answers a different question: what contact details does this organisation publish. The switchboard, the general inbox, the registered address — the front door. For SMBs and any company without a public org chart the front door is often the only door, and it is the address the company chose to publish, which is a materially different position from an inferred personal one.

Limits, provenance and the legal bit

Up to 200 domains per run, one merged record per domain rather than one row per contact. The crawl follows the site's own links to contact, about and legal pages with the sitemap as fallback — which is why the mandatory disclosure pages common in several European countries are found, where a crawler guessing /contact misses them entirely. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

Priced per site rather than per page, so raising max_pages improves coverage without changing the bill. contact_pages and pages_scanned make every record auditable — a thin result is explainable rather than mysterious.

Collecting contacts a company publishes on its own site is generally lawful in most jurisdictions and is about as consent-adjacent as public data gets. Using them for unsolicited marketing is governed independently by GDPR, PECR, CAN-SPAM and CASL, and a named individual's address is personal data even on a corporate site in a way a general inbox largely is not. None of this is legal advice — get some for your actual use case.

Email scraper API: the POST to the site_contacts collector, 20 sites delivered and the bill, 20 × $0.02 = $0.40 in usage.cost_usd; zero sites would cost $0. — The same call you would paste into a terminal: a Bearer key, domains, max_pages and country in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many sites arrived and usage.cost_usd is $0.40, which is 20 × $0.02. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

The questions that come up around extracting emails from websites — legality included.

Something else? Ask us

How do I extract emails from a website?

Send the domain to the site_contacts collector. It loads the homepage, finds the contact, about and legal pages from the site’s own links (sitemap as a fallback), and returns every email, phone, social profile and postal address it found, with the list of pages used.

Is scraping emails from websites legal?

Reading pages a company publishes openly is generally lawful in most jurisdictions, but a personal address like [email protected] is personal data under the GDPR and similar laws, and sending unsolicited email is regulated separately from collecting it. Have a lawful basis, honour opt-outs and take proper legal advice.

Does it guess or verify email addresses?

Neither. It returns only addresses actually published on the pages it read — no pattern guessing like first.last@domain, and no deliverability check. If you need verification, run the output through a dedicated validation service afterwards.

How many domains per call?

Up to 20 per run. One or two domains answer inline; more go asynchronous with a run_id to poll, since each domain means several real page loads. Billing is per delivered site record, not per page fetched.

What happens with sites that block us?

The record comes back with status: blocked or unreachable, and a run that delivers nothing is not billed. Requests go through our residential network with bounded retries, so a temporary block is retried internally at our cost, not yours.

How is this different from the lead scraper?

This one starts from domains you already have, at $0.02 per site with deeper page coverage. The lead scraper API starts from a keyword and a city — it finds the businesses first, then enriches them — at $0.01 per lead with a lighter scan per site.

Why one record per domain instead of one per contact?

Because the question is about the organisation. Everything found across every page scanned is merged into arrays on a single record, which is the shape an enrichment pipeline wants — one join key, one row, no fan-out to collapse later.

What if the contact is behind a form or in an image?

It will not be found, and the record will say so: pages_scanned and contact_pages show exactly what was read. An honest empty result is more useful in a pipeline than a guessed address that bounces.

Start with the Email scraper API

$0.02 per delivered site, $20 per 1,000 delivered sites. $2 of free credit every month, no card — and a run that delivers nothing is never billed.

Run in dashboard

Illustration: three coloured zones of the page that is read (Company website) turn into clean JSON with the fields site_name, domain and pages_scanned.