Validate extracted data with a schema

Put a schema between Zenrows and your database. Each row from Extract, css_extractor or outputs goes through a model that converts types ("$69.00" becomes 69.0, "Yes" becomes true), checks required fields, and sends any row that doesn’t fit to a flagged list for review. Your pipeline stores clean, typed data every time. Uses: Extract (extract=auto), css_extractor and outputs, with Pydantic or Zod

Ask your AI agent

With the Zenrows MCP server connected to Claude, Cursor or any MCP client, paste this prompt. Your agent picks the right Zenrows tools and settings on its own.

Use Zenrows to get every product on https://www.scrapingcourse.com/ecommerce/ with name,
price and URL. Make sure every price is a number and every URL is absolute, and list
separately any product that is missing a field.

The same prompt works for thousands of products across many pages: ask your agent to check every row the same way before it saves them.

Validate css_extractor rows

css_extractor returns each selector as a list of strings. Zip the lists into rows, then validate each row. The model trims names, turns "$1,299.00" into 1299.0, requires a positive price and an absolute URL.

# pip install requests pydantic
import json
import requests
from pydantic import BaseModel, Field, HttpUrl, ValidationError, field_validator

class Product(BaseModel):
    name: str = Field(min_length=1)
    price: float = Field(gt=0)
    url: HttpUrl

    @field_validator("name", mode="before")
    @classmethod
    def strip_name(cls, value):
        return value.strip() if isinstance(value, str) else value

    @field_validator("price", mode="before")
    @classmethod
    def parse_price(cls, value):
        # "$1,299.00" -> 1299.0; numbers pass through unchanged
        if isinstance(value, str):
            value = value.replace("$", "").replace(",", "").strip()
        return value

css_extractor = {
    "names": ".product-name",
    "prices": ".product .price",
    "links": "a.woocommerce-LoopProduct-link @href",
}
params = {
    "apikey": "YOUR_ZENROWS_API_KEY",
    "url": "https://www.scrapingcourse.com/ecommerce/",
    "mode": "auto",
    "css_extractor": json.dumps(css_extractor),
}
response = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180)
response.raise_for_status()
data = response.json()

valid, flagged = [], []
for name, price, url in zip(data["names"], data["prices"], data["links"]):
    raw = {"name": name, "price": price, "url": url}
    try:
        valid.append(Product.model_validate(raw))
    except ValidationError as error:
        flagged.append({"row": raw, "errors": error.errors(include_url=False)})

print(f"{len(valid)} valid, {len(flagged)} flagged")
print(valid[0].model_dump(mode="json"))

// npm install zod@^4
import { z } from "zod";

const Product = z.object({
  name: z.string().trim().min(1),
  // "$1,299.00" -> 1299; numbers pass through unchanged
  price: z.preprocess(
    (v) => (typeof v === "string" ? Number(v.replace(/[$,]/g, "").trim()) : v),
    z.number().positive(),
  ),
  url: z.url(),
});

const cssExtractor = {
  names: ".product-name",
  prices: ".product .price",
  links: "a.woocommerce-LoopProduct-link @href",
};
const params = new URLSearchParams({
  apikey: "YOUR_ZENROWS_API_KEY",
  url: "https://www.scrapingcourse.com/ecommerce/",
  mode: "auto",
  css_extractor: JSON.stringify(cssExtractor),
});
const response = await fetch(`https://api.zenrows.com/v1/?${params}`, {
  signal: AbortSignal.timeout(180_000),
});
if (!response.ok) throw new Error(`${response.status}: ${await response.text()}`);
const data = await response.json();

const valid = [];
const flagged = [];
data.names.forEach((name, i) => {
  const raw = { name, price: data.prices[i], url: data.links[i] };
  const result = Product.safeParse(raw);
  if (result.success) valid.push(result.data);
  else flagged.push({ row: raw, errors: z.flattenError(result.error).fieldErrors });
});

console.log(`${valid.length} valid, ${flagged.length} flagged`);
console.log(valid[0]);

# The raw rows that go into the schema
curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&mode=auto&css_extractor=%7B%22names%22%3A%22.product-name%22%2C%22prices%22%3A%22.product%20.price%22%2C%22links%22%3A%22a.woocommerce-LoopProduct-link%20%40href%22%7D"

Output (Python)

16 valid, 0 flagged
{'name': 'Abominable Hoodie', 'price': 69.0, 'url': 'https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/'}

What a flagged row looks like

A row with an empty name, a price that isn’t a number and a relative URL fails all three checks. The error names each field, so a reviewer, or your agent, knows what to fix:

