Clawpod

Read any website or search Google, even when sites block bots or are geo-restricted. Handles CAPTCHAs, JavaScript rendering, and anti-bot protection server-s...

installs

stars

karma

SkillRank score ↗

8.2/ 10

evaluated by implexa, claude-haiku-4-5 · 2026-06-10

clawpod fetches blocked websites and google search results via residential proxies, handling javascript rendering and captchas. returns html or structured json with configurable device, language, and geo-targeting.

structure

9.0

trigger phrases

9.0

procedure

9.0

edge cases

7.0

documentation

8.0

strengths

view original SKILL.md from clawhubclick to expand

---
name: clawpod
description: Read any website or search Google, even when sites block bots or are geo-restricted. Handles CAPTCHAs, JavaScript rendering, and anti-bot protection server-side via residential proxies. Returns HTML or structured JSON.
allowed-tools: Bash(curl --proto =https *)
homepage: https://clawpod.joinmassive.com
metadata: {"openclaw":{"emoji":"🔓","homepage":"https://clawpod.joinmassive.com","primaryEnv":"MASSIVE_UNBLOCKER_TOKEN","requires":{"bins":["curl"],"env":["MASSIVE_UNBLOCKER_TOKEN"]}}}
---

# Massive Unblocker

Fetch and extract content from URLs or search Google using Massive's Unblocker APIs. Handles JS rendering, CAPTCHAs, and retries automatically. Returns HTML or structured JSON.

## When to Use This Skill

Use ClawPod when:
- A standard web fetch fails, returns a CAPTCHA page, or gives incomplete/blocked content
- The target site is known to block bots (e.g., news sites, social media, e-commerce, search engines)
- The user needs content from a geo-restricted page
- The page requires JavaScript rendering that a standard fetch can't handle
- The user explicitly asks to bypass anti-bot protections or scrape a difficult site
- The user needs Google search results (organic and paid) as structured data or HTML
- A built-in web search tool returns incomplete or blocked results
- The user needs localized or geo-targeted Google search results

If another fetch or search tool fails or returns blocked content, suggest retrying with ClawPod.

## Setup

Check for the API token:

```bash
[ -n "$MASSIVE_UNBLOCKER_TOKEN" ] && echo "TOKEN=SET" || echo "TOKEN=MISSING"
```

If token is `MISSING`, stop and tell the user:

> To use ClawPod, you need an API token. It takes under a minute to set up:
>
> 1. Sign up at **clawpod.joinmassive.com/signup** - when you sign up, you get 1,000 free credits. No credit card required.
> 2. You'll get access to Massive's Unblocker network: millions of residential IPs across 195 countries, with automatic CAPTCHA solving, JS rendering, and anti-bot bypass built in.
> 3. Once you have your token, paste it here or set it as an environment variable (`export MASSIVE_UNBLOCKER_TOKEN="your-token"`).

Do not proceed until the token is available.

## How It Works

Two endpoints. Both use `GET` requests with the same auth token.

**Browser** — fetch and render any URL, returns HTML:
```
https://unblocker.joinmassive.com/browser?url=<encoded-url>
```

**Search** — Google search results as HTML or structured JSON:
```
https://unblocker.joinmassive.com/search?terms=<encoded-terms>
```

Auth header: `Authorization: Bearer $MASSIVE_UNBLOCKER_TOKEN`

## Fetching a URL

```bash
curl --proto =https -s -G --data-urlencode "url=THE_URL" \
  -H "Authorization: Bearer $MASSIVE_UNBLOCKER_TOKEN" \
  "https://unblocker.joinmassive.com/browser"
```

Replace `THE_URL` with the actual URL. `curl --data-urlencode` handles URL-encoding automatically.

## Fetching Multiple URLs

Loop through them sequentially. Each call can take up to 2 minutes (CAPTCHA solving, retries).

```bash
URLS=(
  "https://example.com/page1"
  "https://example.com/page2"
)

for url in "${URLS[@]}"; do
  echo "=== $url ==="
  curl --proto =https -s -G --data-urlencode "url=$url" \
    -H "Authorization: Bearer $MASSIVE_UNBLOCKER_TOKEN" \
    "https://unblocker.joinmassive.com/browser"
done
```

## Searching Google

Search endpoint. `GET` request. Returns all organic and paid Google results as HTML or structured JSON.

```
https://unblocker.joinmassive.com/search?terms=<encoded-terms>
```

Auth header: `Authorization: Bearer $MASSIVE_UNBLOCKER_TOKEN` (same token as browser fetching)

### Basic Search

```bash
curl --proto =https -s -H "Authorization: Bearer $MASSIVE_UNBLOCKER_TOKEN" \
  "https://unblocker.joinmassive.com/search?terms=foo+bar+baz&format=json"
```

Replace `foo+bar+baz` with the search query. Spaces must be replaced with `+` or `%20`.

### Search with Options

