Product data extraction
Turn public product pages into catalog records: name, price, availability, variants, ratings, and features when present on the page. One schema per page shape, not a parser per site.
schemaTurn public pages into validated JSON.
Send a URL and a supported JSON Schema. ByteKit returns the fields your app expects, with validation status and warnings when the page cannot produce a clean match.
A public product page becomes a validated record. validated: true · warnings: []
url + schema → validated jsonOne request. The exact fields your app expects.
Send a public URL and a supported object-root JSON Schema. ByteKit fetches the page, extracts the fields you defined, validates the result, and returns warnings so your system can accept the object or handle a clean miss.
POST /v1/schema REQUEST
{
"url": "https://acme.store/jacket",
"schema": {
"type": "object",
"properties": {
"title": { "type": "string" },
"price": { "type": "number" },
"availability": { "type": "string" },
"features": {
"type": "array",
"items": { "type": "string" }
}
}
}
} 200 OK application/json
{
"data": {
"title": "Waterproof Jacket",
"price": 49,
"availability": "In stock",
"features": [
"Breathable 3-layer fabric",
"Two zip pockets"
]
},
"validated": true,
"warnings": [],
"model": "bytekit-extract-1",
"metrics": { "fields": 4, "filled": 4 },
"scrape": { "status": 200 }
} validated: true · warnings: []
The extracted object is returned in data, wrapped alongside
validated, warnings,
metrics, model, and the underlying
scrape metadata.
Billed as a fixed credit charge per request plus the source page bandwidth. The extracted object is validated against your schema before it is returned.
what schema is forKnown fields, pulled from public pages.
Reach for /v1/schema when your app needs fields, not a blob of
page content.
Competitive intelligence
Read pricing, plan, and feature pages into comparable fields. The validation state and source URL travel with each record, so your team knows what was extracted and what needs review.
Content and metadata normalization
Pull predictable fields from articles, docs, listings, and profiles: title, author, publish date, company, category, or canonical URL. Use /scrape for full content; use /v1/schema for the structured layer.
App workflows and data pipelines
Populate internal records straight from public URLs. When a page has no schema-valid object, ByteKit returns warnings instead of pretending the extraction succeeded.
schema vs scrapePick the endpoint by what you need back.
Both take a public URL. They differ in the shape of the response.
/scrape page content
The page itself, cleaned and ready to store or feed a model.
- markdown
- html and rawHtml
- links and images
- source metadata and context
/v1/schema known fields
The specific fields you asked for, checked against your schema.
- validated JSON in a data envelope
- extraction status and metrics
- warnings
- clean misses (null, not invented)
supported scopeA focused JSON Schema subset.
Enough of the specification to describe a clean record, and no more.
Supported schema subset
Object root
Properties
Required fields
Arrays and items
Enums
Supported internal references
Descriptions, titles, and defaults where useful
Not supported
Full JSON Schema
Arbitrary browser automation
Logged-in workflows
Cookies and custom headers
Selector waits and delays
Schema monitoring
Direct bulk schema items
honest outputA clean miss beats an invented answer.
The endpoint is designed for public pages and honest structured output, not guessing.
A clean miss is explicit
When the page does not contain a schema-valid object, the response returns data: null, validated: false, and warnings explaining what could not be found.
Missing values can be null
Unclear or absent fields are represented honestly as null. The endpoint does not invent a value to fill the shape.
Built for public pages
It is designed for public pages and honest structured output. It is not a guessing engine and not a browser-automation tool.
200 OK · no clean match application/json
{
"data": null,
"validated": false,
"warnings": [
"price not found on page",
"availability could not be determined"
]
} page retrieved · object not produced
faq
What is /v1/schema?
/v1/schema turns a public web page into a validated JSON object that matches the fields your application expects. Send a URL and a supported JSON Schema; the response includes the extracted data plus a validation state.
When should I use /v1/schema instead of /scrape?
Use /scrape when you need page content: markdown, HTML, links, images, or source context. Use /v1/schema when you already know the fields you want back, such as product name, price, or availability.
What JSON Schema features are supported?
A focused subset for structured extraction: object roots, properties, required fields, arrays and items, enums, supported internal references, and descriptive metadata. Full JSON Schema is not supported.
What happens when a field is missing?
Missing or unclear values are returned as null rather than invented, and a warning explains what could not be found. That keeps downstream workflows trustworthy.
What happens if no valid object can be produced?
The response returns data: null, validated: false, and warnings describing why the page was retrieved but could not produce a schema-valid object.
Does it work with dynamic or logged-in pages?
/v1/schema targets public pages. It does not support cookies, custom headers, selector waits, delays, logins, or arbitrary browser automation.
How is schema extraction priced?
It is billed as a fixed credit charge per request plus the source page bandwidth. Test real URLs before committing to a plan. Rates are shown in the pricing section above.
pricingSame API on every plan. Pay for what you use.
Schema is billed as a fixed credit charge per request plus the source page bandwidth. Every plan supports the same API — start on PAYG with a one-time free balance, then pay for usage.
| PAYG free balance | 50 MB + 100 credits |
| PAYG bandwidth | $8 / GB |
| Monthly plans | from $29 / mo |
| Cache hits · failed | 50% · $0 |
Try schema extraction on a real URL.
Create a free API key and send one public page through /v1/schema.
The useful test is the page your product actually depends on.