Set up Anchor Browser with an AI agent

name: anchor
description: Use when automating web tasks with AI agents, building browser
  automation workflows, managing authenticated sessions, handling bot detection,
  or integrating cloud browsers into applications. Agents should reach for this
  skill when they need to navigate websites, fill forms, extract data, handle
  authentication, or run repeatable browser workflows in production.
metadata:
  mintlify-proj: anchor
  version: "1.0"

Anchor Browser Skill

Product Summary

Anchor Browser is a cloud browser platform for AI agents and automation. It provides managed Chromium instances you control via REST API, SDK (Node.js/Python), or Playwright/Puppeteer over CDP. Use it to run natural-language AI tasks, build versioned automation workflows, manage authenticated sessions, bypass bot detection, and handle large-scale browser automation. Key entry points: agentTask() for one-off AI-driven tasks, Sessions.createSession() for manual control, POST /v1/tools/perform-web-task for REST, and the Automation Tasks UI for production workflows. Primary docs: https://docs.anchorbrowser.io

When to Use

Reach for Anchor Browser when:

• AI-driven tasks: Agent needs to navigate a website, fill a form, or extract data using natural language (agentTask() or perform-web-task)
• Repeatable workflows: Building a production automation that runs the same way every time (Automation Tasks)
• Authenticated sessions: Logging into a site and keeping the session alive across multiple operations (managed authentication + identities)
• Bot detection challenges: Site blocks standard browsers; need residential proxies, stealth mode, or CAPTCHA solving
• Large-scale scraping: Running hundreds or thousands of parallel browser sessions (batch sessions)
• Manual browser control: Writing custom Playwright/Puppeteer code against a cloud browser
• Session recording: Capturing video of browser automation for debugging or documentation
• Multi-step workflows: Combining AI agents with deterministic code and human-in-the-loop steps

Do not use for: simple HTTP requests (use a fetch library), static HTML parsing (use cheerio/jsdom), or tasks that don't require JavaScript rendering.

Quick Reference

Session Creation

Method	Use case	Returns immediately?
Sessions.createSession()	Single session, simple setup	Yes (blocks until ready)
Sessions.createSessionAsync()	Parallel provisioning, long setup	Yes (poll for readiness)
POST /v1/batch-sessions	100–5,000 sessions at once	Yes (poll for completion)

Browser Control

Approach	Best for	Effort
agentTask() / perform-web-task	Ad hoc, exploratory, changing flows	Low (natural language)
Automation Tasks	Repeated, versioned, production workflows	Medium (demo or prompt)
Playwright/Puppeteer over CDP	Full control, custom logic	High (write code)
REST endpoints (screenshot, PDF, content)	Fetch page data without session	Low (single call)
OS-level control (mouse, keyboard)	Vision models, computer-use agents	Medium (coordinate-based)

Configuration at Session Create

const session = await Sessions.createSession({
  body: {
    session: {
      initial_url: "https://example.com",
      timeout: { max_duration: 20, idle_timeout: 5 },
      proxy: { active: true, country_code: "us" },
      tags: ["production", "customer-123"]
    },
    browser: {
      headless: { active: false },
      adblock: { active: true },
      extra_stealth: { active: true },
      extensions: ["extension-uuid-1"]
    },
    identities: [{ id: "identity-uuid" }]
  }
});

Common SDK Patterns

// AI task (one-off)
const result = await agentTask("Find the price of this product", {
  taskOptions: { url: "https://example.com/product" }
});

// Structured extraction
const result = await agentTask("Extract product data", {
  taskOptions: {
    url: "https://example.com",
    outputSchema: { title: "string", price: "number" }
  }
});

// Manual browser control
const session = await Sessions.createSession();
const browser = await connectBrowser(session.data.id);
const page = browser.contexts()[0].pages()[0];
await page.goto("https://example.com");
browser.close();

// Screenshot
const screenshot = await Tools.screenshotWebpage({
  query: { sessionId: session.data.id },
  body: {}
});

Decision Guidance

When to use Perform Web Task vs Automation Tasks

Factor	Perform Web Task	Automation Tasks
Frequency	One-off, ad hoc	Repeated, production
Consistency	Varies run to run	Deterministic, same every time
Cost	Per-call (variable)	0.1 credits per run (flat)
Versioning	None	Versioned, deployable
Self-healing	No	Yes (AI fallback + auto-fix)
Setup	Immediate	Demo or prompt first

Use Perform Web Task for exploratory work, testing, or flows that change frequently.
Use Automation Tasks for production, cost-heavy runs, or workflows you deploy and reuse.

When to use Proxy/Stealth/CAPTCHA

Scenario	Solution
Site blocks your IP	Anchor Proxy (residential, geo-targeted)
Site detects automation	Extra Stealth Mode (requires proxy)
Site shows CAPTCHA	Enable captcha_solver (requires proxy)
Need fixed IP	Dedicated Sticky IP
Need VPN routing	Anchor VPN

