> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zenrows.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Hermes MCP Integration for ZenRows

> Connect Hermes Agent with the ZenRows MCP to give your autonomous agent reliable access to any website without getting blocked. Scrape protected pages, extract live data, and run scheduled monitoring tasks with results delivered directly to your CLI or messaging app.

## What is Hermes Agent?

<a href="https://hermes-agent.nousresearch.com" target="_blank" rel="nofollow noopener noreferrer">Hermes Agent</a> is an open-source self-improving autonomous agent. Unlike a chatbot or a coding copilot, Hermes runs a closed learning loop by creating skills from experience, improving them during use, and building a persistent model of who you are across sessions. It runs wherever you put it: a VPS, a local machine, or serverless infrastructure. You can talk to it from your terminal, Telegram, or any supported messaging app you connect to it.

## Why connect ZenRows to Hermes?

* **Every scraping task becomes a skill:** When Hermes successfully scrapes a site through ZenRows, it can turn that workflow into a reusable skill. The next time you ask for competitor pricing or job board leads, it already knows how to execute your workflow.

* **Access any website data without getting blocked:** Proxy rotation, anti-bot evasion, and browser orchestration run on ZenRows' infrastructure. Hermes asks for the page and gets the content regardless of the anti-bot system protecting it.

* **Lower LLM costs per task:** Raw HTML boilerplate burns tokens. ZenRows returns clean, structured, LLM-friendly Markdown or JSON, so Hermes processes only what matters and your token budget is managed.

* **Reliable scheduled tasks:** When Hermes runs a cron job, such as a daily digest, a price check, or a lead monitor, a blocked page breaks the whole run. ZenRows keeps those tasks completing consistently.

* **Works across parallel subagents:** Hermes can spawn up to 3 concurrent subagents by default via `delegate_task`, each with its own isolated context and toolset. Pair that with ZenRows and you can run a multi-source research task, with one subagent pulling competitor pricing, another monitoring job boards, and another tracking industry news, and have all three deliver structured results to your chat simultaneously.

* **Full browser automation, described in plain English:** For sites that require login, pagination, or form interaction, Hermes can instruct ZenRows' browser tools in natural language. No selectors, no scraping code.

## What you can build with the Hermes-ZenRows integration

* **A self-improving competitive intelligence feed:** Schedule a daily cron job that scrapes competitors' pricing, changelogs, and job pages, compares them against the previous run, and delivers only what changed to your Telegram or Slack.

* **A parallel market research agent:** Give Hermes a research brief covering competitors, news sources, and job boards, and let it spawn concurrent subagents via `delegate_task`, each scraping a different source through ZenRows. Hermes then synthesizes everything into a single briefing.

* **An ad research and content brief pipeline:** Give Hermes a product URL and it scrapes the landing page, pulls winning hooks from Meta Ads Library and TikTok Creative Center, and writes a ready-to-use creative brief without you touching a single tab.

* **A daily news and industry digest:** Schedule Hermes to scrape Hacker News, RSS feeds, and industry blogs every morning, filter for what's actually relevant to your work, and push a tight summary to your Telegram or Discord before you start your day.

* **A pre-call research brief:** Give Hermes a company name before a sales or partnership call and it uses ZenRows to scrape their site, recent news coverage, job postings, and any public announcements, then assembles a one-page brief in your messaging app before the meeting starts.

* **A 24/7 monitoring agent on a remote server:** Deploy Hermes on a VPS or serverless instance, point a set of cron jobs at protected pages via ZenRows, and get messaged only when something is worth your attention.

## Connecting ZenRows to Hermes

This guide uses Anthropic as the LLM provider and the ZenRows MCP server. You can substitute any supported provider, but the setup steps shown here follow the Anthropic path.

