Give your AI agent
a real browser.

Antidetect Chromium that passes bot detection so your agent can actually interact with websites. Built-in fingerprints, CAPTCHA solving, proxy rotation.

Request Access See How It Works

Passes Cloudflare, Akamai, DataDome, PerimeterX, and more. Works with browser-use, LangChain, Claude Computer Use, and OpenAI Agents SDK.

Built for every detection layer.
Challenges solved automatically.

Antibot systems challenge your agent at every stage of its loop: network layer, JS environment, browser fingerprint, behavioral patterns, and session identity. Surfsky handles each one so your agent keeps moving.

Product demo

From task to data
in a single session.

Schema in, data out

Declare a typed schema for the data you need. Pass it to the agent and the output gets validated against it automatically. No HTML parsing, no post-processing.

from typing import TypedDict

class Flight(TypedDict):
    airline: str
    price: float
    departure: str
    stops: int

flights: list[Flight] = (await agent.run()).parsed_output()
# → [{"airline": "United", "price": 187.0, "departure": "06:15", "stops": 0},
#    {"airline": "Delta",  "price": 203.0, "departure": "08:30", "stops": 0}, ...]

Start a browser session

Surfsky spins up a browser with a real device fingerprint, residential proxy, and auto captcha solving, then returns a standard CDP WebSocket URL your agent framework already speaks.

surfsky = Surfsky(api_key="sk-...")

session = surfsky.sessions.create(
    proxy={"country": "us", "type": "residential"},
    fingerprint={"os": "mac", "os_arch": "arm"},
    anti_captcha={"enabled": True},
)
# → wss://browser.surfsky.io/session/abc123

Connect your agent framework

Pass the CDP URL to your agent. Human-like mouse moves, keystrokes, and timing are injected at the browser level. Your agent loop runs unchanged.

# browser-use - just swap the CDP URL
browser = Browser(config=BrowserConfig(cdp_url=session.cdp_url))

agent = Agent(
    task="Find cheapest SFO→JFK flights for next Friday",
    llm=ChatOpenAI(model="o3"),
    browser=browser,
)
# LLM reasons → act() → observe → repeat

Plug into your stack

Surfsky works with every major agent framework. Connect via CDP or use our native SDK. Switch one line and your agent code stays the same.

from surfsky import Surfsky
from pydantic import BaseModel

class Startup(BaseModel):
    name: str
    funding: str
    stage: str

client = Surfsky(api_key="sk-...")

session = client.sessions.create(
    proxy={"type": "residential", "country": "us"},
    fingerprint={"os": "mac", "os_arch": "arm"},
    anti_captcha={"enabled": True},
)

result = await client.run(
    "Find the top 10 AI startups on Crunchbase",
    output_schema=Startup,
)

for s in result.output:
    print(s.name, s.funding, s.stage)
# Antidetect browser, proxies, captchas - all automatic

from browser_use import Agent, Browser, BrowserConfig
from langchain_openai import ChatOpenAI
from surfsky import Surfsky

surfsky = Surfsky(api_key="sk-...")
session = surfsky.sessions.create()

browser = Browser(config=BrowserConfig(
    cdp_url=session.cdp_url
))

agent = Agent(
    task="Find the top 5 AI posts on HackerNews",
    llm=ChatOpenAI(model="o3"),
    browser=browser,
)
result = await agent.run()
print(result.final_result())
# browser-use drives the page; Surfsky handles anti-bot

from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
from surfsky import Surfsky
from surfsky.langchain import SurfskyBrowserToolkit

surfsky = Surfsky(api_key="sk-...")
session = surfsky.sessions.create(
    proxy={"country": "us"},
)

# Provides navigate, click, type, extract, screenshot tools
toolkit = SurfskyBrowserToolkit(session=session)

agent = create_react_agent(
    ChatOpenAI(model="o3"),
    tools=toolkit.get_tools(),
)

result = await agent.ainvoke({
    "messages": [{
        "role": "user",
        "content": "Compare GPU pricing on AWS, GCP, and Azure",
    }]
})
# LangGraph ReAct loop with Surfsky antidetect browser

import anthropic
from surfsky import Surfsky

surfsky = Surfsky(api_key="sk-...")
session = surfsky.sessions.create()

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-6-20260310",
    max_tokens=4096,
    tools=[{
        "type": "computer_20250124",
        "name": "computer",
        "display_width_px": 1920,
        "display_height_px": 1080,
    }],
    messages=[{
        "role": "user",
        "content": "Book the cheapest rental car in Miami for this weekend"
    }]
)
# Claude sees and controls a real antidetect browser via Surfsky

from agents import Agent, Runner
from agents.extensions.browsers import BrowserTool
from surfsky import Surfsky

surfsky = Surfsky(api_key="sk-...")
session = surfsky.sessions.create()

browser_tool = BrowserTool(
    cdp_url=session.cdp_url
)

agent = Agent(
    name="researcher",
    instructions="Find the latest Series A funding rounds in AI infrastructure",
    tools=[browser_tool],
)
result = await Runner.run(agent)
print(result.final_output)
# OpenAI agent with antidetect browser - no blocks, no captchas

MCP Server

Give any MCP-compatible client (Claude Desktop, Cursor, Windsurf, or your own agent) full control over antidetect browsers, proxies, and captcha solving with a single config block.

Claude Desktop · claude_desktop_config.json

{
  "mcpServers": {
    "surfsky": {
      "command": "npx",
      "args": ["@surfsky/mcp-server"],
      "env": { "SURFSKY_API_TOKEN": "sk-..." }
    }
  }
}

Available tools

session_create — Launch a browser with fingerprint, proxy, and captcha config

session_close — Stop the session, persist storage if enabled

navigate — Go to URL, wait for selector or network idle

act — Click, type, scroll with human-like behavior

scrape — HTML + cookies + screenshot in one call

screenshot — Full-page capture as base64 for vision models

profile_manage — CRUD for persistent browser profiles

cookies — Import / export cookies to seed authenticated sessions

Ship agents that
don't get blocked.

Tell us what you're building. We'll get you set up.

Request Access

Give your AI agent a real browser.

Built for every detection layer.Challenges solved automatically.

From task to datain a single session.