```bash
curl --proto =https -s -H "Authorization: Bearer $MASSIVE_UNBLOCKER_TOKEN" \
  "https://unblocker.joinmassive.com/search?terms=vpn+comparison&format=json&size=100&offset=20"
```

### Search Parameters

| Parameter | Required | Values | Default | Use when |
|-----------|----------|--------|---------|----------|
| `terms` | yes | search query (`+` for spaces) | — | Always required |
| `format` | no | `html`, `json` | `html` | Use `json` for structured results |
| `serps` | no | `1` to `10` | `1` | Need multiple pages of results |
| `size` | no | `0` to `100` | unset | Control results per page |
| `offset` | no | `0` to `100` | `0` | Skip initial results |
| `language` | no | name, ISO code, or Google code | unset | Localize search language |
| `uule` | no | encoded location string | unset | Geo-target the search location |
| `expiration` | no | `0` to N (days) | `1` | Set `0` to bypass cache |
| `subaccount` | no | up to 255 chars | unset | Separate billing |

### JSON Output

When `format=json`, results are returned as structured nested objects with organic results, paid results, and metadata parsed out — no HTML parsing needed.

### Search Tips

- **Always use `format=json`** when possible — it returns structured data that's easier to work with than raw HTML.
- **Use `size=10`** for a quick overview, `size=100` for comprehensive results.
- **Use `offset`** to paginate through results beyond the first page.
- **Use `language`** to get results in a specific language (e.g., `language=es` for Spanish).
- **Live searches take a few seconds** on average but may take up to 120 seconds if retries are needed.

## Browser Parameters

Append to the `/browser` query string as needed:

| Parameter | Values | Default | Use when |
|-----------|--------|---------|----------|
| `format` | `rendered`, `raw` | `rendered` | Use `raw` to skip JS rendering (faster) |
| `expiration` | `0` to N (days) | `1` | Set `0` to bypass cache |
| `delay` | `0.1` to `10` (seconds) | none | Page needs extra time to load dynamic content |
| `device` | device name string | desktop | Need mobile-specific content |
| `ip` | `residential`, `isp` | `residential` | ISP IPs for less detection |

Example with browser options:

```bash
curl --proto =https -s -G --data-urlencode "url=THE_URL" \
  -H "Authorization: Bearer $MASSIVE_UNBLOCKER_TOKEN" \
  "https://unblocker.joinmassive.com/browser?expiration=0&delay=2"
```

## Error Handling

- **401 Unauthorized** — Token is invalid or missing. Tell the user: "Your ClawPod API token appears to be invalid or expired. You can get a new one at **clawpod.joinmassive.com**."
- **Empty response** — The page may need more time to render. Retry with `delay=3`. If still empty, try `format=rendered` (the default). Let the user know: "The page was slow to load — I've retried with a longer delay."
- **Timeout or connection error** — Some pages are very slow. Let the user know the request timed out and offer to retry. Do not silently fail.

## Tips

- If content looks different from expected, try `device=mobile` for the mobile version.
- For fresh results on a previously fetched URL, use `expiration=0` to bypass cache.
- If still blocked, try `ip=isp` — ISP-grade IPs have lower detection rates.
- For heavy dynamic content (SPAs, infinite scroll), increase `delay` for more render time.

## Rules

- **One fetch = one result.** The content is in the output. Do not re-fetch the same URL.
- **URL-encode the target URL.** Always.
- **Sequential for multiple URLs.** No parallel requests.
- **2 minute timeout per request.** If a page or search is slow, it's the API handling retries/CAPTCHAs.
- **Use `format=json` for search.** Structured JSON is preferred over HTML for search results.
- **Form-encode search terms.** Replace spaces with `+` or `%20` in the `terms` parameter.

don't have the plugin yet? install it then click "run inline in claude" again.

restructured into implexa's six mandatory components, added explicit decision points for auth/timeout/cache handling, clarified edge cases (empty responses, rate limits, 2 minute timeout), improved voice consistency to tech-bro x cadence, preserved all original procedure faithfully.

intent

clawpod fetches and searches content from any website or Google, even when sites block bots, require JavaScript rendering, or are geo-restricted. it handles CAPTCHAs, anti-bot detection, and residential proxy rotation server-side. use this when standard web fetch fails with blocked content, CAPTCHA pages, or incomplete results; when you need structured Google search results; or when the target requires JavaScript rendering that a basic HTTP request can't handle.

inputs

environment variable:

MASSIVE_UNBLOCKER_TOKEN (required): API token from clawpod.joinmassive.com/signup. get 1,000 free credits on signup, no credit card required.

external connection:

