What makes Browser Automation notable?

1.9K downloads. Trust evidence available

How should Browser Automation be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

Browser Automation

Web scraping and browser automation using Puppeteer. Use when the user wants to extract data from websites, crawl pages, scrape dynamic content rendered by J... Skill: Browser Automation Owner: fasjdas Summary: Web scraping and browser automation using Puppeteer. Use when the user wants to extract data from websites, crawl pages, scrape dynamic content rendered by J... Tags: latest:1.0.0 Version history: v1.0.0 | 2026-05-18T14:57:47.390Z | user - Initial release of browser-automation skill powered by Puppeteer. - Enables web scraping, crawling, form automation, and screensho

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.9k

Updated

Oct 9, 2026

Version

1.0.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.9K downloads reported by the source. Last updated 10/9/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 9, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 9, 2026
Adoption signal: 1.9K downloadsadoption · observed Oct 9, 2026
Latest release: 1.0.0release · observed May 18, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17dayn2j0y3gje2rqg2bww9s584xgrp:browser-automation-puppeteer

Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-fasjdas-browser-automation-puppeteer/snapshot"

Documentation

CLAWHUB

18,272 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: browser-automation
description: Web scraping and browser automation using Puppeteer. Use when the user wants to extract data from websites, crawl pages, scrape dynamic content rendered by JavaScript, take screenshots, fill forms, or automate browser workflows. Triggers include "scrape", "crawl", "extract data from", "web harvest", "take screenshot of", or any request involving Puppeteer or headless browser automation.
---

# Browser Automation

Web scraping and browser automation powered by Puppeteer.

## When to Use

✅ **USE this skill when:**

- "Scrape data from [URL]"
- "Extract all [products/listings/items] from [website]"
- "Take a screenshot of [page]"
- "Crawl [website] and collect [info]"
- "Fill and submit [form]"
- Any JavaScript-rendered content that won't load without a browser

❌ **DON'T use this skill when:**

- Simple static pages → use `web_fetch` instead
- APIs available → fetch API directly
- Rate-limited sites → respect robots.txt

## Quick Start

```bash
# Install Puppeteer
npm install puppeteer

# Basic scraping
node scripts/scrape.js https://example.com
```

## Core Patterns

### Launch Browser

```javascript
const puppeteer = require('puppeteer');

async function scrape(url) {
  const browser = await puppeteer.launch({
    headless: 'new',
    args: ['--no-sandbox', '--disable-setuid-sandbox']
  });
  
  const page = await browser.newPage();
  await page.goto(url, { waitUntil: 'networkidle2' });
  
  // ... extract data ...
  
  await browser.close();
}
```

### Extract Text Content

```javascript
// Get all text from a selector
const titles = await page.$$eval('h2', els => els.map(el => el.textContent.trim()));

// Get text from single element
const price = await page.$eval('.price', el => el.textContent.trim());
```

### Extract HTML

```javascript
const html = await page.$eval('.product-list', el => el.innerHTML);
```

### Extract Attributes

```javascript
const links = await page.$$eval('a', els => els.map(el => ({
  text: el.textContent.trim(),
  href: el.getAttribute('href')
})));
```

### Wait for Content

```javascript
// Wait for selector
await page.waitForSelector('.results', { timeout: 10000 });

// Wait for network idle
await page.goto(url, { waitUntil: 'networkidle2' });

// Wait for function
await page.waitForFunction(() => document.querySelectorAll('.item').length > 10);
```

### Pagination

```javascript
async function scrapeWithPagination(baseUrl, maxPages = 5) {
  const browser = await puppeteer.launch({ headless: 'new' });
  const page = await browser.newPage();
  
  let results = [];
  
  for (let i = 1; i <= maxPages; i++) {
    const url = `${baseUrl}?page=${i}`;
    await page.goto(url, { waitUntil: 'networkidle2' });
    
    const items = await page.$$eval('.item', els => 
      els.map(el => el.textContent.trim())
    );
    
    if (items.length === 0) break;
    results.push(...items);
  }
  
  await browser.close();
  return results;
}
```

