# Tabstack: Full Content > Web browsing infrastructure for AI systems. Tabstack gives agents finished output from every web interaction: structured data, cited research answers, and completed browser tasks, each from a single API call. Built by Mozilla, with ephemeral processing, no model training on your data, and robots.txt compliance by default. This is the expanded version of https://tabstack.ai/llms.txt, with full product descriptions and complete blog post content. # Products ## Structured Data Extraction URL: https://tabstack.ai/structured-extraction Define a schema, pass a URL, and get back JSON that matches. No parsing code, no downstream LLM call, no extraction layer to maintain. Endpoints: /extract/json, /extract/markdown, and /generate/json. ## Autonomous Research URL: https://tabstack.ai/web-research Run a research agent with cited answers in a single API call. Live-web sourcing, multi-source synthesis, and SSE streaming, without building or maintaining a research pipeline. Endpoint: /research. ## Browser Automation URL: https://tabstack.ai/browser-automation Automate the web without running browser infrastructure. Navigation, clicks, forms, and multi-step flows on JS-heavy pages, in one API call. Endpoint: /automate. # Documentation - [Agent quickstart](https://tabstack.ai/agents.md): Everything an agent needs for a first API call: base URL, auth, and a runnable example for every endpoint, in clean markdown. - [Documentation](https://docs.tabstack.ai/): Guides, API reference, and SDK quickstarts. - [TypeScript SDK](https://docs.tabstack.ai/sdks/typescript/quickstart/): Install and call Tabstack from TypeScript. - [Python SDK](https://docs.tabstack.ai/sdks/python/quickstart/): Install and call Tabstack from Python. - [MCP](https://docs.tabstack.ai/getting-started/mcp/): Use Tabstack as an MCP server in any agent. # More - [Pricing](https://tabstack.ai/#pricing): Individual, Team, and Pro plans starting at $0/month, with free credits to start. - [Pilo on GitHub](https://github.com/mozilla/pilo): Open-source browser engine behind Tabstack automation; self-hostable. # Blog ## Introducing Schema Source: Programmatic Blueprinting for Web Data Extraction URL: https://tabstack.ai/blog/introducing-schema-source-web-data-extraction Date: 2026-06-26 Building schemas for AI web scraping is tedious. We built Schema Source, an independent API that instantly reverse-engineers any webpage to generate a production-ready JSON schema. Learn how to combine it with Tabstack to automate programmatic blueprinting, extraction, and data transformations with zero manual config. We built **Tabstack** to replace traditional parsing configurations with a declarative model. Instead of telling a scraper *how* to navigate a page, you define *what* data you want using a JSON schema, and our `/extract/json` and `/generate/json` endpoints handle the execution. Schema-first extraction bypasses structural web shifts, but introduces a predictable bottleneck: **manual schema design**. Manually building a valid, production-grade JSON schema for a complex web page is tedious. It requires inspecting the DOM, identifying data hierarchies, mapping out types, and writing detailed string descriptions so the underlying LLMs understand the context of each field. To automate this setup phase, we built [**Schema Source**](https://schema.tabstack.ai?utm_source=tabstack.ai&utm_medium=blog&utm_campaign=blog_post&utm_content=schema_intro). ## **What is Schema Source?** **Schema Source** is an independent API that reverse-engineers a webpage's visual and semantic layout to instantly generate a structured data schema. Pass a URL via a raw `GET` request to instantly retrieve a structured JSON blueprint. For example, if you point it at a content-heavy community page like `https://reddit.com/r/nba`, Schema Source analyzes the page components and automatically outputs an optimized JSON schema mapping the posts, metrics, and metadata. You can then pass this schema directly into Tabstack's extraction pipelines to begin pulling live data immediately. ## **How Schema Source Fits into the Tabstack Workflow** In a schema-first architecture, **object descriptions act as system prompts**. If your schema has a field called score, an LLM needs to know if that means a sporting event's box score, a user upvote count, or a sentiment rating. Schema Source handles this contextual work by generating explicit metadata alongside the data types. ### **Step 1: Bootstrapping the Schema via Schema Source** To generate a structural baseline for a target page, append your target URL directly to the Schema Source endpoint: ```ts async function generateSchema(url) { const res = await fetch( `https://schema.tabstack.ai/get/${encodeURIComponent(url)}?format=json`, ); const { schema } = await res.json(); return schema; } ``` The API analyzes the target page and returns a clean, production-ready JSON schema tailored to its core data elements: ```json { "type":"object", "properties":{ "posts":{ "type":"array", "description":"List of popular posts on Reddit's front page", "items":{ "type":"object", "properties":{ "title":{ "type":"string", "description":"The title of the Reddit post" }, "author":{ "type":"string", "description":"The username of the post's author" }, "score":{ "type":"number", "description":"The score (upvotes) of the post" }, "comment_count":{ "type":"number", "description":"The number of comments on the post" }, "permalink":{ "type":"string", "description":"The direct link to the Reddit post discussion page" }, "published_at":{ "type":"string", "description":"The timestamp when the post was published" } }, "required":[ "title", "author", "score", "comment_count", "permalink", "published_at" ] }, "maxItems":10 } }, "required":[ "posts" ] } ``` ### **Step 2: Running a Direct Extraction with Tabstack** Deploying the schema into a production pipeline requires zero manual layout configuration. Pass the generated schema directly into the official `@tabstack/sdk` to execute a literal data extraction. ```ts import Tabstack from '@tabstack/sdk'; const client = new Tabstack({ apiKey: process.env.TABSTACK_API_KEY }); const url = 'https://reddit.com/r/nba'; const json_schema = await generateSchema(url); async function extractLiteralData() { const response = await client.extract.json({ url, json_schema, }); console.log('Extracted Data:', JSON.stringify(response.data, null, 2)); } ``` ### **Step 3: Layering AI Transformation with generate.json** If your pipeline requires transforming, filtering, or analyzing data rather than just mirroring what is literally on the page, you can use the exact same schema with Tabstack's `/generate/json` endpoint. While `/extract/json` returns literal data from the DOM, generate allows you to pass custom prompt instructions (like summarization or synthesis) while guaranteeing the engine wraps those modified results perfectly inside your schema structure: ```ts async function extractAndTransformData() { const response = await client.generate.json({ url, json_schema, instructions: "Filter out any threads that aren't about live game updates. For the remaining posts, rewrite the title to be a strictly objective 5-word summary.", }); console.log('Transformed Data:', JSON.stringify(response.data, null, 2)); } ``` ## **Decoupling Configuration from Execution** We decoupled Schema Source to isolate structural data discovery from production data ingestion pipelines. This architecture eliminates the need to manually draft schemas or guess layout hierarchies during the initial development cycle. Teams can use Schema Source programmatically to seed baseline data definitions, then rely entirely on Tabstack’s infrastructure to fetch, parse, and validate those payloads at scale. Try generating your first schema at [schema.tabstack.ai](https://schema.tabstack.ai?utm_source=tabstack.ai&utm_medium=blog&utm_campaign=blog_post&utm_content=schema_cta). --- ## Hardening AI Web Agents: How We're Securing Tabstack Against Indirect Prompt Injection URL: https://tabstack.ai/blog/securing-ai-agents-indirect-prompt-injection Date: 2026-06-12 Following a disclosure from Brave, we patched an indirect prompt injection vulnerability in our automation endpoint. This report details the original exploit behavior and the new isolation boundaries added to the Mozilla Pilo engine. At Mozilla, we believe that building a useful AI ecosystem requires radical transparency, especially when it comes to security. Recently, security researchers at Brave reached out to us regarding an Indirect Prompt Injection (IPI) vulnerability they identified in Tabstack's `/v1/automate` endpoint, which they have since detailed in their public blog post on the flaw. Because Tabstack is built to act as an autonomous web agent that can browse, click, and interact with the live web on behalf of a user, the implications of IPI are a critical design challenge. The vulnerability has been patched, and the fix was independently verified by the Brave team before their public write-up. We want to share a transparent look at the exploit, how our model handled it, and the architecture we've implemented to harden our automation engine against this entire class of attacks. ## The Vulnerability: Bypassing the Scope of the Task The attack discovered by Brave highlights the unique risks associated with "agentic" AI tools. During a controlled test, researchers passed a standard, routine prompt to the `/v1/automate` endpoint: "Summarize this page." However, the target page contained hidden, malicious instructions (rendered in white-on-white text, invisible to a human but fully readable in the page's text layer ingested by the AI). The injected text instructed the model to ignore its previous task, grab the user's full conversation history, paste it into an external web form, and hit submit. Because Large Language Models mix user intent and third-party data into a single, flat text window, Tabstack didn't view this as a security conflict. Instead, it confidently followed the instructions step-by-step: 1. Navigated away from the target page to an external domain. 2. Copied the user's conversation context. 3. Submitted the form, actively exfiltrating the data to the researcher's server. When we analyzed the agent's internal reasoning traces, the challenge became even clearer. The model wasn't "tricked" or confused; it was executing what it genuinely believed to be a legitimate workflow continuation. ## How We Fixed It: Moving Beyond a Flat Context Prompt injection is a dynamic, shifting threat vector across the entire AI industry. While it is functionally impossible to guarantee any LLM is 100% immune to prompt injection, we can severely limit an agent's ability to act on malicious inputs. That was our north star: assume the model will occasionally be fooled by injected text, and make sure that being fooled cannot translate into exfiltrated data. Following the disclosure, our engineering team confirmed the gap and shipped a series of changes to our underlying browser automation engine, Mozilla Pilo. Rather than trying to detect malicious prompts (a losing game of pattern-matching), we focused on shrinking the agent's "blast radius" with structural guardrails that hold regardless of what the page says. ### A Structural Action Firewall for Forms The core of the fix is a new action firewall that sits between the agent's decisions and the browser's execution of them. Critically, it does not work by scanning text for "suspicious" instructions. Instead, it classifies every form interaction using DOM field metadata and reference provenance: where a value came from, what kind of field it is targeting, and whether a human ever approved it. - The agent is free to fill operational controls it legitimately needs to do its job (search boxes, date pickers, range sliders, comboboxes). - It is structurally blocked from auto-filling freeform or sensitive fields, and from submitting any form that contains agent-filled data that was never approved, before the action reaches the browser. - Even operational submissions are now restricted to the same host as the current page. An attacker page can label its collector field as a "search box," but it cannot make the agent submit that data to an attacker-controlled domain. Unknown page hosts fail closed. When a block fires in non-interactive mode, the CLI prints a remediation footer explaining how to proceed. That footer is user-facing only: the model never sees it, so injected page content cannot instruct the agent to talk the user into disabling the firewall. ### External Content Isolation We also closed the more fundamental gap that made the original exploit possible: the agent treated web-page text and user instructions as one undifferentiated stream. Web-sourced content returned by the agent's tools (page extracts, fetched markdown, search results, even the completion validator's own feedback) is now wrapped in explicit `` tags at the point the data enters the conversation, with an inline warning on every block and a matching directive in the system prompt. This mirrors the trust-framing we already applied to raw page snapshots, so untrusted page text is consistently delineated from the user's actual task. This wrapping is structural, not learned: the boundary is enforced by how we construct the context, not by hoping the model "decides" to distrust the right paragraph. The same change also clips stale external content out of conversation history after a turn, which incidentally shut down a cost-amplification angle of the same attack. ### Caller-Controlled Trust Boundaries, Now Per Request Some legitimate workflows genuinely need the agent to enter data into third-party forms. Rather than weaken the firewall globally, we exposed explicit, opt-in trust controls: - **`trustedHostnames`:** A caller-supplied allowlist that bypasses the fill and submit gates, but only when the current page host and every form-action target (including submitter `formaction` overrides) are all on the list. - **`unsafeMode`:** A deliberate, fully-documented global opt-out, with prominent data-risk warnings on every surface. - A caller-provided start URL is treated as consent to interact with that specific site, but planner-chosen or agent-navigated URLs are not, since those are influenced by the model and the page. Originally configured via local environment variables and core configuration files, we have exposed these parameters directly to our automation engine's request layer. This allows the Tabstack API to pass `trustedHostnames` and `unsafeMode` dynamically inside the request body, establishing strict trust boundaries per request rather than per deployment. ### Defense in Depth Alongside the firewall and content isolation, we tightened how the agent reports completion. A new data-grounding rule requires every value the agent returns to trace back to a page snapshot, tool result, or task input (no filling in answers from the model's own training), backed by a pre-completion verification checklist. We also wired the completion validator's conversation history and outcome into the agent loop, and hardened the agent against getting stuck repeating injected actions across changing element references. ## The Responsible Disclosure Timeline We are incredibly grateful to the Brave research team for their clean, professional coordination on this bug. Their outreach allowed us to identify, patch, and verify a critical gap before it could ever affect users in production. - **May 13, 2026:** Brave reports the IPI vulnerability to the Mozilla Tabstack team. - **May 14, 2026:** Mozilla engineers review the traces, confirm the vulnerability, and begin engineering defenses. - **June 1, 2026:** Mozilla deploys the updated Pilo browser engine changes, and the Brave team independently verifies the fix. Securing autonomous web agents is one of the most complex engineering challenges in AI right now. By treating third-party web content as inherently untrusted, creating structural boundaries, and cutting off the pathways for unauthorized data exfiltration, we are building a safer foundation for agentic workflows. We will continue to harden Tabstack out in the open, and we welcome the global security community's continued scrutiny. --- ## Upgrading Pilo to Support Human-in-the-Loop Browser Automation URL: https://tabstack.ai/blog/pilo-interactive-mode Date: 2026-04-16 What happens when an AI web agent needs context it does not have? With Pilo Interactive Mode, it no longer has to guess or fail. This new beta feature lets Pilo pause its reasoning loop, ask the user or a parent agent for the missing data, and seamlessly complete the task. When we open-sourced Pilo, our goal was to provide a robust execution engine for AI web agents capable of navigating the chaos of the modern web. By leveraging the accessibility tree and intelligent reasoning loops, Pilo handles complex browser orchestration reliably. But autonomous execution has a hard limit: missing context. Today, we are excited to introduce **Interactive Mode (Beta)** for Pilo. This new feature allows the Pilo agent to pause its execution loop and ask the caller, whether that is a human user or a parent agent, for the specific information it needs to complete a task. ## The Problem of Missing Context In traditional web automation, agents are expected to operate entirely on their own once given a prompt. But what happens when an agent encounters a step that requires specific, localized knowledge? Imagine giving an agent the prompt: *"Sign up for the mozilla newsletter."* The agent can successfully generate a plan, navigate to the Mozilla website, locate the newsletter signup page, and identify the required input fields. But when it tries to submit the form, it hits a roadblock: it doesn't know your email address or your subscription preferences. Previously, this would result in a failed task or a hallucinated input. The agent was trapped in a silo, unable to request the missing piece of the puzzle. ## Enter Interactive Mode Interactive Mode transforms Pilo from a purely autonomous executor into a collaborative agent. Instead of failing when it lacks information, Pilo can now dynamically halt its loop and prompt the caller for guidance. For our first iteration of Interactive Mode, we are focusing specifically on form completion. When Pilo encounters a form requiring personal data, credentials, or preferences it doesn't possess, it will output a request for input. Once the caller provides the missing information, Pilo directly injects it into the form and resumes the agentic loop to complete the task. ## How It Works Across the Stack Interactive Mode integrates deeply into Pilo's core execution engine rather than relying on the LLM to decide when to ask for help. When Pilo encounters a form, it uses a "fill gate" mechanism to inspect the required fields. If it detects that user input is needed, Pilo bypasses the LLM entirely to pause task execution and request the data. Because Pilo can be run in several different environments, we designed the interactive feedback loop to adapt to how you are using it: * **Pilo Core:** When you are building directly on top of the Pilo library, the core engine expects a simple callback function. When the execution loop pauses, it triggers your callback with the required fields, waiting for your application logic to return the necessary data before resuming. * **Pilo CLI:** For developers testing locally, the Pilo CLI handles this automatically. When the core requests information, the CLI pauses the terminal output and interactively prompts the user for the missing fields right in the console. * **Pilo Server:** For remote execution, the Pilo Server emits an `interactive:form_data:request` event containing the full field data. It utilizes a dedicated WebSocket endpoint (`/pilo/run`), enabling real-time, bidirectional communication to exchange user data while the task is suspended. Furthermore, Pilo captures form validation states directly within its ARIA tree snapshots. If a user submits an invalid email, the agent detects the field error in the snapshot and will automatically trigger a re-prompt for the corrected information. ## Seeing it in Action with Tabstack The Tabstack **/automate** endpoint is built directly on top of the Pilo Server. This means you can test the WebSocket-driven Interactive Mode today using the Tabstack SDK. Here is what it looks like to catch those interactive requests and supply the missing context: ```python from tabstack import Tabstack # Initialize the Tabstack client client = Tabstack( api_key="YOUR_TABSTACK_API_KEY", ) # Start a task with Interactive Mode enabled stream = client.agent.automate( task="signup for the mozilla newsletter", interactive=True, ) # Listen for events in the stream for event in stream: print(event) # Catch the specific event where the agent asks for form data if event.event == "interactive:form_data:request": request_id = event.data.get("requestId") fields = event.data.get("fields", []) print(f"\n--- Interactive input requested (requestId: {request_id}) ---") field_values = [] # Dynamically prompt the user for the missing fields for field in fields: ref = field.get("ref", "") label = field.get("label", "") required = field.get("required", False) prompt = f" {label}{'*' if required else ''}: " value = input(prompt) field_values.append({"ref": ref, "value": value}) # Submit the user's input back to the agent to resume the task response = client.agent.automate_input( request_id, fields=field_values, ) print(f"\n--- Input response: {response} ---\n") ``` By decoupling the reasoning engine from the data source, Interactive Mode allows you to build more adaptable, resilient pipelines. Whether you are typing in the terminal or wiring Pilo into a complex backend where a master orchestrator agent automatically supplies the missing data, the engine easily adapts. ## Just the First Step It is important to note that Interactive Mode is currently in **Beta**. This initial release is highly optimized for form-filling scenarios, but this is only the first step in our vision for collaborative agents. As we continue to test and build out this functionality, Pilo's interactive capabilities will become much more advanced. Future iterations will support complex scenarios like resolving ambiguous instructions mid-task, requesting visual confirmations before executing destructive actions, and handling multi-step interactive workflows. We built Pilo to be the most reliable open-source foundation for web agents, and giving those agents the ability to ask questions is a massive step forward in making them truly useful. Check out the updated documentation on the [Mozilla Pilo GitHub repository](https://github.com/mozilla/pilo) or try out the SDK at [Tabstack.ai](https://tabstack.ai) today. --- ## Tabstack's New Pricing Plans URL: https://tabstack.ai/blog/updated-pricing-plans Date: 2026-04-06 Tabstack's pricing is evolving to give you more control and flexibility. Enjoy clearer, consistent billing with our new free 10k credit Trial, Pay As You Go Individual plan, or predictable monthly subscriptions. Build without interruption and scale at your own pace! ## Unlocking Flexibility Since day one, our goal at Tabstack has been to build tools that make your workflow smoother and more efficient. We have loved watching our community grow and build amazing things using our platform. But as your projects have evolved, we realized our pricing model needed to evolve alongside them. Until now, Tabstack has operated exclusively on prepaid credit packs. While this worked for many, we heard your feedback loud and clear: you want **clearer, consistent billing**, and you want choices that adapt to the way your team actually works. Today, we are thrilled to announce a complete overhaul of our pricing structure, designed to give you ultimate control, predictability, and flexibility. ## What Is New? We are moving away from the strict advanced credit model and introducing a tiered system that grows with you, taking you from your very first API call to enterprise deployments. ### The New Trial Tier We want everyone to experience the power of Tabstack without any friction. Every new user will now start with a **Trial Tier that includes 10,000 free credits**. This allows you to test the waters, build a proof of concept, and see exactly how Tabstack fits into your stack before spending a dime. ### The Individual Plan (Pay As You Go) Got a project with unpredictable volume? The Individual plan is for you. Once you graduate from the Trial Tier, you can opt to simply pay for what you use. You will be billed monthly based strictly on your exact usage. There are no upfront commitments, and you are never paying for credits you do not end up using. ### Predictable Monthly Subscriptions For teams with consistent or high volume needs, we are introducing two new subscription plans. These plans offer a set monthly price, a generous default credit allowance, and a lower cost per credit ratio. | Plan Tier | Monthly Price | Included Monthly Credits | Ideal For | | :---- | :---- | :---- | :---- | | **Team** | $99 / month | 500,000 credits | Growing startups and mid-sized teams with consistent workloads. | | **Pro** | $499 / month | 3,000,000 credits | High-volume applications and established companies scaling fast. | ## Overages and Spend Protection We know that traffic can spike unexpectedly. If you are on the Team or Pro plan and exceed your monthly credit allowance, your workflow will not break. You will seamlessly transition to overage billing so your services keep running smoothly. However, we also want to protect you from unexpected bills. You now have the power to configure your own custom usage limits directly from your dashboard. You can set up alerts to notify you when you reach a certain threshold, or set your own hard caps to pause operations automatically. Additionally, to provide an extra layer of security against massive, surprise bills, we have implemented a platform-level hard cap on all accounts. While you cannot edit this system cap directly, you can easily request an increase from our support team as your project scales. ## Important Details for Existing Users If you are already building with Tabstack, we want to make sure your transition is as smooth as possible. We are providing a 90 day grace period for all existing accounts. During the next 90 days, you will continue to receive your legacy monthly allowance of 50,000 credits, and you can still purchase credit packs just like before. You can choose to upgrade to the Individual plan or one of the new subscription plans at any time during this window. When you upgrade, any existing credit balance you have will be carried over to the new system, and **those credits will not expire**. If you have not transitioned after 90 days, your account will be updated automatically, and your remaining credit balance will still be safely preserved without an expiration date. ## Updated Credit Costs Along with the new plans, we are updating the credit cost per operation to better reflect the scale and processing power of our tools. If you are an existing user in the 90 day grace period, you will continue to enjoy the old pricing. All new users, existing users who choose to upgrade early, and all users after the 90 day window will be subject to the new pricing structure. | Operation | Old Cost (Credits/Action) | New Cost (Credits/Action) | | :---- | :---- | :---- | | **Extract Markdown** | 9 | 10 | | **Extract JSON** | 50 | 100 | | **Generate** | 57 | 250 | | **Automate** | 75 | 500 | | **Research Fast** | 25 | 500 | | **Research Balanced** | 50 | 1,000 | ## Why We Made the Switch (And Why It Is Good For You) We did not just change our pricing to add more options; we redesigned it to solve real pain points we noticed in how users were interacting with the platform. Here is how the new system works in your favor: * **Clearer, Consistent Billing:** You can now budget effectively. Whether you choose the predictability of the Team and Pro tiers or the exactness of the Individual plan, your finance team will thank you. * **Goodbye, "Top-Up Anxiety":** Under the old credit pack system, running out of credits meant your operations paused until someone manually logged in and bought more. Now, your workflow remains entirely uninterrupted. * **Scale at Your Own Pace:** Start for free, scale to the Individual plan as you gain traction, and lock in savings with a subscription tier once your volume is established. You are never forced into a box that does not fit your current size. * **No Bill Shock:** With customizable alerts and platform safety limits, you get the peace of mind that your budget is protected even if your application goes viral overnight. * **Lower Barrier to Entry:** The 10k credit Trial Tier allows developers and creators to experiment freely without needing to pull out a company credit card right away. ## Ready to Explore the New Plans? These new plans are live today! Head over to your dashboard to view your current usage, explore the new tiers, and select the plan that makes the most sense for your next big project. As always, if you have any questions, our support team is ready to help you find the perfect fit. Happy building! --- ## Not Every Page Needs a Browser URL: https://tabstack.ai/blog/fetch-effort-parameter Date: 2026-03-17 We rearchitected how Tabstack fetches pages to be faster by default, and added a new effort parameter that puts you in control. Start lightweight, escalate to full browser rendering only when you need it, and build adaptive pipelines that retry intelligently. ## The Problem with One-Size-Fits-All When you point an extraction API at a URL, you typically have no say in how the page gets fetched. A static documentation page and a JavaScript-heavy single-page application go through the same pipeline, with the same overhead and the same latency. You end up paying a time penalty on simple pages because the system has to assume every page might be complex. The reality is that most pages on the web are straightforward. A news article, a product listing on a server-rendered site, a wiki page — these do not need a full headless browser to extract. But a React dashboard behind client-side rendering absolutely does. You know your target sites. We should let you tell us. ## What Changed We made two changes to how Tabstack handles page fetching. First, we rearchitected the default fetch path to be significantly faster and more reliable. The `"standard"` effort level that every request uses by default is now smarter about how it retrieves content, with better fallback mechanisms and reduced overhead. Second, we added the `effort` parameter to the `/extract/json`, `/extract/markdown`, and `/generate/json` endpoints. This gives you explicit control over how hard Tabstack works to fetch a page before extraction begins. There are three levels: - **`"min"`** — A lightweight fetch with no fallback. This is the fastest option usually under 1 second, ideal for static or server-rendered pages where you know the content is available without JavaScript execution. - **`"standard"`** — The default. A balanced approach with enhanced reliability and fallback mechanisms, typically completing in less than 10 seconds. This will handle most pages, including ones with some JavaScript. Start here for any new integration. - **`"max"`** — Full browser rendering. This spins up a headless browser, executes JavaScript, waits for dynamic content to load, and then extracts. It takes 15 to 60 seconds but is necessary for SPAs, pages behind client-side hydration, or sites that load content dynamically. Try this when the other levels are not getting the content you want. ## Using Effort Adding the parameter is straightforward. Here is a basic example that extracts markdown from a JavaScript-heavy page: ```python import os from tabstack import Tabstack client = Tabstack(api_key=os.environ.get("TABSTACK_API_KEY")) # Full browser rendering for a JS-heavy page result = client.extract.markdown( url="https://example.com/spa-dashboard", effort="max" ) print(result.content) ``` For a static docs site where speed matters, drop to `"min"`: ```python result = client.extract.markdown( url="https://docs.example.com/api-reference", effort="min" ) ``` ## Adaptive Effort: Start Fast, Escalate When Needed The most powerful pattern with the effort parameter is adaptive escalation. Instead of guessing the right level upfront, you start with the fastest option and only escalate when the result is insufficient. This gives you the best possible latency on easy pages while still handling complex ones reliably. ```python import os from tabstack import Tabstack client = Tabstack(api_key=os.environ.get("TABSTACK_API_KEY")) def extract_with_adaptive_effort(url, min_length=100): """Extract markdown, escalating effort until we get a good result.""" efforts = ["min", "standard", "max"] for effort in efforts: result = client.extract.markdown(url=url, effort=effort) if result.content and len(result.content) >= min_length: return result return result # Return whatever we got at max effort result = extract_with_adaptive_effort("https://example.com/products") print(result.content) ``` This pattern works well in production pipelines where you process a mix of sites. Simple pages resolve in a couple of seconds at `"min"`, and only the pages that genuinely need browser rendering incur the additional latency. Your average response time drops significantly while your success rate stays high. ## When to Use Each Level Here is a quick guide for choosing the right effort level: - **Use `"min"` when** you are scraping well-known static sites, server-rendered pages, or any URL where you have verified that lightweight fetching returns complete content. Great for high-volume pipelines where speed is critical. - **Use `"standard"` when** you are integrating with a new site or processing a mix of URLs. It handles most of the web reliably without the overhead of full rendering. - **Use `"max"` when** content is missing from lower effort levels, the target is a known SPA or JavaScript-heavy application, or the page loads data asynchronously after initial render. ## Get Started The effort parameter is available now on all extract and generate endpoints. Update to the latest SDK version to use it, or pass `effort` directly in your request body if you are calling the API without an SDK. - **API Reference:** [docs.tabstack.ai](https://docs.tabstack.ai) - **Tabstack Dashboard:** [tabstack.ai](https://tabstack.ai) If you are building pipelines that process diverse URLs, try the adaptive effort pattern. Start fast, escalate smart, and let your code decide how hard to try. --- ## Scaling Web Automation with Pilo and Agentic AI URL: https://tabstack.ai/blog/introducing-pilo-browser-automation Date: 2026-02-24 Building reliable AI web agents is incredibly complex. To solve this, we are open sourcing Pilo. Pilo is a robust execution engine that uses the accessibility tree, smart context compression, and agentic reasoning loops to reliably navigate the modern web. Run it entirely on your own hardware. ## The Chaos of the Modern Web Building reliable web automation is notoriously difficult. Modern websites are dynamic, heavily reliant on JavaScript, and constantly changing. When you add Large Language Models to the mix to create autonomous web agents, the complexity multiplies. You suddenly have to manage browser orchestration, keep token costs down while maintaining full page context, handle flaky networks, and build complex reasoning loops just to get an AI to reliably extract data or click a button. You end up managing massive amounts of infrastructure just to handle a basic reasoning loop. We didn't just stumble upon these problems; we ran into them headfirst while building Tabstack. We needed a reliable engine to power our own /automate endpoint, but nothing off the shelf could handle the chaos of the modern web without constant breakage. So we built our own solution. We call it Pilo. It became the bedrock of our platform, and we realized that developers everywhere need this same robust, transparent foundation. Today, we are very excited to share Pilo as an open source project, enabling anyone to run this powerful web automation engine completely on their own infrastructure. You can find the full source code and documentation on [Github here](https://github.com/mozilla/pilo). ## Giving AI the Steering Wheel At its core, Pilo moves away from rigid scripts and embraces an agentic loop built around Playwright's accessibility tree. Instead of telling a program exactly where to click, you give Pilo a natural language goal. Pilo then takes over and makes decisions at every step based on what it actually sees on the screen. The system operates in a continuous, intelligent loop: - **Observe:** Pilo captures the current page state using the browser's accessibility tree. This provides a semantic, stable structure of the page rather than a chaotic mess of raw HTML tags. - **Decide:** Pilo passes this state to an LLM provider of your choice. The LLM evaluates the context and selects a specific tool to use next. - **Act:** Pilo executes the chosen action, whether that is navigating to a URL, clicking a button, filling out a form, or extracting structured data. Pilo handles all the gritty details under the hood. It features layered retries for flaky navigation, automatic context truncation to prevent context window bloat during long tasks, and a robust error recovery philosophy. If an action fails, Pilo does not simply crash. It feeds the error back to the LLM so the agent can adapt and try a new approach. ![Pilo Agent Loop](/images/blog/browser-ref2.png "By utilizing the accessibility tree, Pilo turns a chaotic webpage into a structured roadmap of labeled elements, making complex browser automation faster and more reliable.") ## Anatomy of an Autonomous Action To understand how Pilo handles the complexities of the web, let's look under the hood at a task like "find the best pizza restaurants in Seattle". **1. The Planning Phase:** Before launching a browser, Pilo forces the LLM to pause and strategize. It calls a create_plan tool to generate a step-by-step path and, crucially, defines strict success criteria. For a search-heavy task like this, the planner might smartly set the starting URL to about:blank, signaling the agent to immediately trigger its search workflow rather than wasting time navigating to a specific homepage. **2. Layered Navigation:** Navigating to a URL is the single most failure-prone operation in browser automation. Pilo wraps navigation in a layered defense system. It starts with timeout escalation, doubling the allowed wait time on each failure. If the network is truly flaky and throws a DNS error, Pilo will automatically kill and restart the entire browser instance to clear any bad state before retrying. **3. Compressing the Matrix:** Once the page loads, Pilo needs to show it to the LLM. Passing raw HTML is too expensive and noisy, so Pilo captures the accessibility tree, a semantic map of the page's structure. It pipes this tree through a compression engine that maps verbose tags like listitem to li, shortens reference IDs, and deduplicates repetitive text. This process slashes token usage by 60 to 80 percent while keeping every interactive element accessible. **4. The Decision Loop:** The LLM reviews the compressed snapshot and selects a tool, such as click. Pilo resolves the reference ID (e.g., e45) to a live Playwright locator and executes the action. If the page shifted and e45 is gone, Pilo catches the InvalidRefException and feeds it back to the LLM as a recoverable error. The agent sees the failure, realizes the page state has changed, and naturally requests a fresh snapshot to try again. **5. Quality Control:** When the agent thinks it's finished and calls done, Pilo doesn't just take its word for it. It triggers an isolated validation step where a second LLM acts as a grader. It compares the final results against the success criteria defined in step one. If the agent found only two restaurants when the plan demanded five, the validator marks it as "partial" quality and sends the agent back to work with specific feedback on what's missing. ## Seeing is Believing: Pilo in Your Browser While Pilo is a powerful backend engine, we wanted to make its capabilities completely tangible. Because the event system decouples the core logic from where it runs, Pilo is built to work seamlessly in different contexts, including a browser extension. You can install the extension, give it a natural language prompt, and literally watch the agentic loop drive your browser in real time. It is one thing to read about accessibility trees and LLM decision making; it is entirely another to sit back and watch an AI navigate, click, and extract data across the live web right in front of your eyes. It provides a perfect sandbox to test tasks and understand exactly how Pilo thinks and operates. ## The Engine Inside Tabstack We built Pilo to be completely standalone. You can run it locally, plug in your own API keys, and use it to power your own applications without ever signing up for Tabstack. Our goal is to provide developers with a reliable, open source foundation for web agents. However, building and scaling this kind of infrastructure in production is incredibly resource intensive. You have to manage compute pools, handle persistent browser sessions, and scale concurrent tasks. This exact challenge is why we built Tabstack in the first place. Pilo is the core engine that underlies our /automate endpoint. If you want to leverage the power and resilience of Pilo but do not want to manage the underlying infrastructure, browser orchestration, or scaling logistics, Tabstack provides all of this out of the box. --- ## Tabstack Research: Verified Answers from the Open Web URL: https://tabstack.ai/blog/tabstack-research-verified-answers Date: 2026-02-03 Tabstack Research moves the autonomous reasoning loop into the infrastructure layer. We handle the discovery, extraction, and verification required to bridge the synthesis gap. Access high-fidelity, structured data with inline citations instead of raw HTML noise or model hallucinations. Web browsing is the hidden tax of AI development. When you connect an agent to the open web, you are forced to stop building AI and start managing the overhead of browser orchestration. You end up debugging JS-rendering, rotating proxies, and writing brittle selectors just to turn the chaotic web into clean inputs. This is why we built Tabstack: to turn browsing into a reliable infrastructure layer. But even with a stable browser fleet, developers face a secondary bottleneck: **The Synthesis Gap**. Fetching raw data from a single URL is an infrastructure problem. Answering a complex question like "Compare Slack vs. Teams retention policies" is a state management and reasoning problem. To answer that, an agent must spawn a fleet of parallel searches, navigate dozens of unvetted URLs, filter out 90% marketing noise, and reconcile conflicting data. Processing this at scale creates a direct conflict between latency and context window density. If you feed your model every raw byte, you burn your token budget on noise. If you truncate too early, you lose the ground truth. Today we are launching **Tabstack Research**. It is a high-level research primitive that moves the autonomous reasoning loop into the infrastructure layer. You give us a goal. We execute the coordinated workflow of discovery, extraction, and verification to return a synthesized report backed by source citations. ## The Drudgery of Scale Most developers begin by wrapping a basic scraper in a loop, but they quickly hit an infrastructure wall. Scaling a research task does not just increase your bandwidth requirements. It multiplies your **orchestration complexity**. When an agent tackles a non-trivial query, it rarely performs a single lookup. It spawns a fan-out of parallel sub-queries. In this scenario, "ten blue links" quickly explode into 100 unvetted URLs. Processing this volume in production requires you to solve three high-stakes problems: 1. **The Concurrency Bottleneck:** Running 100 parallel headless sessions to handle modern, JS-heavy sites requires massive compute overhead. Managing the memory leaks, zombie processes, and proxy rotation needed to avoid rate limits turns into a full-time DevOps job. 2. **The Token Tax:** Consumption is not comprehension. Shoveling 50,000 tokens of raw HTML boilerplate into your model is a recipe for high latency and "lost in the middle" reasoning errors. Without a pre-processing layer, you are paying to process navigation menus and footer links instead of actual data. 3. **The Resolution Logic:** You are forced to build custom logic to reconcile conflicting data points across different domains. You end up spending more time on data cleaning and deduplication than on your core agent logic. The result is a fragile pipeline where engineering cycles are wasted managing a browser fleet instead of refining the product. ## An Adaptive Research Loop We built **Tabstack Research** to move this orchestration logic out of your application and into our specialized browsing layer. When you send us a request, we initiate a multi-phase agentic loop designed to mimic the recursive nature of human research at machine speed. By offloading the "discovery and verification" cycle to our infrastructure, you avoid the complexity of building custom state machines to handle search branching and error correction. Behind the scenes, the system executes a coordinated workflow that treats research as an iterative process rather than a linear fetch: - **Planning and Decomposition:** The system mimics a researcher's initial "mental map" by breaking your goal into targeted sub-questions. It identifies that a true comparison requires hitting distinct data silos: official documentation, enterprise pricing tables, and compliance whitepapers. - **Parallel Execution:** We visit these sites in parallel using our core browsing infrastructure. We perform real-time content extraction, filtering out the DOM noise and marketing fluff that typically bloat a context window. - **Gap Evaluation:** This is the recursive heart of the system. The system evaluates the collected data against the original intent. If it identifies a missing variable or a conflicting date, it detects the gap and triggers a new iteration to hunt down that specific information. - **Verification and Termination**: The loop concludes when the system determines the claims are sufficiently verified against the source text or when it reaches the iteration limit for the selected mode. For example, while the system stops early if it has all the required information, **Balanced Mode** allows for up to three rounds of recursive discovery to ensure the final output is grounded in retrieved evidence rather than model weights. ## Anatomy of a Request To see how this works in production, consider a complex research task: **"Compare enterprise data retention policies for Slack vs. Microsoft Teams."** ```python import os from tabstack import Tabstack # Initialize the client tabs = Tabstack(api_key=os.getenv('TABSTACK_API_KEY')) # Ask a research question result = await tabs.agent.research( query="Compare enterprise data retention policies for Slack vs. Microsoft Teams.", mode="balanced", ) print(result) ``` If you pass this query to a standard LLM or a basic search-based agent, you will likely get generic advice or a surface-level summary of the marketing pages. Here is how the **Tabstack Research** loop executes it: ### The Planning Phase The system deconstructs the high-level prompt into a series of technical primitives. It identifies that "retention" is not a single value. It generates sub-queries for "Teams Purview chat retention," "Slack Enterprise Grid file storage limits," and "M365 E5 compliance overrides." ### The Discovery Phase It executes these searches in parallel. It prioritizes official documentation like `learn.microsoft.com` and `slack.com`. Critically, our browsing layer ignores the SEO-optimized "Top 10" blog posts from 2023 that no longer reflect the 2026 pricing and policy landscape. ### The Recursive Pivot During extraction, the system hits a common stumbling block. Initial results for Teams mention a 30-day default retention. However, our evaluation step detects a critical gap: **Files shared in Teams are actually stored in SharePoint and OneDrive, which often have conflicting retention policies.** A standard agent would miss this nuance. Tabstack Research detects the ambiguity and triggers a targeted, second-pass search to clarify the "Conflict Resolution" logic between these interdependent Microsoft services. The engine identifies that while messages appear in Teams, the actual preservation happens in a hidden "SubstrateHolds" folder within the "Exchange Recoverable Items" folder. This is a nuance that dictates how legal holds are actually applied and accessed. ### The Verification Phase The final report is compiled with specific, time-sensitive data points that are verified against the source text to mitigate the risk of model hallucinations: - **Service Interdependence:** It clarifies that while Teams manages the message metadata, SharePoint manages the physical file retention. - **Price Adjustments:** It catches upcoming M365 price increases scheduled for July 1, 2026 (e.g., E3 moving from $36 to $39). - **Infrastructure Transitions:** It identifies technical shifts scheduled for late 2025 and 2026, such as Slack implementing a two-year rolling retention policy for audit logs and Teams migrating private channel messages to group mailboxes. - **Retention Granularity:** It identifies that Slack offers channel-level control, whereas Microsoft favors a centralized "longest-period-wins" logic. Every single claim is returned with an inline citation and a direct link to the specific documentation used for the extraction. ## Verifiable Claims The output is not a block of prose. It is a structured synthesis designed for downstream application consumption. We prioritize high-fidelity data over general summaries. ### A Note on AI-Generated Research LLMs can be remarkably confident even when they are incorrect. While Tabstack Research is built to minimize errors through recursive browsing and cross-referencing, no automated system is perfect. This is why we provide thorough, inline citations for every claim. We believe the value of an AI agent is not in replacing human judgment, but in providing the clear, sourced evidence required for you to make an informed decision. ### Grounded Attribution In an era of black box AI, we have moved the burden of proof from the model to the evidence. Every claim in a Tabstack Research report is backed by an inline citation. If the system reports that Slack Enterprise Grid requires a custom quote for the Discovery API, it provides the specific URL and the text fragment used to verify that fact. This allows your application to provide "click to verify" functionality for your end users. ### Conflict Resolution The system does not just aggregate data. It reconciles it. The loop often encounters conflicting information. For example, one source may claim Slack retention is limited to 90 days while another cites indefinite storage for paid tiers. The system resolves this by verifying the context, such as Free tier visibility limits versus Enterprise Grid storage policies. The result is a reconciled data point that prioritizes the most authoritative source. ### Structured Data Primitives Because we strip the DOM noise and marketing boilerplate during the execution phase, the final synthesis is high-density. You receive clean and actionable data points: - **Logic Mapping:** You learn that Slack offers granular channel level control while Microsoft favors a centralized "longest period wins" conflict logic. - **Temporal Accuracy:** You get specific price points like Slack's \~$15 to $45 per user per month (custom pricing) versus Microsoft 365's $36 for E3 and $60 for E5 list price, which accounts for upcoming 2026 shifts. - **Infrastructure Insights:** You receive technical specifics that impact compliance. This includes the fact that Teams video clips and embedded images are retained, but code snippets and voice memos are often excluded from standard retention policies. By the time the data reaches your application, the heavy lifting of discovery and extraction is complete. You are left with a verified asset that is ready to be stored in a database or presented in a UI. ## Continuum of Execution: Choosing Your Speed Research is not a one-size-fits-all operation. Different use cases require different levels of recursion and computational depth. We offer two primary modes to help you manage the balance between latency and comprehensiveness. - **Fast Mode:** This is optimized for instant answers and populating UI tooltips. It uses lightweight fetches and high-priority search excerpts to return an answer in **10 to 30 seconds**. It is ideal for "what is" questions where the answer is likely available in the primary search result or a single documentation page. - **Balanced Mode:** This triggers our full agentic loop. The system visits, renders, and analyzes pages deeply. It performs the multi-pass gap evaluation we described earlier. Typically delivering a comprehensive report in **1 to 2 minutes**, this mode is designed for complex comparisons and multi-source verification. ## Built for Trust In an era of opaque AI, we have taken a different path. As part of the **Mozilla** ecosystem, Tabstack is built on a foundation of privacy and responsibility. This is not just a marketing claim. It is a technical constraint on how we handle your data. - **Zero Training:** We do not train AI models on your research queries or the data we collect for you. Your intellectual property remains yours. - **Ephemeral by Design:** Your research data is treated as ephemeral. It is used to execute the specific task and is then discarded from our active processing memory. - **Full Verifiability:** By providing full citations and source metadata, we move the burden of proof from the model to the evidence. This allows you to build applications where the AI can be audited in real time. ## What You Can Finally Ask When you stop worrying about how to get the data, you can finally focus on asking the right questions. By moving the orchestration of web browsing into the infrastructure layer, the scope of what your agents can accomplish expands significantly. You can build agents that handle: - **Competitive Intelligence:** Compare enterprise pricing and data retention policies for Slack versus Teams. - **Regulatory Compliance:** Extract mandatory data residency requirements for healthcare SaaS in the European Union. - **Due Diligence:** Identify strategic supply chain risks in the latest 10-K filings from NVIDIA. - **Strategic Analysis:** Summarize the major commercial partnerships announced by Salesforce in the last year. We take care of the hard parts. We handle the browsing, the parsing, and the noise reduction so you can focus on the reasoning that makes your agent unique. Ready to build? [Sign up](https://console.tabstack.ai/signup) to get started and receive 50,000 free credits per month or explore the technical implementation in our [documentation](https://docs.tabstack.ai/api/research-v-1). --- ## Tabstack: Browsing Infrastructure for AI Agents URL: https://tabstack.ai/blog/intro-browsing-infrastructure-ai-agents Date: 2026-01-14 Building browser infrastructure is a hidden tax on AI development. Tabstack is the developer API that turns the chaotic web into clean inputs for your agents. From rendering SPAs to complex automation, we handle the orchestration so you can focus on reasoning. Reliable, scalable, and built by Mozilla. ## **The Web Access Challenge for Agentic AI** Every AI engineer eventually hits the same infrastructure wall. You build an agent that reasons perfectly in a sandbox, but the moment you connect it to the open web to perform a complex task, you are forced to stop building AI and start managing the massive overhead of browser orchestration. What starts as a simple script to fetch a URL quickly spirals into a full-time job. You find yourself managing headless browsers just to handle client-side rendering. You spend hours writing brittle selectors to parse raw HTML, only to watch them break the moment a site updates its layout. Instead of getting clean data, you are stuck debugging a chaotic mess of tags and attributes. This is the hidden tax of autonomous systems. The web is messy, unpredictable, and designed for human eyes rather than software agents. When teams try to bring browsing infrastructure to production themselves, they end up spending more cycles handling session reliability and patching browser fleets than they do improving their agent's intelligence. **Suddenly, you are not building AI anymore. You are maintaining a fragile, expensive web layer.** We built Tabstack to turn that chaotic infrastructure into a solved problem. ## **Web Browsing as Infrastructure** Today, we are publicly launching **Tabstack**, the web execution layer for AI systems. Tabstack is a developer-focused API that enables AI agents to extract, generate, and automate web content. It acts as a single abstraction layer that collapses the complexity of web automation. Tabstack gives your agents the ability to navigate pages, interact with real user flows, and turn the chaotic web into clean, actionable inputs. **We treat browsing as a distinct infrastructure problem.** Developers should not have to manually assemble network layers, proxies, and rendering engines just to reliably interact with a website. Whether you need to render complex single-page applications or navigate multi-step user workflows, Tabstack handles the heavy lifting of orchestration and reliability. We provide the stability needed to operate at scale so you can focus on building the intelligence that drives your agents. ## **A Continuum of Execution** Under the hood, Tabstack dynamically routes every request to the most efficient extraction method. It does not just blindly fire up a heavy browser for every request. Instead, it intelligently selects the lightest viable method by starting with raw HTTP fetches and escalating to full browser sessions only when edge cases or complex interactions demand it. This adaptive approach delivers: - **Speed:** Process simple pages instantly via lightweight fetches. - **Reliability:** Handle complex single-page apps (SPAs) with a robust automation engine that manages scrolling, rendering, and wait times. - **Resilience:** Maintain high success rates with **intelligent routing and retry logic**, without your team needing to manage the underlying infrastructure. ## **Turning the Web into Data** Tabstack provides a high-level interface for both understanding and acting on web content. By filtering out the noise before it reaches your model, **Tabstack prevents you from burning your budget on parsing raw HTML.** We ensure every token in your context window is spent on reasoning, not rendering. Whether you are feeding a RAG (Retrieval-Augmented Generation) pipeline or building an autonomous agent, we have an endpoint for the job: - **/markdown:** Instantly convert any URL's page content into clean Markdown, perfect for feeding into LLM context windows. - **/json:** Transform unstructured web pages into structured JSON objects using a schema you provide. This is ideal for turning product listings or news articles into database-ready records. - **/automate:** Instruct Tabstack to navigate, click, type, and handle complex interactions to complete multi-step workflows. This allows your agent to execute tasks just like a human user. ## **Giving Your Agent Eyes** We designed our API to be dead simple. Just import the SDK and tell Tabstack what to do. Here is how you can automate a complex task, like researching the top posts on Hacker News, in just a few lines of Python: ```python import os from tabstack import Tabstack # Initialize the client tabs = Tabstack(api_key=os.getenv('TABSTACK_API_KEY')) # Run an autonomous task result = await tabs.agent.automate( url="https://news.ycombinator.com", task="Go through 5 pages of the top posts. For each post, determine the website it is from and group all the posts by website. Return the list of the 10 websites with the most posts." ) print(result) ``` In the background, Tabstack's engine navigates pagination, interprets the content, aggregates the results, and returns the final answer. Your agent stays focused on reasoning while we handle the browsing. ## **Built for Production** Tabstack is designed for teams building AI systems that need to work reliably beyond a prototype. You can start quickly with a simple API and SDKs, then scale without re-architecting your stack or taking on new operational burden. There is no need to manage browser fleets, network layers, or constantly shifting edge cases. We are seeing developers use Tabstack to build incredible things that go far beyond simple data retrieval: - **Autonomous Research:** Agents that "read" the news or documentation and synthesize answers rather than hallucinating from outdated training sets. - **Action-Oriented Agents:** Systems that can book reservations, check flight statuses, or fill out forms on your behalf. - **Live Market Analysis:** Tools that navigate e-commerce sites to track pricing and availability in real-time. ## **Privacy You Can Trust (Backed by Mozilla)** We know that giving an external service access to your web traffic requires trust. **Tabstack is built by Mozilla.** In an era where data is often harvested without consent, we are building this capability in a way that reflects Mozilla's values. - **No Training on Your Data:** Mozilla does **not** train AI systems on the data that is collected by Tabstack. - **Ephemeral by Default:** We practice strict data minimization. Internally, we use the returned data solely to execute the requested task. Customer data is treated as ephemeral. - **Secure by Design:** We utilize end-to-end TLS and scoped API keys to support the secure handling of sensitive information, giving you control and peace of mind. We are building a tool for developers to access the web responsibly, rather than a mass data harvester for model training. ## **Get Started** The era of static, isolated AI is over. It is time to let your agents browse. Tabstack is now in public early access. We want to see what you can build when **the entire web is an API.** - **Website:** [https://tabstack.ai](https://tabstack.ai) - **Documentation:** [https://docs.tabstack.ai](https://docs.tabstack.ai) - **Twitter/X:** [@tabstack](https://x.com/tabstack) Let's see what you build.