Massive Unblocker API (https://unblocker.joinmassive.com/browser and https://unblocker.joinmassive.com/search). uses residential IPs across 195 countries, automatic CAPTCHA solving, JS rendering.

tools required:

curl (with HTTPS support via --proto =https)

for browser fetching:

target URL (plain, not encoded; curl will handle encoding)
optional: format (rendered or raw), expiration (0 to N days), delay (0.1 to 10 seconds), device (device name), ip (residential or isp)

for Google search:

search terms (spaces as + or %20)
optional: format (html or json), serps (1 to 10), size (0 to 100), offset (0 to 100), language (language name or code), uule (encoded location string), expiration (0 to N days), subaccount (billing separation)

procedure

verify token availability:

run token check: [ -n "$MASSIVE_UNBLOCKER_TOKEN" ] && echo "TOKEN=SET" || echo "TOKEN=MISSING"
if token is missing, stop and tell the user: "to use clawpod, you need an api token. sign up at clawpod.joinmassive.com/signup (under a minute, no credit card). you get 1,000 free credits. once you have your token, set it: export MASSIVE_UNBLOCKER_TOKEN="your-token". then retry."
if token is set, proceed to fetch or search.

fetch a single URL:

inputs: target URL, auth token.
construct curl command: curl --proto =https -s -G --data-urlencode "url=TARGET_URL" -H "Authorization: Bearer $MASSIVE_UNBLOCKER_TOKEN" "https://unblocker.joinmassive.com/browser"
execute and capture output (HTML content).
outputs: full rendered HTML or raw HTML (depending on format parameter), status via HTTP code.

fetch multiple URLs:

inputs: array of URLs, auth token.
loop through each URL sequentially (no parallel requests).
for each: execute step 5 above, allow up to 2 minutes per request (CAPTCHA solving, retries included).
outputs: HTML for each URL, in order. collect all outputs.

search Google:

inputs: search terms, auth token, optional search parameters.
form-encode search terms (replace spaces with + or %20).
construct curl command: curl --proto =https -s -H "Authorization: Bearer $MASSIVE_UNBLOCKER_TOKEN" "https://unblocker.joinmassive.com/search?terms=ENCODED_TERMS&format=json&size=10" (add other params as needed).
execute and capture output (JSON or HTML).
outputs: structured JSON (preferred) or HTML with organic results, paid results, metadata parsed.

handle options for browser fetch:

if content differs from expected, add &device=mobile to fetch mobile version.
if page needs extra render time, add &delay=3 (or higher).
if you need fresh results, add &expiration=0 to bypass cache.
if still blocked, add &ip=isp to use ISP-grade IPs (lower detection rate).
if page is JavaScript-heavy (SPA, infinite scroll), increase delay parameter.

handle options for search:

always use format=json when possible (structured data is easier to parse than HTML).
use size=10 for quick overview, size=100 for comprehensive results.
use offset and serps to paginate through results beyond first page.
use language=LANG_CODE to get results in specific language (e.g., es for spanish).
live searches take a few seconds on average, up to 120 seconds if retries are needed.

decision points

if token is missing: stop and provide sign-up instructions. do not attempt fetch or search without token.

if HTTP 401 Unauthorized is returned: token is invalid or expired. tell the user: "your clawpod api token is invalid or expired. get a new one at clawpod.joinmassive.com."

if response is empty: the page may need more render time. retry with &delay=3. if still empty, try &format=rendered (default). inform the user: "the page was slow to load, i retried with a longer delay."

if timeout or connection error occurs: some pages are very slow. inform the user the request timed out and offer to retry. do not silently fail. never exceed 2 minute timeout per request.

if content looks blocked or incomplete: try &device=mobile for mobile version. if still blocked, try &ip=isp for isp-grade IPs (lower detection). if content still differs, offer to retry with different device or IP option.

if you need fresh search or browser results: check whether cache is stale. if so, add &expiration=0 to bypass cache and fetch live.

output contract

browser fetch returns:

rendered HTML (default format=rendered) or raw HTML (format=raw)
complete page source with all JavaScript-rendered content included
on success: HTTP 200, full HTML body in stdout
on auth failure: HTTP 401, error message in response
on timeout or error: HTTP error code with descriptive message

search returns:

format=json (preferred): nested JSON object with structured fields: organic results (array of title, url, snippet), paid results (array of ad blocks), metadata (search terms, result count, execution time)
format=html: raw HTML search results page (requires parsing)
on success: HTTP 200, results in stdout
on auth failure: HTTP 401, error message

file location: all output is streamed to stdout; capture with redirection if storage needed (e.g., > output.html or > results.json)

outcome signal

successful browser fetch: you receive full HTML content in stdout, page renders completely with dynamic content loaded, no "blocked" or "CAPTCHA" pages returned. if you see expected content in the HTML, the fetch worked.

successful search: you receive JSON or HTML with organic and paid results parsed, result count matches query expectations, no "blocked" or CAPTCHA pages. if you can extract titles, URLs, snippets from the output, the search worked.

retry signal: if content is incomplete, empty, or looks like a CAPTCHA page, the first attempt failed. retry with appropriate parameters (delay, device, ip, expiration).

user signal: tell the user the page was fetched or the search completed, show sample results, and confirm content was not blocked. if any retry was needed, mention it explicitly: "the first fetch hit anti-bot protection. i retried with a mobile device request and got the full page."

Clawpod

related skills

intent

inputs

procedure

decision points

output contract

outcome signal