### Screenshots

```javascript
// Full page

README.md

# Browser Automation

Web scraping and browser automation skill using Puppeteer for AI assistants.

## Install

```bash
npm install puppeteer
```

## Scripts

### scrape.js — Extract text from a web page

```bash
node scripts/scrape.js <url> [selector]
```

**Examples:**

```bash
# Scrape all headings
node scripts/scrape.js https://news.ycombinator.com h2

# Scrape with default selector (body)
node scripts/scrape.js https://example.com

# Scrape specific elements
node scripts/scrape.js https://shop.example.com .product-item
```

**Output:** JSON array of extracted content

---

### screenshot.js — Capture screenshots

```bash
node scripts/screenshot.js <url> [output.png] [--full]
```

**Examples:**

```bash
# Basic screenshot (viewport only)
node scripts/screenshot.js https://example.com

# Full page screenshot
node scripts/screenshot.js https://example.com full.png --full

# Custom output path
node scripts/screenshot.js https://example.com ./screenshots/page.png
```

**Options:**

- `output.png` — Output file path (default: screenshot.png)
- `--full` — Capture entire scrollable page

---

### crawl.js — Multi-page crawler

```bash
node scripts/crawl.js <url> <selector> [maxPages]
```

**Examples:**

```bash
# Crawl 5 pages of products
node scripts/crawl.js https://shop.example.com/products .product-item 5

# Crawl Hacker News
node scripts/crawl.js https://news.ycombinator.com .athing 3

# Default max pages is 10
node scripts/crawl.js https://example.com/blog .post-title
```

**Output:** JSON array of all extracted items across pages

---

## Node.js API

Use the skill's patterns directly in your own scripts:

```javascript
const puppeteer = require('puppeteer');

async function scrape(url, selector) {
  const browser = await puppeteer.launch({
    headless: 'new',
    args: ['--no-sandbox', '--disable-setuid-sandbox']
  });
  
  const page = await browser.newPage();
  await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');
  
  await page.goto(url, { waitUntil: 'networkidle2' });
  
  const results = await page.$$eval(selector, els => 
    els.map(el => el.textContent.trim())
  );
  
  await browser.close();
  return results;
}

scrape('https://example.com', 'h1').then(console.log);
```

---

## Tips

- **Check robots.txt** before scraping: `curl example.com/robots.txt`
- **Add delays** between requests to avoid getting blocked
- **Use screenshots** to debug when selectors don't match
- **Set viewport** before taking screenshots: `await page.setViewport({ width: 1280, height: 800 })`

## Requirements

- Node.js 18+
- npm
- Puppeteer (installed via `npm install puppeteer`)

## License

MIT

_meta.json

{
  "ownerId": "kn7av1vf358r12x3h9g4w71r89831x43",
  "slug": "browser-automation-puppeteer",
  "version": "1.0.0",
  "publishedAt": 1779116267390
}

references/puppeteer-api.md

# Puppeteer API Reference

Complete reference for Puppeteer used in this skill.

## Browser Launch

```javascript
const browser = await puppeteer.launch({
  headless: 'new',           // 'new' = faster headless
  args: [
    '--no-sandbox',          // Required for Linux
    '--disable-setuid-sandbox',
    '--disable-dev-shm-usage',
    '--disable-accelerated-2d-canvas',
    '--no-first-run',
    '--no-zygote',
    '--disable-gpu'
  ]
});
```

## Page Navigation

```javascript
await page.goto(url, {
  waitUntil: 'networkidle2',  // Wait until network is idle
  timeout: 30000               // 30s timeout
});

