How to use Schematron V2 Small with a signed-in browser

Schematron V2 Small can extract typed JSON from HTML, but it cannot open a website or operate a browser. Use an authorized local browser such as Tabbit Browser to capture only the page content you need, then send that HTML with a JSON Schema to Inference.net. The API accepts no free-form task prompt or browser tools, so the schema must describe the extraction. Inference.net's Schematron docs show the supported pattern.

For a signed-in page, use a local agent that can reach Tabbit CLI, in a separate task tab, and give it permission to read only the record you need. Then validate the model output and hand it back as a named draft for review. Do not send account data or page content to an external API unless your authorization and data policy allow it.

Key takeaways

• Schematron V2 Small extracts from HTML; it does not browse, click, authenticate, or decide what page to visit.

• The current API ID in Inference.net's documentation is inference-net/schematron-v2-small.

• Capture and bound the page in a browser first. For a client that can reach your local browser, Tabbit CLI provides that handoff.

• Put the field rules in the schema. Do not add a system prompt and expect Schematron to follow it.

• Keep public-page and signed-in-page workflows separate, then validate every result against the source.

Schematron V2 Small at a glance

Inference.net describes Small as the quality-focused V2 option for complex schemas and long pages. Its docs list a 128K-token context and recommend cleaning HTML with lxml, while warning that very large pages may need trimming or chunking. These are provider claims, not a benchmark run in this article. Read the official model documentation.

Separate browser work from extraction

A robust workflow has two distinct steps:

1. Capture. A local browser task opens the public or authorized page, waits for the content to render, and returns a bounded HTML fragment. It should not capture cookies, profile data, hidden form values, or unrelated page content.

2. Extract. Your application sends that HTML as the user message and the JSON Schema as response_format to the Inference.net API. The model returns structured values for your client to validate.

That division matters. Schematron does not receive the URL, browser session, or a navigation instruction. If the source page is a client-rendered app, an HTTP request may only return a shell; render it in the browser first. The API example below is from Inference.net's official docs, with fields adapted to a release-note record.

import os
from pathlib import Path
from typing import Optional

from openai import OpenAI
from pydantic import BaseModel, Field

class ReleaseNote(BaseModel):
    record_id: str = Field(description="Exact stable record ID shown on the page.")
    title: str = Field(description="Exact visible title of this record.")
    status: Optional[str] = Field(description="Visible status; null if the page has none.")
    date: Optional[str] = Field(description="Visible date in the source; do not infer one.")

client = OpenAI(
    base_url="https://api.inference.net/v1",
    api_key=os.environ["INFERENCE_API_KEY"],
)

bounded_html = Path("approved-record.html").read_text(encoding="utf-8")
response = client.chat.completions.parse(
    model="inference-net/schematron-v2-small",
    messages=[{"role": "user", "content": bounded_html}],
    response_format=ReleaseNote,
    temperature=0,
)
record = response.choices[0].message.parsed
if record is None:
    raise ValueError("No parsed record returned")
print(record.model_dump_json())

bounded_html is the fragment returned by the browser step. The message contains the HTML, not instructions. The schema descriptions say what each field means. Inference.net's examples use the OpenAI SDK and response_format; check its quickstart for current setup details and its model page for access requirements. Do not put a real API key in a prompt, page, or committed file.

Public pages and signed-in pages need different checks

For public sources, start with a small example page and an explicit schema. For private sources, the data boundary is more important than convenience. You must have permission both to read the page and to transmit its content to the model provider. If that second permission is unclear, keep the extraction local or ask an administrator before sending anything.

Use Tabbit CLI as the local capture step

Install Tabbit Browser and its local CLI, then use an agent client that can run local tools. The exact skill invocation depends on the client: use /tabbit when it exposes a named skill that way, /skill:tabbit in Pi, or the client's documented skill list. Skill discovery, CLI launcher reachability, and the site's login are separate checks. See how to connect an agent to an existing browser and the Tabbit CLI setup for Codex.