When to use Browser Profiles vs Managed Authentication

Need	Browser Profiles	Managed Authentication
Simple login once, reuse	✓
Auto re-auth on expiry		✓
MFA support	Manual codes	Built-in (OTP, TOTP, 1Password)
Production login flows		✓

Workflow

Running a One-Off AI Task

1. Identify the task: What should the agent do? (navigate, click, extract, fill form)
2. Prepare inputs: URL, any secret values (credentials), output schema if structured data needed
3. Call agentTask(): Pass prompt and taskOptions
4. Handle result: Extract result.data.result (string or JSON if schema provided)
5. Verify output: Check result matches expected format; log for debugging

Building a Production Automation Task

1. Plan the workflow: Write a clear prompt or prepare a demonstration
2. Create the task: Use UI (demo or prompt) or POST /v2/tasks/generate API
3. Poll for readiness: GET /v2/tasks/{taskId}/generation-status until status === 'ready'
4. Test with sample inputs: Run once to verify behavior
5. Deploy: Call POST /v1/tasks/{taskId}/run with inputs at runtime
6. Monitor: Check task status, handle failures, enable self-healing if needed
7. Iterate: Edit task code or re-generate if site changes break it

Setting Up Authenticated Sessions

1. Create an application: Define the target website (e.g., linkedin.com)
2. Choose auth mode: Auto-discovery, preset (username/password + MFA), or manual
3. Create an identity: Store credentials or complete a guided login
4. Launch session with identity: Sessions.createSession({ identities: [{ id }] })
5. Browser starts signed in: No login steps needed on subsequent runs
6. Re-auth on expiry: Anchor runs auth flow automatically if session expires

Handling Bot Detection

1. Enable proxy: proxy: { active: true, country_code: "us" }
2. Enable stealth: extra_stealth: { active: true } (requires proxy)
3. Enable CAPTCHA solving: captcha_solver: { active: true } (requires proxy)
4. Test: Run a small batch to verify access
5. Scale: Use batch sessions for large-scale scraping

Common Gotchas

• Session not ready on connect: Async sessions return immediately; poll GET /v1/sessions/{id} until status === 'ready' before connecting over CDP.
• Idle timeout kills session: Set idle_timeout to -1 to disable, or ensure your code connects before timeout elapses.
• Max duration cuts off long tasks: Set max_duration high enough for your workflow (default 180 min); no upper limit.
• Proxy required for stealth: Extra stealth mode only works with proxy.active: true.
• CAPTCHA solver needs proxy: captcha_solver requires proxy enabled.
• Profile expires silently: Browser profiles don't auto re-auth; use managed authentication for production.
• Retrying creates duplicate sessions: POST /v1/sessions does not read Idempotency-Key; retrying a 5xx or 409 may start a second session.
• Live view URL contains API key: Never log session.data.cdp_url; use live_view_url for sharing.
• Perform Web Task not idempotent: Sending the same request twice runs two tasks; use async + workflow ID for deduplication.
• Task generation can fail silently: Poll generation-status and check for status === 'failed' before assuming task is ready.
• Agent steps vary by model: Different LLM models take different paths; set max_steps to prevent runaway tasks.
• Secrets not logged but visible in recordings: Use secret_values for credentials; disable recording if sensitive data is on screen.
• Batch sessions don't return individual IDs immediately: Poll batch status to get session IDs; they're created asynchronously.

Verification Checklist

Before submitting work:

• Session created and ready (check status or poll async endpoint)
• Timeout configured appropriately (max_duration and idle_timeout set)
• Authentication working (identity attached if needed; test login flow)
• Proxy/stealth enabled if site requires it (test with small batch first)
• Task prompt or demonstration clear and unambiguous
• Output schema defined if extracting structured data
• Secret values passed securely (not in logs or recordings)
• Session cleaned up after use (end-browser-session or auto-timeout)
• Cost tracked (use session tags for billing attribution)
• Error handling in place (check error.type on task failure)
• Recording reviewed if debugging needed (check recording_url)
• Rate limits respected (check RateLimit headers on 429)

Resources

• Full page navigation: https://docs.anchorbrowser.io/llms.txt
• API Reference: https://docs.anchorbrowser.io/api-reference
• SDK Reference: https://docs.anchorbrowser.io/sdk-reference
• Perform Web Task (AI tasks): https://docs.anchorbrowser.io/agentic-browser-control/ai-task-completion
• Automation Tasks (production workflows): https://docs.anchorbrowser.io/tasks/creating-a-task
• Managed Authentication: https://docs.anchorbrowser.io/essentials/managed-authentication

---

For additional documentation and navigation, see: https://docs.anchorbrowser.io/llms.txt