// Alternative wait strategies:
// 'load' - default
// 'domcontentloaded' - faster
// 'networkidle0' - stricter
// 'networkidle' - strictest
```

## Content Extraction

### $$eval (Multiple Elements)

```javascript
const data = await page.$$eval('selector', elements => {
  return elements.map(el => ({
    text: el.textContent.trim(),
    href: el.href,
    src: el.src
  }));
});
```

### $eval (Single Element)

```javascript
const text = await page.$eval('.title', el => el.textContent.trim());
```

### Inner HTML/Text

```javascript
const html = await page.$eval('.container', el => el.innerHTML);
const text = await page.$eval('.container', el => el.innerText);
```

## Waiting

### Wait for Selector

```javascript
await page.waitForSelector('.loaded-content', { timeout: 10000 });
```

### Wait for Function

```javascript
await page.waitForFunction(() => {
  return document.querySelectorAll('.item').length >= 10;
});
```

### Wait for Navigation

```javascript
await Promise.all([
  page.waitForNavigation(),
  page.click('.submit-btn')
]);
```

## Click & Type

```javascript
await page.click('#submit-button');
await page.type('#search-input', 'search term');
await page.focus('#input');
await page.keyboard.press('Enter');
```

## Evaluate (Raw JS in Page Context)

```javascript
const result = await page.evaluate(() => {
  const items = document.querySelectorAll('.item');
  return Array.from(items).map(item => ({
    title: item.querySelector('h3')?.textContent,
    price: item.querySelector('.price')?.textContent
  }));
});
```

## Screenshots

```javascript
// Full page
await page.screenshot({ path: 'full.png', fullPage: true });

// Specific area
await page.screenshot({ path: 'header.png', clip: { x: 0, y: 0, width: 800, height: 200 } });

// Element
const el = await page.$('.chart');
await el.screenshot({ path: 'chart.png' });
```

## PDF Generation

```javascript
await page.pdf({
  path: 'page.pdf',
  format: 'A4',
  printBackground: true
});
```

## Handle New Tabs/Windows

```javascript
const [newPage] = await Promise.all([
  new Promise(resolve => browser.once('targetcreated', target => resolve(target.page()))),
  page.click('a[target="_blank"]')
]);
await newPage.waitForSelector('.content');
```

## Request Interception

```javascript
await page.setRequestInterception(true);
page.on('request', req => {
  if (req.resourceType() === 'image'

skill-card.md

## Description:

Web scraping and browser automation using Puppeteer for extracting data from websites, crawling pages, scraping JavaScript-rendered content, taking screenshots, filling forms, and automating browser workflows.

This skill is ready for commercial/non-commercial use.

## Publisher:

[fasjdas](https://clawhub.ai/user/fasjdas)

### License/Terms of Use:

MIT

## Use Case:

Developers and engineers use this skill to guide browser-based scraping, crawling, screenshot capture, form interaction, and automation for pages that require JavaScript rendering.

### Deployment Geography for Use:

Global

## Known Risks and Mitigations:

Risk: Browser automation against arbitrary URLs can expose the agent environment to untrusted web content.

Mitigation: Run the skill only in an isolated, unprivileged environment with limited network access and restrict allowed URL targets where possible.

Risk: The browser process could access secrets, credentials, cookies, or internal services if they are available in the execution environment.

Mitigation: Do not expose secrets or internal services to the browser process, and require explicit user confirmation before submitting forms or using credentials or cookies.

Risk: Installing Puppeteer without a reviewed lockfile can introduce unpinned dependency changes.

Mitigation: Pin Puppeteer and related packages with a reviewed lockfile before production use.

## Reference(s):

- [Puppeteer API Reference](references/puppeteer-api.md)
- [ClawHub skill page](https://clawhub.ai/fasjdas/skills/browser-automation-puppeteer)
- [Publisher profile](https://clawhub.ai/user/fasjdas)

## Skill Output:

**Output Type(s):** [text, markdown, code, shell commands, configuration, guidance]

**Output Format:** [Markdown guidance with JavaScript and shell command examples; included scripts emit JSON or PNG files when run.]

**Output Parameters:** [1D]

**Other Properties Related to Output:** [May produce browser screenshots, extracted page data, crawler results, and Puppeteer automation snippets.]

## Skill Version(s):

1.0.0 (source: server release metadata)

## Ethical Considerations:

Users should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.

Github ReposUpdated 10h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.