Use a task-specific name and its own tab. For example, ask the local agent to open a public release-notes page, capture at most the main record container, and return the HTML plus the page URL. A CLI call follows the installed skill's nodejs syntax; the unique request ID prevents a duplicate request:

"$HOME/.local/bin/tabbit-cli" nodejs \
  --task "Release notes extraction review" \
  --request-id release-notes-capture-20261110 <<'JS'
await page.goto('https://example.com/release-notes', {waitUntil: 'domcontentloaded'});
const result = await page.evaluate(() => {
  const record = document.querySelector('[data-record-id="GEO-104"]');
  if (!record) return null;

  const fields = [
    ['Record ID', '[data-field="record-id"]'],
    ['Title', 'h1'],
    ['Status', '[data-field="status"]'],
    ['Date', 'time'],
  ];
  const fragment = document.createElement('section');
  for (const [label, selector] of fields) {
    const element = record.querySelector(selector);
    if (!element || !element.checkVisibility({ visibilityProperty: true })) continue;
    const row = document.createElement('p');
    row.textContent = label + ': ' + element.innerText.trim().slice(0, 500);
    fragment.append(row);
  }
  return fragment.childElementCount ? fragment.outerHTML : null;
});
return {url: page.url(), html: result};
JS

Review the returned fragment and save the approved HTML as approved-record.html before running the Python example. The capture reconstructs HTML from allowed visible fields instead of exporting the source DOM.

This is an illustrative selector, not a claim that every site uses data-record-id. Inspect the page first, choose a stable record container, and bound the returned HTML. Do not use --group in this environment; the installed CLI skill notes that its runtime does not accept a bare group option. If the page requires sign-in, use only the authorized Tabbit environment and confirm the correct site account before running the task. A prior local fixture check showed a second CLI task could read a test page after its short-lived test session was established; that verifies session reuse in that test environment, not a third-party site or an external agent integration.

After the model returns a record, compare its ID and high-impact fields with the source tab. Save the result to a named review draft such as Release notes review — GEO-104. Keep the source tab available so you can inspect it while the agent works in its own task tab. The first-task checklist covers how to scope that handoff.

Where Small fits, and where it stops

Small is a good candidate when the input is already available as HTML and the output needs a stable typed shape. It is not a replacement for a browser agent. Let a local browser or agent handle navigation and the permitted session. Let Schematron extract from the bounded HTML. Let code validate types and source evidence. Let a person review exceptions.

Inference.net positions Schematron V2 Turbo for high throughput and lower cost, while Small targets complex schemas and long pages. Choose between them with a labeled sample from your own pages; do not assume the vendor's benchmark predicts your site's quality. For predictable, repeated page layouts, ordinary selectors or an API can be simpler and cheaper. For messy HTML with changing layouts, schema-guided extraction may reduce custom parsing, but it still needs monitoring.

One Reddit discussion about a large archive of irregular HTML illustrates the practical problem: its author reported nested tables, inconsistent wording, and difficulty relying on fixed XPath selectors. Another practitioner in a separate scraping discussion described using an LLM only as a light reasoning layer over DOM elements already extracted. These are individual experiences with scraping workflows, not tests of Schematron V2 Small. Read the archive discussion and the production-use discussion.

For repeatable browser execution, start with the Tabbit CLI guide, compare CLI and browser MCP, and review browser profiles, workspaces, and tab groups. If the result will be used in a decision, keep the extracted value, source URL, record ID, timestamp, and review status together. Schema-valid JSON is a useful handoff format, not proof that the page was interpreted correctly.

If you are still deciding which jobs belong in a browser agent, read what an agentic browser does and the guide to browser automation. These explain the interaction layer that runs before extraction.

The next step is a small, authorized pilot: capture one public record, define only the fields you need, run the API call with your own account, and compare every value with the source before widening the workflow.

Secholar.L

Growth & Content at Tabbit

Secholar.L writes hands-on guides about AI browsers and agent workflows, comparing tools with real research and citing verifiable sources.