HowTo schema for web extraction

A HowTo schema captures an instructional guide as structured data: the name of the task, the ordered list of steps with a name and text each, how long it takes, the tools you keep using, the supplies you consume, and an estimated cost. Teams extract this to build recipe and tutorial databases, feed step-by-step content into assistants, compare instructions across sources, or turn scattered guide pages into a uniform dataset. Naming each field gives you typed records you can render, search, and validate instead of a page of HTML you still have to take apart. Guide pages are a strong fit for describing fields rather than writing CSS selectors, because no two sites mark up their steps the same way. One blog wraps each step in an ordered list, another uses headings, a third renders the whole thing with JavaScript. You describe what a step or a total time is once, and because every request runs through a real headless browser, the model reads it from the rendered page regardless of the markup. When a guide lists no tools or never states a cost, those fields come back as null instead of an invented figure, so an empty supplies list means the page truly had none, not that the extraction quietly guessed.

Fields in a HowTo schema

The fields teams most often extract for a howto, what type each one is, and whether it is usually present.

Field	Type	Required	Notes
name	string	yes	The title of the how-to guide as shown on the page, such as How to Replace a Bike Tire. This is the primary key for listing, search, and grouping guides, so it is required rather than optional.
steps	{ name: string, text: string }[]	yes	The ordered instructions, each as an object with a short step name and the full step text. Returning steps typed as a list of objects preserves order and structure so you can render or count them, instead of getting one blob of run-together text you must re-split later.
totalTime	string	optional	How long the whole task takes, ideally as an ISO 8601 duration like PT45M. Asking for a normalized duration lets you sort and filter guides by effort without parsing free-form phrasing like about an hour, and it returns null when the page states no time.
tools	string[]	optional	The reusable items needed but not used up, such as a screwdriver or a tire lever, returned as a list of strings. Kept separate from supplies so you can tell durable equipment apart from consumables when building a requirements checklist.
supplies	string[]	optional	The materials consumed while performing the task, such as a replacement inner tube or wood glue, as a list of strings. Separating these from tools lets a reader or a shopping feature know what they actually have to buy versus own.
estimatedCost	number	optional	The estimated cost of supplies as a numeric value, so you can compare guides on price and run filters or sums directly. Returned as a number rather than a currency string, and set to null when the page states no cost rather than guessing a figure.
currency	string	optional	The currency for estimatedCost as a code like USD or EUR, kept separate from the numeric amount. Having the unit explicit avoids ambiguity when you aggregate costs from guides published in different regions.
yield	string	optional	What completing the guide produces, such as 12 cookies or one repaired tire. Useful for recipe and project datasets where the result quantity matters, and returns null for guides that describe a one-off outcome.

The schema

Copy this and send it with any URL.

{
  "name": "string",
  "steps": "{ name: string, text: string }[]",
  "totalTime": "string",
  "tools": "string[]",
  "supplies": "string[]",
  "estimatedCost": "number",
  "currency": "string",
  "yield": "string"
}

Example output

Validated JSON back, matching the schema.

{
  "name": "How to Replace a Bike Tire",
  "steps": [
    {
      "name": "Remove the wheel",
      "text": "Open the brake and loosen the axle nuts or quick release, then lift the wheel out of the frame."
    },
    {
      "name": "Pry off the tire",
      "text": "Slide a tire lever under the bead and work a second lever around the rim until one side of the tire comes free."
    },
    {
      "name": "Fit the new tire",
      "text": "Seat one bead onto the rim, tuck in the inner tube, then work the second bead over by hand, avoiding the levers near the valve."
    },
    {
      "name": "Inflate and reinstall",
      "text": "Pump to the pressure printed on the sidewall, refit the wheel, and reconnect the brake."
    }
  ],
  "totalTime": "PT30M",
  "tools": [
    "tire levers",
    "floor pump",
    "wrench"
  ],
  "supplies": [
    "replacement inner tube"
  ],
  "estimatedCost": 12,
  "currency": "USD",
  "yield": "one repaired bike wheel"
}

Try this howto schema against a real page in the live demo, or read the docs to use it via the API.

HowTo schema: FAQ

How does Extracto return the steps in the right order?

You describe steps as a list of objects with a name and text, and Extracto renders the page in headless Chrome before passing the text to the model with your schema as a strict contract. The model reads the instructions in document order and returns them as an ordered array, so step three stays step three. Because the output is typed, you can render, count, or re-number the steps without re-parsing a blob of text, and the structure holds even on guides that mark up their steps with plain headings rather than an ordered list.

Why is estimatedCost a number instead of text?

Typing estimatedCost as a number means you get 12 back rather than the string about twelve dollars, so you can sort guides by cost, run filters, or sum a project budget directly. The currency travels in a separate field so the unit is never ambiguous. When a guide states no cost at all, estimatedCost returns null instead of a guessed figure, which is enforced because the JSON is validated against your schema before it is returned to you.

What is the difference between tools and supplies here?

Tools are the reusable items you need but do not use up, like a screwdriver or tire levers, while supplies are the materials consumed during the task, like an inner tube or wood glue. Keeping them in separate lists lets a reader tell what they must buy from what they already own, and lets a shopping or checklist feature treat the two differently. Either list comes back empty or null when the page names nothing, never padded with invented items.

Can Extracto extract guides from any site, including protected ones?

It works on any public guide page, including JavaScript-rendered and anti-bot-protected ones, because every request runs through a real headless browser with a managed anti-bot bypass layer and proxies handled for you. Recipe and DIY sites sitting behind Cloudflare, DataDome, or PerimeterX are covered by that managed layer with no setup on your side. The exception is login-gated content that needs session cookies, which is available on Enterprise. Respect each site's robots.txt and terms of service, and keep request volume modest.

What happens when a guide does not state a total time?

The totalTime field returns null rather than an estimated duration. That keeps your dataset honest: a null tells you the page genuinely never stated a time, so you can filter or backfill those records deliberately instead of trusting a number the model invented. When a time is present, asking for an ISO 8601 duration like PT30M lets the model normalize free-form phrasing so you can sort and compare guides by effort.