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 works on any prepared domain, with any active Zenrows API key and no extra setup. You can prepare a new domain 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. You can prepare one yourself: 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 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, and the response shape around parsed may evolve, 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.

Open the dashboard

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 a 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. The exception is a site Extract is not enabled for: its REQS007 title says Extract is not enabled for the requested domain, and preparing it does not help. Use css_extractor there, or contact support to have the site enabled. 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. This request sends three product pages from the same site:

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.com",
    "example_urls": [
      "https://www.example.com/products/a",
      "https://www.example.com/products/b",
      "https://www.example.com/products/c"
    ]
  }'

Preparation takes a few minutes and costs no credits. Poll GET /v1/extract/prepared-domains/{domain} about every 30 seconds until status is ready, then send your extract=auto request as normal. The domain is the host: a leading www. is dropped, and any other subdomain is prepared on its own.

Choosing example URLs

example_urls takes 1 to 5 URLs, and they tell Zenrows exactly which pages to prepare.

One works. Extract prepares the page type it points at.
We recommend 3 or more of the same page type (e.g. 3 product pages, as in the example above), because Extract compares pages of one type to check the fields it found and fill in fields one page is missing.
Several page types can share the 5 (e.g. 3 product pages + 2 search-result pages).

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) whose title says Extract is not prepared for the requested domain, and the message tells you how to prepare it. On a prepared domain, the same error can instead have a title that says Extract did not recognise this page. That means the page may have nothing to extract, such as a home page. Try a product, article or listing page instead, retry once in a few minutes if the page should work, or use css_extractor. Preparing the domain again does not change this error. Neither request is charged, and nothing about your plan or your account changes either outcome. If Extract knows the page type but none of the fields come back filled (with extract_fields, none of the ones you asked for, as long as they exist; names that match nothing are REQS004), the request fails with a 422 error (no_data_extracted) rather than returning 200 with an empty parsed object. That request is not charged, and it doesn’t return the raw HTML.

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 currently free. 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.

Open Analytics Open notification settings

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) whose title says Extract is not prepared for the requested domain, and it isn’t charged. The message tells you how to prepare it: POST /v1/extract/prepared-domains with up to 5 example URLs, then retry once it reports ready, a few minutes later. Nothing about your plan or your account changes the outcome, since preparation is per domain.

What happens if Extract finds no data on the page?

Extract never answers 200 with an empty parsed object, and neither outcome is charged or returns the raw HTML. If the domain is prepared but Extract did not recognise this page as one it can extract, the request fails with a 403 error (REQS007) whose title says Extract did not recognise this page. Try a product, article or listing page on the same site, retry once in a few minutes if this page should work, or use css_extractor. Preparing the domain again does not change it. If Extract recognised the page but no field came back filled, the request fails with a 422 error (no_data_extracted); check that the page rendered fully (some sites need js_render=true or premium_proxy=true) and, if you use extract_fields, omit it to see whether other fields have values. Names that match nothing fail earlier, with REQS004.

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 so you can check the extracted data against the source page. Build your data pipeline around parsed, since the surrounding response shape may evolve.

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

Crawl

Batch

Browser

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

Choosing example URLs

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

​Choosing example URLs

​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

Choosing example URLs

Combining with other features

Extract vs. Autoparse vs. CSS Extractor

Pricing

Frequently Asked Questions (FAQ)