Extract

Extract turns a web page into structured JSON in a single request. Add extract=auto to your Fetch call, and Zenrows identifies the meaningful data on the page and returns it as clean JSON, together with the raw HTML. There are no selectors to write, no schema to define, and no parser to maintain. The extraction adapts automatically when a website changes its layout.

Extract is in Beta and works on domains Zenrows has prepared. Any active Zenrows API key can use it on those, with no extra setup needed, and you can ask for a new domain to be prepared yourself.

How Extract works

Unlike general-purpose parsing rules that apply the same logic to every website, Extract builds and maintains an extraction that’s tailored to each individual site. Zenrows analyzes a domain’s pages, identifies its meaningful data points, and keeps that extraction working as the site evolves, so you get richer and more complete fields than a one-size-fits-all approach can offer. That tailoring is per domain, so a domain has to be prepared before Extract can serve it. Any domain can be: see Domain coverage.

Basic usage

Enable Extract by adding the extract=auto parameter to your Zenrows request:

# pip install requests
import requests

url = 'https://www.scrapingcourse.com/ecommerce/'
apikey = 'YOUR_ZENROWS_API_KEY'
params = {
    'url': url,
    'apikey': apikey,
    'extract': 'auto',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.json())

// npm install axios
const axios = require('axios');

const url = 'https://www.scrapingcourse.com/ecommerce/';
const apikey = 'YOUR_ZENROWS_API_KEY';
axios({
    url: 'https://api.zenrows.com/v1/',
    method: 'GET',
    params: {
        'url': url,
        'apikey': apikey,
        'extract': 'auto',
    },
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto", nil)
    if err != nil {
        log.Fatalln(err)
    }
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

# gem install faraday
require 'faraday'

url = URI.parse('https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto')
conn = Faraday.new()
conn.options.timeout = 180
res = conn.get(url, nil, nil)
print(res.body)

curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto"

This example extracts structured data from the Scraping Course eCommerce page. Instead of raw HTML alone, you get a JSON response with the meaningful data Zenrows identified on the page, plus the original HTML for reference.

Parameters

Extract adds two parameters to a Fetch request. Every other Fetch parameter keeps working alongside them.

PARAMETER	TYPE	DEFAULT	DESCRIPTION
extract	`string`		Turns Extract on and picks the extraction mode. Accepted values: `auto`, `native`, `standard`. Use-case: Get the same field names across websites
extract_fields	`string`		Comma-separated list of the fields to return inside `parsed`, dot-notated for fields inside a group. Omit it to receive every field. Use-case: Return only the fields you need

Response

A request with extract=auto returns Content-Type: application/json with two fields:

JSON

{
  "html": "<!DOCTYPE html><html>...</html>",
  "parsed": {
    "page_context": {
      "current_page": 1,
      "results_per_page": 69,
      "total_pages": 12,
      "total_results": 188
    },
    "products": [
      {
        "name": "Abominable Hoodie",
        "price": 69,
        "currency": "USD",
        "availability": "in_stock",
        "sku": "MH09",
        "product_id": "246",
        "product_type": "variable",
        "image_url": "https://www.scrapingcourse.com/.../mh09-blue_main.jpg",
        "product_url": "https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/"
      }
    ]
  }
}

parsed contains the structured data extracted from the page.
html contains the raw HTML of the scraped page. It’s included during the beta so you can validate the extracted data against the source.

Field names are in plain English and reflect the data each website actually exposes, so different websites can return different fields for similar pages. The set of fields inside parsed stays stable across requests for a given website, and new fields may be added over time as extraction improves, so treat unknown fields as additive rather than breaking. The html field is included for validation during the beta, and the overall response shape may evolve once the beta ends, so build your data pipeline around parsed and treat html as a validation aid rather than a permanent contract.

Extraction is fully automatic, and a field is only returned when it’s present on the page. Always run test requests on your target pages and verify all the data you need is extracted before using Extract in production.

Selecting the fields you need

parsed carries every field Extract found on the page. Add extract_fields with a comma-separated list to get back only the ones your pipeline reads:

# pip install requests
import requests

url = 'https://www.scrapingcourse.com/ecommerce/'
apikey = 'YOUR_ZENROWS_API_KEY'
params = {
    'url': url,
    'apikey': apikey,
    'extract': 'auto',
    'extract_fields': 'products.name,products.price',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.json())

// npm install axios
const axios = require('axios');

const url = 'https://www.scrapingcourse.com/ecommerce/';
const apikey = 'YOUR_ZENROWS_API_KEY';
axios({
    url: 'https://api.zenrows.com/v1/',
    method: 'GET',
    params: {
        'url': url,
        'apikey': apikey,
        'extract': 'auto',
        'extract_fields': 'products.name,products.price',
    },
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto&extract_fields=products.name%2Cproducts.price"

Response

{
  "html": "<!DOCTYPE html><html>...</html>",
  "parsed": {
    "products": [
      { "name": "Abominable Hoodie", "price": 69 },
      { "name": "Adrienne Trek Jacket", "price": 57 }
    ]
  }
}

How the list is read:

A bare name selects a whole group. extract_fields=products returns every product with all of its fields.
A dot path selects inside a group, element by element. products.name returns the name of every product in the list, not only the first one.
Spaces after commas are ignored. products.name, products.price selects the same fields as products.name,products.price.
Only parsed is filtered. The html field always comes back in full.
Filtering never adds a field. Naming something the page doesn’t provide doesn’t produce an empty field, it just isn’t there.

It works the same way in every extraction mode, so a standard request can be narrowed with the canonical field names: extract=standard&extract_fields=listings.title,listings.price.

Field names come from each website, so they differ from site to site in the default mode. Send one request without extract_fields first, read the names in parsed, then pin the ones you want.

When none of the requested fields exist

A name that matches nothing is ignored as long as at least one other name in the list does match, so a typo costs you that field quietly. When no name matches, the request fails with 400 (REQS004) rather than returning an empty object, and the message lists the fields the page does offer:

Response

{
  "code": "REQS004",
  "detail": "None of the fields requested in 'extract_fields' are available for this page (requested: prize). Available fields: page_context, page_context.current_page, page_context.results_per_page, page_context.total_pages, page_context.total_results, products, products.availability, products.currency, products.image_url, products.name, products.price, products.product_id, products.product_type, products.product_url, products.sku. Adjust 'extract_fields', or omit it to receive every field this page provides.",
  "instance": "/v1",
  "status": 400,
  "title": "None of the requested 'extract_fields' are available for this page (REQS004)",
  "type": "https://docs.zenrows.com/api-error-codes#REQS004"
}

Extraction modes

The value of extract also picks which extraction resolves for the page:

Value	Extraction
`auto`	The default, and the same extraction as `native`.
`native`	The website’s own extraction. Field names follow what that site exposes, so they are as rich and as specific as the page itself.
`standard`	A canonical schema shared by every website in the same vertical. The same field names come back from every site, so pages from different websites line up without mapping.

Stay on auto unless you’re merging pages from several websites into one table, which is the job standard exists for. The trade is richness for uniformity: a native extraction returns everything a given site exposes, and a standard one returns the agreed set.

The mode is an API-level parameter. The playground in your dashboard runs the default extraction and lists standard as coming soon, so pick a mode from a direct API request or from an SDK, which passes the parameter straight through.

The difference is visible on two real-estate search pages from different websites. In the default mode, each site names things its own way, one calling floor area construction_area_m2 and the other area_sqm, one splitting the price into price and price_currency, the other into price_amount and price_currency. In standard, both return the same field names:

curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.casasyterrenos.com%2Fyucatan%2Fmerida%2Fcasas%2Fventa&extract=standard"

# pip install requests
import requests

apikey = 'YOUR_ZENROWS_API_KEY'
for url in [
    'https://www.casasyterrenos.com/yucatan/merida/casas/venta',
    'https://www.lamudi.com.mx/yucatan/merida/for-sale/',
]:
    response = requests.get('https://api.zenrows.com/v1/', params={
        'url': url,
        'apikey': apikey,
        'extract': 'standard',
    })
    listings = response.json()['parsed']['listings']
    print(url, sorted(listings[0]))  # the same field names on both sites

Response

{
  "html": "<!DOCTYPE html><html>...</html>",
  "parsed": {
    "search": {
      "location": "merida",
      "total_results": 169
    },
    "listings": [
      {
        "title": "Venta de Casa en San jeronimo en Conkal",
        "listing_type": "venta",
        "property_type": "casa",
        "price": { "value": 4500000, "currency": "MXN" },
        "bedrooms": 3,
        "bathrooms": 3,
        "living_area": 215,
        "area_unit": "m²",
        "address": "Conkal, Yucatán",
        "city": "Conkal",
        "postal_code": null,
        "latitude": null,
        "longitude": null,
        "agent_name": null,
        "image": "https://cdn.casasyterrenos.com/img_casas/26-Casas-Renta-Pueblo-Conkal-Conkal-Yucatan-3879000-SQzkaHpu.jpg",
        "listing_id": "3879000",
        "url": "/propiedad/casa-venta-conkal-pueblo-conkal-conkal-yuc-3879000"
      }
    ]
  }
}

standard currently covers real estate only, both search results and listing pages. A page in any other vertical is rejected with 400 (REQS004), so use auto or native everywhere else.

Any value other than the three above is rejected before the page is even fetched, with 400 (REQS004) and the message Invalid value "..." for 'extract' parameter. Supported values: auto, native, standard.

Domain coverage

Extract works on any domain, once that domain has been prepared: Zenrows learns the shapes of its pages and checks that extraction returns the right data. A prepared domain then works for every Zenrows API key, so coverage is per domain and never per account, and there is no allowlist to manage on your side. Many domains are prepared already, and the set grows as people ask for the sites they need.

Checking whether a domain is ready

GET /v1/extract/domains returns everything Extract serves right now:

cURL

curl "https://api.zenrows.com/v1/extract/domains?apikey=YOUR_ZENROWS_API_KEY"

Response

{
  "domains": [
    {
      "domain": "zillow.com",
      "verticals": ["Real Estate/Houses", "Real Estate/Real Estate Buying and Selling"],
      "warm": true
    },
    {
      "domain": "amazon.com",
      "verticals": ["Shopping", "Technology & Computing/Consumer Electronics"],
      "warm": true
    }
  ]
}

An integration can check this before sending a request instead of handling an error after one. See the endpoint reference for the full response.

Asking for a domain

If the domain you need isn’t there, ask for it:

cURL

curl -X POST "https://api.zenrows.com/v1/extract/prepared-domains?apikey=YOUR_ZENROWS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "domain": "example-shop.com",
    "example_urls": ["https://example-shop.com/product/blue-shirt"]
  }'

Preparation usually takes minutes. Poll GET /v1/extract/prepared-domains/{domain} until status is ready, then send your extract=auto request as normal. Example URLs are worth including: they tell Zenrows exactly which kinds of page you care about. Each account can prepare a set number of new domains per month; the endpoint reference covers how to check what’s left. If you send extract=auto for a domain that isn’t prepared, the request fails with a 403 error (REQS007) naming the domain, and the message tells you how to get it prepared. Nothing about your plan or your account changes that: preparation is per domain.

Combining with other features

Extract works on the final HTML of the page, so it combines with the scraping features you already use. For JavaScript-heavy websites, add JavaScript Rendering with a short wait so dynamic content finishes loading before extraction. For protected websites, add Premium Proxy:

# pip install requests
import requests

url = 'https://www.scrapingcourse.com/ecommerce/'
apikey = 'YOUR_ZENROWS_API_KEY'
params = {
    'url': url,
    'apikey': apikey,
    'extract': 'auto',
    'js_render': 'true',
    'wait': '3000',
    'premium_proxy': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.json())

curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto&js_render=true&wait=3000&premium_proxy=true"

When extract=auto is set, it takes precedence over other output formats. autoparse, css_extractor, response_type, and outputs are ignored on that request.

Extract vs. Autoparse vs. CSS Extractor

Method	Best for	Pros	Cons
Extract (`extract=auto`)	Any site where you want the richest data	Tailored to each website, adapts when the site’s layout changes, richer fields	The domain has to be prepared first
Autoparse (`autoparse=true`, deprecated)	Integrations already built on it	Works on any site, no setup, included at no extra cost	General-purpose rules, often returns page scaffolding rather than the data you want. Migrate to Extract
CSS Extractor (`css_extractor`)	Specific data points, single site, custom requirements	Full control, precise targeting	Requires HTML knowledge, selectors are site-specific

Pricing

Extract is free during Beta. You only pay the standard Fetch cost of the underlying request, including JavaScript Rendering or Premium Proxy if you use them.

You can monitor your Zenrows usage in multiple ways to stay informed about your account activity and prevent unexpected overages.Dashboard monitoring: View real-time usage statistics, remaining requests, success rates, and request history on your Analytics Page. You can also set up usage alerts in your notification settings to receive notifications when you approach your limits.Programmatic monitoring: For automated monitoring in your applications, call the /v1/subscriptions/self/details endpoint with your API key in the X-API-Key header. This returns real-time usage data that you can integrate into your monitoring systems. Learn more about the usage endpoint.Response header monitoring: Track your concurrency usage through response headers included with each request:

Concurrency-Limit: Your maximum concurrent requests
Concurrency-Remaining: Available concurrent request slots
X-Request-Cost: Cost of the current request
X-Key-Credits-Remaining: Lowest remaining credits across your API key’s credit caps, sent only for keys with at least one cap

Frequently Asked Questions (FAQ)

How is Extract different from Autoparse?

Autoparse (autoparse=true) applies general-purpose extraction rules that work the same way on every website, and it is deprecated. Extract (extract=auto) builds an extraction tailored to each website, which returns richer, more complete fields and adjusts itself when the website’s layout changes. Extract needs a domain to be prepared first, which you can request; see Migrate to Extract for the parameter swap.

What happens on a domain that isn't prepared yet?

The request fails with a 403 error (REQS007) naming the domain, and the message tells you how to get it prepared: POST /v1/extract/prepared-domains, then retry once it reports ready. Nothing about your plan or your account changes the outcome, since preparation is per domain.

Can I get only some of the fields back?

Yes. Add extract_fields with a comma-separated list, using dot paths for fields inside a group: extract_fields=products.name,products.price. A dot path applies to every element of a list, so that example returns the name and price of every product. Omit the parameter to receive every field the page provides.

What is the difference between the native and standard extraction modes?

extract=auto (the default) and extract=native return the website’s own extraction, so field names follow what that particular site exposes and differ from site to site. extract=standard returns a canonical schema shared by every website in the same vertical, so pages from different websites line up without mapping. standard currently covers real estate only, and modes are available on the API, not yet in the dashboard playground. See Extraction modes.

Will the extracted fields change over time?

The response shape for an enabled website stays stable. Your integration keeps receiving the same fields even as Zenrows improves extraction behind the scenes. New fields may be added over time, so treat unknown fields as additive rather than breaking.

Can I rely on the html field long term?

Treat html as a validation aid rather than a permanent part of the contract. It’s included during the beta so you can check the extracted data against the source page. Build your data pipeline around parsed, since the surrounding response shape may evolve once the beta ends.

Can I combine Extract with other Zenrows features?

Yes. Extract works alongside JavaScript Rendering, Premium Proxy, and other request options. It takes precedence over other output formats, so autoparse, css_extractor, response_type, and outputs are ignored on a request that sets extract=auto.

Get Started

Fetch

Batch

Browser Sessions

Residential Proxies (Legacy)

Guides

Extract

How Extract works

Basic usage

Parameters

Response

Selecting the fields you need

When none of the requested fields exist

Extraction modes

Domain coverage

Checking whether a domain is ready

Asking for a domain

Combining with other features

Extract vs. Autoparse vs. CSS Extractor

Pricing

Frequently Asked Questions (FAQ)

​How Extract works

​Basic usage

​Parameters

​Response

​Selecting the fields you need

​When none of the requested fields exist

​Extraction modes

​Domain coverage

​Checking whether a domain is ready

​Asking for a domain

​Combining with other features

​Extract vs. Autoparse vs. CSS Extractor

​Pricing

​Frequently Asked Questions (FAQ)

How Extract works

Basic usage

Parameters

Response

Selecting the fields you need

When none of the requested fields exist

Extraction modes

Domain coverage

Checking whether a domain is ready

Asking for a domain

Combining with other features

Extract vs. Autoparse vs. CSS Extractor

Pricing

Frequently Asked Questions (FAQ)