Python (Pydantic)

Product.model_validate({"name": " ", "price": "Call for price", "url": "/product/blue-shirt"})

Output (trimmed)

3 validation errors for Product
name
  String should have at least 1 character [type=string_too_short, input_value='', input_type=str]
price
  Input should be a valid number, unable to parse string as a number [type=float_parsing, input_value='Call for price', input_type=str]
url
  Input should be a valid URL, relative URL without a base [type=url_parsing, input_value='/product/blue-shirt', input_type=str]

With Zod, z.flattenError(result.error).fieldErrors gives the same answer as an object:

Output (Node.js)

{
  name: [ 'Too small: expected string to have >=1 characters' ],
  price: [ 'Invalid input: expected number, received NaN' ],
  url: [ 'Invalid URL' ]
}

Validate Extract output

extract=auto already returns numbers for prices and null for fields a page leaves empty. A schema pins the fields your pipeline relies on, fills defaults (a null or missing currency becomes "USD"), and drops every other field, so new fields from Extract never break your storage. This one requires a name, a positive price, a SKU and a product URL, and saves valid and flagged rows to separate files.

# pip install requests pydantic
import json
from typing import Optional

import requests
from pydantic import BaseModel, Field, HttpUrl, ValidationError, field_validator

class Product(BaseModel):
    name: str = Field(min_length=1)
    price: float = Field(gt=0)
    currency: str = "USD"
    sku: str = Field(min_length=1)
    product_url: HttpUrl
    availability: Optional[str] = None  # null when the page doesn't say

    @field_validator("currency", mode="before")
    @classmethod
    def default_currency(cls, value):
        return value or "USD"  # null becomes "USD" too

params = {
    "apikey": "YOUR_ZENROWS_API_KEY",
    "url": "https://www.scrapingcourse.com/ecommerce/?s=jacket&post_type=product",
    "mode": "auto",
    "extract": "auto",
}
response = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180)
response.raise_for_status()
products = response.json()["parsed"]["products"]

valid, flagged = [], []
for raw in products:
    try:
        valid.append(Product.model_validate(raw).model_dump(mode="json"))
    except ValidationError as error:
        flagged.append({"row": raw, "errors": error.errors(include_url=False)})

with open("products.json", "w") as f:
    json.dump(valid, f, indent=2)
with open("flagged.json", "w") as f:
    json.dump(flagged, f, indent=2, default=str)

print(f"{len(valid)} valid, {len(flagged)} flagged")
print(valid[0])

// npm install zod@^4
import { writeFile } from "node:fs/promises";
import { z } from "zod";

const Product = z.object({
  name: z.string().min(1),
  price: z.number().positive(),
  currency: z.string().nullish().transform((v) => v ?? "USD"), // null or missing becomes "USD"
  sku: z.string().min(1),
  product_url: z.url(),
  availability: z.string().nullable().default(null), // null when the page doesn't say
});

const params = new URLSearchParams({
  apikey: "YOUR_ZENROWS_API_KEY",
  url: "https://www.scrapingcourse.com/ecommerce/?s=jacket&post_type=product",
  mode: "auto",
  extract: "auto",
});
const response = await fetch(`https://api.zenrows.com/v1/?${params}`, {
  signal: AbortSignal.timeout(180_000),
});
if (!response.ok) throw new Error(`${response.status}: ${await response.text()}`);
const { parsed } = await response.json();

const valid = [];
const flagged = [];
for (const raw of parsed.products) {
  const result = Product.safeParse(raw);
  if (result.success) valid.push(result.data);
  else flagged.push({ row: raw, errors: z.flattenError(result.error).fieldErrors });
}

await writeFile("products.json", JSON.stringify(valid, null, 2));
await writeFile("flagged.json", JSON.stringify(flagged, null, 2));
console.log(`${valid.length} valid, ${flagged.length} flagged`);
console.log(valid[0]);

Output (Python)

16 valid, 0 flagged
{'name': 'Olivia 1/4 Zip Light Jacket', 'price': 77.0, 'currency': 'USD', 'sku': 'WJ12', 'product_url': 'https://www.scrapingcourse.com/ecommerce/product/olivia-1-4-zip-light-jacket/', 'availability': None}

Normalize table rows

Rows from outputs=tables are keyed by the column headings on the page, and every value is a string. Field aliases map headings such as "Product ID" to clean names, and Pydantic turns "Yes"/"No" into booleans on its own:

Python (Pydantic)

