How to Use the Hyperbrowser (Web Infra for AI) MCP in LangChain

Q: How do I manage persistent session state across different LangChain runnables using Hyperbrowser (Web Infra for AI)?

Pass the session ID returned by createsession through your LangChain state. This lets different nodes in your chain execute runscript or pagecontent on the same MCP Server instance without starting over.

Q: Can my LangChain agent handle asynchronous scraping with Hyperbrowser (Web Infra for AI)?

Yes, your agent can call startscrape to begin an async job and then enter a conditional LangGraph loop. The loop uses getscrapejob to poll the status until it returns the completed HTML payload.

Run multi-step web automation and scraping chains in LangChain using Hyperbrowser's managed cloud browsers.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Hyperbrowser (Web Infra for AI) MCP to LangChain

Create your Vinkius account to connect Hyperbrowser (Web Infra for AI) to LangChain and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Hyperbrowser (Web Infra for AI) with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Dynamic session chaining in LangChain

The `create_session` tool initializes a remote browser instance that your LangChain ReAct agent controls step-by-step. You pass the connection details directly into your chain's state, letting subsequent nodes execute custom JavaScript using `run_script` on the exact same page. This keeps your agent's execution context intact across complex multi-page workflows. LangSmith traces every step of this browser lifecycle, showing you exactly when `stop_session` runs to clean up resources. You get full visibility into the execution latency of your custom scripts and the exact raw HTML returned by `page_content` within your chain.

LangChain structured extraction via Hyperbrowser MCP Server

The `extract_data` tool uses LLM capabilities to parse raw web pages directly into typed LangChain schemas. Instead of writing brittle selectors in your chain, you feed the raw DOM to this tool and get structured JSON that maps directly to your LangChain output parsers. For heavy pages, your chain can trigger `start_scrape` to offload the rendering workload to Hyperbrowser's MCP Server. The agent then polls `get_scrape_job` within a LangGraph loop, keeping your main execution thread free from long-running HTTP timeouts.

Visual debugging for agent chains

The `page_screenshot` tool captures the visual state of any active browser session during chain execution. When a node in your LangChain graph fails to find an element, the agent triggers this tool to capture a base64 image of the page. You can feed this image back into a multimodal LangChain model or inspect it in your tracing dashboard. By listing active sessions with `list_sessions` and checking their health with `get_session` on this MCP Server, you pinpoint exactly where your automation broke down.

Setup guide

Set up Hyperbrowser (Web Infra for AI) MCP in LangChain

Prerequisites

Python 3.10+ installed
langchain-mcp-adapters + langgraph packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install langchain-mcp-adapters langgraph langchain-openai. The MCP adapters package converts MCP tools into native LangChain BaseTool objects.
2

Connect via HTTP transport
Use MultiServerMCPClient with "transport": "http" pointing to your Vinkius endpoint. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Create a ReAct agent
Pass the discovered tools to create_react_agent() from LangGraph. The agent automatically routes Hyperbrowser (Web Infra for AI) tool calls through the MCP protocol.
4

Run with any LLM
Swap ChatOpenAI for ChatAnthropic, ChatGoogleGenerativeAI, or any LangChain-compatible model. The MCP tools work identically across all providers.

agent.py

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

async with MultiServerMCPClient({
    "hyperbrowser-web-infra-for-ai-mcp": {
        "transport": "http",
        "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp",
    }
}) as client:
    tools = client.get_tools()

    agent = create_react_agent(
        ChatOpenAI(model="gpt-4o"),
        tools,
    )
    result = await agent.ainvoke({
        "messages": "List recent Hyperbrowser (Web Infra for AI) transactions"
    })
    print(result["messages"][-1].content)

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Hyperbrowser. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Hyperbrowser (Web Infra for AI) now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Hyperbrowser (Web Infra for AI) MCP in LangChain

Pass the session ID returned by `create_session` through your LangChain state. This lets different nodes in your chain execute `run_script` or `page_content` on the same MCP Server instance without starting over.

Yes, your agent can call `start_scrape` to begin an async job and then enter a conditional LangGraph loop. The loop uses `get_scrape_job` to poll the status until it returns the completed HTML payload.

You specify proxy and stealth configurations in the JSON payload when invoking `create_session` from your LangChain tool-calling agent. The remote browser handles the rotation automatically, keeping your chain's IP footprint clean.

Use a try-finally block or a LangChain callback handler to ensure `stop_session` is called. You can also run `list_sessions` on the MCP client to find and terminate lingering sessions.

Your raw HTML, scraped data, and screenshots are processed in isolated, ephemeral browser sandboxes that are destroyed the moment you call `stop_session`. No session data or page content is stored permanently on our servers.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript