Introduction

What Tabstack is

Tabstack is a managed web API. You make one call and get back a finished result: a cited answer from live sources, clean text, matching JSON, or a completed public browser task. There is no browser fleet, proxy pool, or parsing pipeline to own or maintain.

The problem it solves

A hosted assistant is not only a model. It is a bundle: model, search, page reading, tool orchestration, citations, and interface. When you run your own model, you keep the model and the bundle is yours to rebuild.

Search is the easy part to add, and it is not the finished result. A useful web answer needs a loop: decide what to search for, search, pick promising sources, fetch and render the pages, recover readable content, judge relevance, notice what is missing, search again, reconcile claims that disagree, synthesize, and attach sources to the claims they support. Search covers one step of that. A fetcher covers two more. Your model and your application own the rest.

Running that loop through the model costs tool calls, tokens, latency, and context window, and it fails in ways that are hard to debug across the search, fetch, model, and orchestration layers. Tabstack runs the loop inside the call instead, so the model receives output rather than operating tools.

For the direct comparison, see Search versus research.

The three capabilities

Each capability turns an instruction into finished web output. Pick the one that matches what you need from the web right now.

You send	You get back	Capability
A question	A cited answer from live sources	Research
A URL	Clean text	Extract
A URL and a JSON schema	Matching JSON	Extract
A URL and instructions	Matching JSON	Generate
A public website task	The completed task	Automate

Research

Give Research a question. It plans the queries, discovers and reads sources, iterates when something is missing, and returns a synthesized answer with the sources it cited. The call streams over Server-Sent Events. Reach for it when your application needs a current answer and your users need to verify where it came from.

Endpoint: /research

TypeScript

research.ts

import Tabstack from "@tabstack/sdk";

const client = new Tabstack();

const stream = await client.agent.research({
  query: "What are the main approaches to browser automation for AI agents?",
  mode: "fast",
});

for await (const event of stream) {
  if (event.event === "error") {
    throw new Error(event.data.error?.message ?? "Research failed");
  }
  if (event.event === "complete") {
    console.log(event.data.report);
    console.log(event.data.metadata.citedPages);
  }
}

Python

research.py

from tabstack import Tabstack

client = Tabstack()

for event in client.agent.research(
    query="What are the main approaches to browser automation for AI agents?",
    mode="fast",
):
    if event.event == "error":
        raise RuntimeError(event.data.error.message if event.data.error else "Research failed")
    if event.event == "complete":
        print(event.data.report)
        print(event.data.metadata.cited_pages)

Progress events (start, iteration:start, and so on) stream first. The complete event carries the report and its cited sources:

Response (complete event)

{
  "report": "There are three main approaches...",
  "metadata": {
    "citedPages": [
      {
        "id": "src-1",
        "url": "https://example.com/browser-automation",
        "title": "Browser Automation Approaches",
        "claims": []
      }
    ]
  }
}

Read the Research guide for modes, the full event stream, and timeout strategy.

Extract

Give Extract a URL and it returns clean text. Add a JSON schema and it returns JSON that matches your schema, with proper types. Reach for it when the content you need is already on a page you can point at, and you want it usable rather than parsed by hand.

Endpoints: /extract/markdown and /extract/json

TypeScript

extract.ts

import Tabstack from "@tabstack/sdk";

const client = new Tabstack();

const result = await client.extract.json({
  url: "https://news.ycombinator.com",
  json_schema: {
    type: "object",
    properties: {
      stories: {
        type: "array",
        items: {
          type: "object",
          properties: {
            title: { type: "string" },
            points: { type: "number" },
          },
        },
      },
    },
  },
});

Python

extract.py

from tabstack import Tabstack

client = Tabstack()

result = client.extract.json(
    url="https://news.ycombinator.com",
    json_schema={
        "type": "object",
        "properties": {
            "stories": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "title": {"type": "string"},
                        "points": {"type": "number"},
                    },
                },
            },
        },
    },
)

CLI

extract.sh

tabstack extract json https://news.ycombinator.com --schema @schema.json

The response matches your schema exactly:

Response

{
  "stories": [
    { "title": "New AI Model Released", "points": 342 },
    { "title": "Database Performance Tips", "points": 156 }
  ]
}

A related endpoint, /generate/json, takes a URL plus instructions and returns matching JSON that is derived from the page rather than copied off it. See Generate.

Automate

Give Automate a task in plain language and a starting URL. An agent runs it in a managed browser, navigating, clicking, and filling forms as needed, streaming its progress over SSE. Reach for it when reading the page is not enough and you need to interact with it.

Hosted Automate works on public websites and cannot log in. For automation against a browser and model you control, see Pilo, the open-source engine.

Endpoint: /automate

TypeScript

automate.ts

import Tabstack from "@tabstack/sdk";

const client = new Tabstack();

const stream = await client.agent.automate({
  task: "Find the top 3 trending repositories and extract their names",
  url: "https://github.com/trending",
});

for await (const event of stream) {
  if (event.event === "error") {
    throw new Error(event.data.error?.message ?? "Automate failed");
  }
  // `complete` carries the result; a final `done` event then closes the stream.
  if (event.event === "complete" && event.data.success) {
    console.log(event.data.finalAnswer);
  }
}

Python

automate.py

from tabstack import Tabstack

client = Tabstack()

stream = client.agent.automate(
    task="Find the top 3 trending repositories and extract their names",
    url="https://github.com/trending",
)

for event in stream:
    if event.event == "error":
        raise RuntimeError(event.data.error.message if event.data.error else "Automate failed")
    # `complete` carries the result; a final `done` event then closes the stream.
    if event.event == "complete" and event.data.success:
        print(event.data.final_answer)

The final result arrives on the complete event:

Response (complete event)

{
  "success": true,
  "finalAnswer": "Top 3 repos: awesome-ai, web-framework, data-viz",
  "stats": { "iterations": 4, "durationMs": 12840 }
}

Limits worth knowing up front

• Hosted /automate runs on public websites only. It cannot authenticate.
• /research and /automate always stream. There is no non-streaming mode.
• Everything is hosted. There is no air-gapped deployment of the API. Pilo is the self-hosted path for automation specifically.
• Page content is cached by URL, effort, and region rather than by account. Pass nocache: true for a fresh fetch. See Data Handling.

Where to go next

• Make your first call. The Quickstart walks you from API key to a cited answer.
• Understand the distinction. Search versus research explains what Tabstack does that a search API leaves to your model.
• Go deeper on Research. The Research guide covers modes, events, and failure handling.
• Structure the output. JSON Extraction and Schema Design cover schemas in depth.
• See real use cases. The examples show full applications built on these endpoints.