# pip install requests pydantic
import requests
from pydantic import BaseModel, Field, field_validator

class Item(BaseModel):
    product_id: str = Field(alias="Product ID")
    name: str = Field(alias="Name", min_length=1)
    category: str = Field(alias="Category")
    price: float = Field(alias="Price", gt=0)
    in_stock: bool = Field(alias="In Stock")  # "Yes"/"No" become True/False

    @field_validator("price", mode="before")
    @classmethod
    def parse_price(cls, value):
        return value.replace("$", "").replace(",", "") if isinstance(value, str) else value

params = {
    "apikey": "YOUR_ZENROWS_API_KEY",
    "url": "https://www.scrapingcourse.com/table-parsing",
    "mode": "auto",
    "outputs": "tables",
}
response = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180)
response.raise_for_status()

rows = response.json()["tables"][0]["Content"]
items = [Item.model_validate(row) for row in rows]
print(len(items), "rows")
print(items[2].model_dump())

Output

15 rows
{'product_id': '003', 'name': 'Headphones', 'category': 'Audio', 'price': 149.99, 'in_stock': False}

Example output

The first rows of products.json from the Extract run above. Every row is typed, carries the USD default, and keeps only the schema’s fields:

[
  {
    "name": "Olivia 1/4 Zip Light Jacket",
    "price": 77,
    "currency": "USD",
    "sku": "WJ12",
    "product_url": "https://www.scrapingcourse.com/ecommerce/product/olivia-1-4-zip-light-jacket/",
    "availability": null
  },
  {
    "name": "Neve Studio Dance Jacket",
    "price": 69,
    "currency": "USD",
    "sku": "WJ11",
    "product_url": "https://www.scrapingcourse.com/ecommerce/product/neve-studio-dance-jacket/",
    "availability": null
  }
]

flagged.json holds [] for this page. Any row that fails the schema lands there with its errors, as shown in What a flagged row looks like.

Customize it

Change	How
Reject unknown fields instead of dropping them	Pydantic: `model_config = ConfigDict(extra="forbid")`. Zod: `z.strictObject({...})`
Keep every field Extract returns	Pydantic: `ConfigDict(extra="allow")`. Zod: `z.looseObject({...})`
A fixed set of allowed values	Pydantic: `Literal["in_stock", "out_of_stock"]`. Zod: `z.enum(["in_stock", "out_of_stock"])`
Fewer fields to validate	Add `extract_fields`, see Get structured JSON from any page
Validate a whole catalog	Run each Batch result through the same model, see Turn search and listing pages into JSON
Retry the pages behind flagged rows	Re-fetch those URLs with `js_render=true` and `wait_for`, see Retry failed requests

Troubleshooting

Every row is flagged on price: the price arrives in a format your parser doesn’t expect, such as "69,00 €". Print one raw value and adjust the parse_price step for that currency format.
A required field is null on many rows: the page leaves it empty, or loads it late. Make the field Optional with a default, or fetch with js_render=true and wait_for so it renders first.
URLs fail as relative: the selector returned paths such as /product/blue-shirt. Join them with the page URL (urljoin in Python, new URL(path, page) in Node.js) before validation.
Names and prices don’t line up: one card has no price, so the lists differ in length. Use extract=auto, which returns one object per item, or parse one card at a time as in Extract data with CSS selectors.

Get structured JSON from any page

Get product, listing and article fields as JSON.

Turn search and listing pages into JSON

Collect every item across every page into one dataset.

Pull tables and links from any page

Save every table on a page as CSV.

Extract data with CSS selectors

Pick exact elements with css_extractor.

Start Here

Foundations Course

Fetch Recipes

Extract Recipes

Crawl Recipes

Batch Recipes

Browser Recipes

Pipelines

Use Cases

By Surface

Production

Validate extracted data with a schema

Ask your AI agent

Validate css_extractor rows

What a flagged row looks like

Validate Extract output

Normalize table rows

Example output

Customize it

Troubleshooting

Get structured JSON from any page

Turn search and listing pages into JSON

Pull tables and links from any page

Extract data with CSS selectors

​Ask your AI agent

​Validate css_extractor rows

​What a flagged row looks like

​Validate Extract output

​Normalize table rows

​Example output

​Customize it

​Troubleshooting

​Related recipes

Get structured JSON from any page

Turn search and listing pages into JSON

Pull tables and links from any page

Extract data with CSS selectors

Ask your AI agent

Validate css_extractor rows

What a flagged row looks like

Validate Extract output

Normalize table rows

Example output

Customize it

Troubleshooting

Related recipes