Before continuing, you need a ZenRows account and API key. Obtain one from the [ZenRows dashboard](https://app.zenrows.com/register).

<Steps>
  <Step title="Install Hermes">
    The Hermes installer handles everything automatically: Python 3.11, Node.js 22, ripgrep, ffmpeg, and the `hermes` command itself. You don't need to install those manually.

    **Linux / macOS / WSL2:**

    ```bash theme={null}
    curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
    ```

    **Windows (native PowerShell):**

    ```powershell theme={null}
    iex (irm https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1)
    ```

    Verify the installation:

    ```bash theme={null}
    hermes doctor
    ```
  </Step>

  <Step title="Configure your LLM provider">
    Hermes requires a model with at least 64,000 tokens of context. Most hosted models meet this easily. Follow the on-screen prompts to choose your LLM provider, enter your API key, and select your preferred model.

    ```bash theme={null}
    hermes model
    ```
  </Step>

  <Step title="Test the chat model">
    Verify that chat works by running the following command:

    ```bash theme={null}
    hermes
    ```

    Once the CLI-based agent loads, send a test prompt to see if Hermes loads a response from the connected model:

    ```text theme={null}
    Go to https://www.scrapingcourse.com/antibot-challenge and summarize the page.
    ```

    Hermes will attempt the page with its built-in search services and respond with a blocked page, showing its built-in tools aren't enough to access protected pages:

    ```text Output theme={null}
    The site is hitting Cloudflare's anti-bot security check and blocking access.
    ```
  </Step>

  <Step title="Add ZenRows MCP to Hermes">
    ZenRows exposes its scraping and browser tools as an MCP server. Adding it to Hermes automatically gives the agent access to all ZenRows tools.

    Hermes has a built-in catalog of Nous-approved MCP servers that you can install with a single command (`hermes mcp catalog`). ZenRows isn't in the catalog yet, so add it manually to the config file instead.

    Hermes configuration lives in the `~/.hermes/config.yaml` file. Open it in any editor. The path depends on your OS:

    * **Linux / macOS / WSL2:** `~/.hermes/config.yaml`
    * **Windows:** `C:\Users\<username>\AppData\Local\hermes\config.yaml`

    Add ZenRows MCP to the `mcp_servers` block:

    ```yaml YAML theme={null}
    mcp_servers:
        zenrows:
            url: "https://mcp.zenrows.com/mcp"
            headers:
                Authorization: "Bearer <YOUR_ZENROWS_API_KEY>"
    ```

    Save the file, then start Hermes:

    ```bash theme={null}
    hermes chat
    ```

    Hermes discovers MCP servers at startup and registers their tools into the normal tool registry. Verify ZenRows loaded by asking:

    ```text theme={null}
    Tell me which MCP-backed tools are available right now.
    ```

    The Hermes chat agent returns ZenRows and its exposed tools:

    ```text Output wrap theme={null}
    Based on the tools loaded in this session, here are all the MCP-backed tools available right now:

    ZenRows MCP (mcp_zenrows_*)

    Scraping:
        - mcp_zenrows_scrape - Fetch any URL as markdown/plaintext/HTML/PDF, with optional JS rendering, proxies, CSS extraction

    Browser Automation:
    # ... list of exposed ZenRows tools truncated for brevity
    ```

    If you're adding ZenRows to a running session or made changes to the MCP configuration at runtime, use the reload command in that chat session instead of restarting:

    ```text theme={null}
    /reload-mcp
    ```

    If the dynamic update doesn't work, close the current chat session and rerun `hermes chat` to reload the Hermes agent with your changes.
  </Step>
</Steps>

### Filtering ZenRows tools (optional)

If you want to restrict which ZenRows tools Hermes can use, for example allowing only the `scrape` tool and blocking browser automation, add a `tools.include` filter:

```yaml YAML theme={null}
mcp_servers:
  zenrows:
    url: "https://mcp.zenrows.com/mcp"
    headers:
        Authorization: "Bearer <YOUR_ZENROWS_API_KEY>"
    tools:
        include: [scrape]
```

## Getting started: Basic usage

With ZenRows connected, Hermes can fetch and process any page without writing a single line of code. Start a chat session and try:

```text wrap theme={null}
Scrape the top headlines from news.ycombinator.com and summarize all the top 5 stories in one paragraph.
```

Hermes will call the ZenRows scrape tool, receive clean Markdown back, and summarize the content for you:

```text Output wrap theme={null}
Today's top Hacker News stories cover a mix of security, science, education, and programming. A researcher exposed...truncated for brevity...
```

Try a more targeted extraction:

```text wrap theme={null}
Go to https://www.scrapingcourse.com/ecommerce and extract all product names and prices. Return them as a table.
```

Or test it against a protected site:

```text theme={null}
Go to https://www.scrapingcourse.com/antibot-challenge and summarize the page.
```

With ZenRows, Hermes knows when to escalate to anti-bot bypass based on the response. You don't have to specify it unless you want to.

## Advanced usage: Autonomous Scheduled Scraping

Hermes has a built-in cron scheduler. Pair it with ZenRows, and you can set up scraping tasks that run on a schedule and deliver results to any platform without you having to intervene.

### Setting up a daily price monitor

From inside a chat session, use the `/cron` command:

```text wrap theme={null}
/cron add "every day at 9 am" "Scrape https://www.amazon.com/s?k=headset, get the top 3 best deals based on price and ratings, and return a summary." --name "Headset deals."
```

The above prompt creates a cron job that runs every 24 hours. Hermes fires a fresh agent session, scrapes the page via ZenRows, and outputs a summary of the top deals.

<Tip>Cron jobs run in fresh agent sessions; they don't inherit the context of your current chat. They do have access to Hermes's persistent memory and skills, but anything specific to your current conversation needs to be included directly in the prompt. You set the prompt once when creating the job, and Hermes runs it on every cycle. Include everything it needs directly in that prompt: the URL, what to extract, and how to format the output.</Tip>

### Monitoring important responses using the \[SILENT] flag

For monitoring jobs, you only want to see when something changes. Include a `[SILENT]` flag to only get relevant alerts:

```text wrap theme={null}
/cron add "1d" "Scrape https://www.indeed.com/q-london-uk-jobs.html and extract all job postings. Identify roles that signal buying intent such as new engineering hires, scaling teams, or data infrastructure roles. If nothing changed since the last run, respond with [SILENT]. Otherwise, list new postings added today." --name "Buying intent monitor."
```

When the agent's final response contains `[SILENT]`, delivery is suppressed. No notification noise on quiet days.

Manage your cron jobs with the following commands:

```bash theme={null}
/cron list                              # List all active jobs
/cron run <job_id>                      # Trigger immediately for testing
/cron pause <job_id>                    # Pause without deleting
/cron edit <job_id> --schedule "4h"     # Change schedule
/cron remove <job_id>                   # Delete permanently
```

To learn how to run parallel scraping workstreams across multiple sources simultaneously, see <a href="https://hermes-agent.nousresearch.com/docs/guides/delegation-patterns" target="_blank" rel="noopener noreferrer">Delegation Patterns</a> in the Hermes docs.

## Set up a messaging channel (optional)

Once ZenRows and Hermes are working, you can connect a messaging platform to receive scraping results and cron job outputs directly in your preferred chat app.

The messaging gateway is a background process that handles all connected platforms and runs the cron scheduler. You need it running for message delivery to work.

<Steps>
  <Step title="Configure your platform">
    ```bash theme={null}
    hermes gateway setup
    ```

    The above command starts an interactive chat channel setup. Select your preferred channel and follow the instructions to set it up. This connects Hermes to Telegram, Discord, Slack, WhatsApp, Signal, or any of 20+ supported platforms.

    This guide uses Telegram. Set up a Telegram bot by sending the `/newbot` command to `@BotFather`. Follow `@BotFather`'s instructions and enter the given bot ID into the interactive CLI. Once set up, scheduled cron jobs and agent results can be delivered straight to your preferred channel.
  </Step>

  <Step title="Install and start the gateway as a background service">
    ```bash theme={null}
    hermes gateway install   # Registers as a system service
    hermes gateway start     # Starts the service
    hermes gateway status    # Confirms it's running
    hermes gateway stop      # Stops a running service
    ```

    Once installed, the gateway runs in the background and starts automatically whenever your machine boots.

    When the Hermes server starts, run a scraping prompt through the Telegram bot you created. It uses the ZenRows scrape tool to access your target and loads the response via the connected AI model.
  </Step>
</Steps>

## Troubleshooting

### No response is returned in Telegram

The message was delivered to the bot, but the gateway isn't running, so nothing is processing it.

1. Confirm the gateway is running:

   ```bash theme={null}
   hermes gateway status
   ```

2. If it's stopped, restart it:

   ```bash theme={null}
   hermes gateway start
   ```

Check that your Telegram bot token is correct and the bot was created via `@BotFather`. An invalid token means the gateway connects but cannot send messages back.

### ZenRows tools not loading after adding to config

* Confirm the config was saved to `~/.hermes/config.yaml`.
* Restart Hermes with the `hermes start` command.
* Verify your API key is correct and the ZenRows MCP endpoint is entered correctly.

### Scraping returns empty or blocked content

ZenRows handles anti-bot systems automatically, but Hermes may sometimes use its built-in browser tool instead. If you're seeing unexpected results, explicitly instruct Hermes to use ZenRows:

```text theme={null}
Use ZenRows to scrape https://www.scrapingcourse.com/ and summarize the page.
```

### Cron job runs, but no message is delivered

* Confirm the gateway is running: `hermes gateway status`.
* Run the job manually with `/cron run <job_id>` to see the output immediately.

## FAQ (Frequently asked questions)

<Accordion title="Does ZenRows count as one of Hermes's 60+ built-in tools?">
  No. ZenRows tools are added via MCP and are registered separately under the `mcp_zenrows_` prefix. They sit alongside Hermes's native tools and the agent uses whichever is best for the task.
</Accordion>

<Accordion title="Can I use ZenRows alongside Hermes's built-in browser tool?">
  Yes. Hermes has a native browser tool (available via Nous Portal's Tool Gateway) and ZenRows runs as a separate MCP-backed toolset. They coexist cleanly. For heavy-duty scraping with anti-bot evasion, ZenRows is the better choice; for simple navigation tasks you control, the native browser may be sufficient.
</Accordion>

<Accordion title="How does Hermes decide when to use ZenRows vs. a direct fetch?">
  Hermes reasons about the task. For pages that are known to be protected or dynamic, it will reach for ZenRows tools. You can also instruct it explicitly: "use ZenRows to scrape this URL."
</Accordion>

<Accordion title="Can I run Hermes and ZenRows on a remote server?">
  Yes. Hermes is designed to run anywhere: a VPS, a cloud VM, Docker, or serverless infrastructure via Daytona or Modal. The setup is identical: install Hermes, add ZenRows to `~/.hermes/config.yaml`, configure your messaging platform, and your scraping agent runs 24/7 without you needing to SSH in.
</Accordion>

<Accordion title="Does Hermes store scraped content across sessions?">
  Hermes can save content to skills and memory if you instruct it to. Scraped data that's useful as a reference can be persisted as a skill or written to a file. By default, raw scrape output stays in the current session.
</Accordion>

<Accordion title="Can I use the local stdio version of ZenRows MCP instead of the remote URL?">
  Yes. ZenRows supports both a remote HTTP server and a local stdio server via the `@zenrows/mcp` npm package. Both options expose the same tools and capabilities. The remote URL (`https://mcp.zenrows.com/mcp`) is recommended for Hermes since it requires no local installation. If you prefer the local stdio approach, you need Node.js installed and use this config instead:

  ```yaml YAML theme={null}
  mcp_servers:
      zenrows:
          command: "npx"
          args: ["-y", "@zenrows/mcp"]
          env:
              ZENROWS_API_KEY: "<YOUR_ZENROWS_API_KEY>"
  ```
</Accordion>

<Accordion title="Can I connect multiple MCP servers alongside ZenRows?">
  Yes. Hermes supports multiple MCP servers in the same config. Each gets its own named block under `mcp_servers`, and its tools are registered separately:

  ```yaml YAML theme={null}
  mcp_servers:
      zenrows:
          url: "https://mcp.zenrows.com/mcp"
          headers:
              Authorization: "Bearer <YOUR_ZENROWS_API_KEY>"
      github:
          command: "npx"
          args: ["-y", "@modelcontextprotocol/server-github"]
          env:
              GITHUB_PERSONAL_ACCESS_TOKEN: "<YOUR_TOKEN>"
  ```
</Accordion>

<Accordion title="Is there a cost to using ZenRows MCP with Hermes?">
  The ZenRows MCP server itself is free to connect. Each tool call is billed against your ZenRows subscription: `scrape` calls use Universal Scraper API credits, and `browser_*` calls use Scraping Browser credits. You can monitor usage on your [ZenRows Analytics page](https://app.zenrows.com/analytics).
</Accordion>

<Accordion title="Can I install ZenRows through the Hermes MCP catalog?">
  The Hermes catalog (`hermes mcp catalog`) lists Nous-approved MCP servers. ZenRows isn't currently in the catalog, so this guide walks through adding it manually to `config.yaml`. You can check the latest catalog entries by running `hermes mcp catalog` in your terminal.
</Accordion>