From ce1a4962d5b201dba2c20a32d39cfd4b4796bd0e Mon Sep 17 00:00:00 2001
From: meirk-brd <themeirmedia@gmail.com>
Date: Thu, 30 Apr 2026 19:08:46 +0300
Subject: [PATCH] feat(brightdata-scrape): add Bright Data web scraping power
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds a Kiro power that detects a project's stack and adds production-ready
web scraping in the right shape — a reusable module, an API route, or an
agent tool — backed by Bright Data's Web Unlocker, SERP API, Web Scraper
API, and Browser API. Also wires the Bright Data MCP server into the
project so any AI agent that runs against the project (Claude Code,
Cursor, Cline, Kiro itself) gains live web tools.

The power runs a four-phase orchestrated workflow with confirmation
gates between phases:

1. Detect & plan — inspect manifest (package.json, pyproject.toml,
   requirements.txt, go.mod, Cargo.toml, etc.), classify the stack,
   pick a single integration pattern (module / route / tool), and
   propose a plan.
2. Scraping playbook — pick the right Bright Data API and selectors:
   pre-built scraper if one exists for the domain, Web Unlocker for
   static HTML, Browser API for JS-rendered or interactive content,
   SERP API for search results.
3. Integrate — fill the right code template and write generated files
   into the user's project (with a confirmation gate before any file
   is written).
4. MCP & verify — wire the Bright Data MCP server into
   .kiro/settings/mcp.json, run a one-page smoke test, and write a
   README wrap-up section.

First-class language support: Python and TypeScript/JavaScript. Other
languages get a generic Web Unlocker curl/HTTP template that the user
adapts.

Frameworks covered by canonical templates:
- Web (route pattern): Next.js (App Router + Pages Router), Express,
  Fastify, Hono, Koa, FastAPI, Flask, Django.
- Agent (tool pattern): LangChain (TS + Python), Anthropic SDK
  (TS + Python), OpenAI SDK (TS + Python), Mastra, Vercel AI SDK.
- Module: bs4 + stdlib (Python), cheerio + fetch-only (TypeScript).

Files added:
- brightdata-scrape/POWER.md — frontmatter + onboarding + orchestrator
  pointer.
- brightdata-scrape/mcp.json — wires the remote Bright Data MCP server
  with the API token interpolated from BRIGHTDATA_API_KEY.
- brightdata-scrape/steering/scrape-workflow.md — orchestrator.
- brightdata-scrape/steering/phase{1..4}-*.md — the four phase steering
  files, loaded on demand via readSteering.
- brightdata-scrape/templates/{module,route,tool,fallback}/* — 22
  canonical code templates with {{TARGET_NAME}} / {{TARGET_URL}} /
  {{SELECTORS}} / etc. placeholders the orchestrator fills at runtime.
- README.md — power entry inserted alphabetically.
---
 README.md                                     |   7 +
 brightdata-scrape/POWER.md                    |  85 ++++++++++
 brightdata-scrape/mcp.json                    |   8 +
 .../steering/phase1-detect-and-plan.md        | 160 ++++++++++++++++++
 .../steering/phase2-scraping-playbook.md      |  85 ++++++++++
 .../steering/phase3-integrate.md              | 134 +++++++++++++++
 .../steering/phase4-mcp-and-verify.md         | 113 +++++++++++++
 brightdata-scrape/steering/scrape-workflow.md |  65 +++++++
 brightdata-scrape/templates/fallback/curl.sh  |  27 +++
 brightdata-scrape/templates/module/py-bs4.py  | 100 +++++++++++
 .../templates/module/py-stdlib.py             | 140 +++++++++++++++
 .../templates/module/ts-cheerio.ts            |  80 +++++++++
 .../templates/module/ts-fetch.ts              |  91 ++++++++++
 brightdata-scrape/templates/route/django.py   |  32 ++++
 brightdata-scrape/templates/route/express.ts  |  27 +++
 brightdata-scrape/templates/route/fastapi.py  |  26 +++
 brightdata-scrape/templates/route/fastify.ts  |  35 ++++
 brightdata-scrape/templates/route/flask.py    |  27 +++
 brightdata-scrape/templates/route/hono.ts     |  29 ++++
 brightdata-scrape/templates/route/koa.ts      |  33 ++++
 .../templates/route/next-app-router.ts        |  23 +++
 .../templates/route/next-pages-router.ts      |  36 ++++
 .../templates/tool/anthropic-sdk-py.py        |  49 ++++++
 .../templates/tool/anthropic-sdk-ts.ts        |  43 +++++
 .../templates/tool/langchain-py.py            |  44 +++++
 .../templates/tool/langchain-ts.ts            |  32 ++++
 brightdata-scrape/templates/tool/mastra.ts    |  37 ++++
 brightdata-scrape/templates/tool/openai-py.py |  53 ++++++
 brightdata-scrape/templates/tool/openai-ts.ts |  46 +++++
 .../templates/tool/vercel-ai-sdk.ts           |  36 ++++
 30 files changed, 1703 insertions(+)
 create mode 100644 brightdata-scrape/POWER.md
 create mode 100644 brightdata-scrape/mcp.json
 create mode 100644 brightdata-scrape/steering/phase1-detect-and-plan.md
 create mode 100644 brightdata-scrape/steering/phase2-scraping-playbook.md
 create mode 100644 brightdata-scrape/steering/phase3-integrate.md
 create mode 100644 brightdata-scrape/steering/phase4-mcp-and-verify.md
 create mode 100644 brightdata-scrape/steering/scrape-workflow.md
 create mode 100644 brightdata-scrape/templates/fallback/curl.sh
 create mode 100644 brightdata-scrape/templates/module/py-bs4.py
 create mode 100644 brightdata-scrape/templates/module/py-stdlib.py
 create mode 100644 brightdata-scrape/templates/module/ts-cheerio.ts
 create mode 100644 brightdata-scrape/templates/module/ts-fetch.ts
 create mode 100644 brightdata-scrape/templates/route/django.py
 create mode 100644 brightdata-scrape/templates/route/express.ts
 create mode 100644 brightdata-scrape/templates/route/fastapi.py
 create mode 100644 brightdata-scrape/templates/route/fastify.ts
 create mode 100644 brightdata-scrape/templates/route/flask.py
 create mode 100644 brightdata-scrape/templates/route/hono.ts
 create mode 100644 brightdata-scrape/templates/route/koa.ts
 create mode 100644 brightdata-scrape/templates/route/next-app-router.ts
 create mode 100644 brightdata-scrape/templates/route/next-pages-router.ts
 create mode 100644 brightdata-scrape/templates/tool/anthropic-sdk-py.py
 create mode 100644 brightdata-scrape/templates/tool/anthropic-sdk-ts.ts
 create mode 100644 brightdata-scrape/templates/tool/langchain-py.py
 create mode 100644 brightdata-scrape/templates/tool/langchain-ts.ts
 create mode 100644 brightdata-scrape/templates/tool/mastra.ts
 create mode 100644 brightdata-scrape/templates/tool/openai-py.py
 create mode 100644 brightdata-scrape/templates/tool/openai-ts.ts
 create mode 100644 brightdata-scrape/templates/tool/vercel-ai-sdk.ts

diff --git a/README.md b/README.md
index 3ebb744..199aa91 100644
--- a/README.md
+++ b/README.md
@@ -56,6 +56,13 @@ Documentation is available at https://kiro.dev/docs/powers/
 
 ---
 
+### brightdata-scrape
+**Add web scraping to any app with Bright Data** - Detects your project's stack (Python, TypeScript, 9 web frameworks, 8 agent frameworks) and adds production-ready Bright Data web scraping in the right shape — a reusable module, an API route, or an agent tool — backed by Web Unlocker, SERP API, Web Scraper API, and Browser API. Wires the Bright Data MCP server into the project so any AI agent that runs against the project (Claude Code, Cursor, Cline, Kiro itself) gains live web tools.
+
+**MCP Servers:** brightdata
+
+---
+
 ### cloud-architect
 **Build infrastructure on AWS** - Build AWS infrastructure with CDK in Python following AWS Well-Architected framework best practices.
 
diff --git a/brightdata-scrape/POWER.md b/brightdata-scrape/POWER.md
new file mode 100644
index 0000000..a13d202
--- /dev/null
+++ b/brightdata-scrape/POWER.md
@@ -0,0 +1,85 @@
+---
+name: "brightdata-scrape"
+displayName: "Add web scraping to any app with Bright Data"
+description: "Detect your project's stack and add production-ready web scraping — generates the right integration pattern (module, API route, or agent tool), wires Bright Data MCP into your project, handles pagination and bot detection."
+keywords: ["scrape", "scraping", "scraper", "crawl", "crawler", "web-data", "extract", "extract-data", "competitor", "pricing-monitor", "lead-generation", "amazon", "linkedin", "instagram", "tiktok", "youtube", "serp", "google-search", "search-engine", "brightdata", "bright-data", "web-unlocker", "browser-api", "captcha", "bot-detection", "pagination", "agent-tools", "mcp"]
+author: "Bright Data"
+---
+
+# Add web scraping to any app with Bright Data
+
+This power detects what kind of project you're working on and adds production-ready scraping in the right shape — a reusable module, an API route, or an agent tool — backed by Bright Data's Web Unlocker, Web Scraper API, Browser API, and SERP API. It also wires the Bright Data MCP server into your project so any AI agent that runs against the project (Claude Code, Cursor, Cline, Kiro itself) gains live web tools.
+
+**It works on any language**, but Python and TypeScript/JavaScript get first-class code generation. Other languages get a generic `curl`/HTTP template that you adapt.
+
+## What you can do
+
+- "Scrape competitor prices from example.com daily into my Next.js dashboard"
+- "Add a `/api/scrape` route to my Express app"
+- "Give my Claude SDK agent a tool that searches Google and reads results"
+- "Extract all product listings from this Shopify store"
+- "Monitor LinkedIn profiles of my pipeline contacts"
+
+## Onboarding
+
+Before using this power, complete the following.
+
+### Step 1: Get a Bright Data API token
+
+Sign up (or log in) at [Sign up at brightdata.com](https://brightdata.com). Generate an API token at [API token settings](https://brightdata.com/cp/setting/users). The free tier includes **5,000 requests per month** including Pro tools.
+
+### Step 2: Configure the token (pick one)
+
+**Option A — Env var (recommended for CI / production):**
+
+```bash
+export BRIGHTDATA_API_KEY=<your-token>
+```
+
+Add to your shell profile (`.zshrc`, `.bashrc`) or a project `.env` file. The generated `mcp.json` references `${BRIGHTDATA_API_KEY}`, so this works automatically.
+
+**Option B — Hardcoded in user-level Kiro config:**
+
+Edit `~/.kiro/settings/mcp.json` and add:
+
+```json
+{
+  "mcpServers": {
+    "brightdata": {
+      "url": "https://mcp.brightdata.com/mcp?token=YOUR_TOKEN_HERE",
+      "disabled": false
+    }
+  }
+}
+```
+
+This makes Bright Data MCP available in every Kiro project on your machine.
+
+### Step 3 (optional): Set up an Unlocker zone
+
+The default Web Unlocker zone is named `unblocker` on new accounts. If you've renamed it or hit "no zone" errors, set:
+
+```bash
+export BRIGHTDATA_UNLOCKER_ZONE=<your-zone-name>
+```
+
+Or create / rename a zone at [zone management page](https://brightdata.com/cp/zones).
+
+---
+
+## How to use this power
+
+For any scraping task, **always** read the orchestrator steering file first:
+
+```
+Call action "readSteering" with powerName="brightdata-scrape", steeringFile="scrape-workflow.md"
+```
+
+The orchestrator runs four phases in sequence with confirmation gates between each:
+
+1. **Detect & plan** — inspect the project, pick the right integration pattern, ask what to scrape.
+2. **Scraping playbook** — pick the right Bright Data API and selectors based on the target site.
+3. **Integrate** — generate the scraper module, API route, or agent tool into the user's project.
+4. **MCP & verify** — wire the Bright Data MCP server, run a smoke test, write a README snippet.
+
+**Do NOT improvise. Do NOT skip phases.** The steering files contain the exact instructions for each.
diff --git a/brightdata-scrape/mcp.json b/brightdata-scrape/mcp.json
new file mode 100644
index 0000000..b42f8da
--- /dev/null
+++ b/brightdata-scrape/mcp.json
@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "brightdata": {
+      "type": "http",
+      "url": "https://mcp.brightdata.com/mcp?token=${BRIGHTDATA_API_KEY}"
+    }
+  }
+}
diff --git a/brightdata-scrape/steering/phase1-detect-and-plan.md b/brightdata-scrape/steering/phase1-detect-and-plan.md
new file mode 100644
index 0000000..80302bb
--- /dev/null
+++ b/brightdata-scrape/steering/phase1-detect-and-plan.md
@@ -0,0 +1,160 @@
+# Phase 1: Detect & Plan
+
+Inspect the user's workspace, classify it, and propose a single integration pattern. Confirm with the user before proceeding to Phase 2.
+
+## Step 1: Manifest detection
+
+Look for these manifest files at the workspace root, in order:
+
+| Manifest | Language |
+|----------|----------|
+| `package.json` | TypeScript / JavaScript |
+| `pyproject.toml`, `requirements.txt`, `Pipfile` | Python |
+| `go.mod` | Go |
+| `Cargo.toml` | Rust |
+| `Gemfile` | Ruby |
+| `pom.xml`, `build.gradle` | Java / Kotlin |
+| `composer.json` | PHP |
+
+**No manifest found** → **greenfield mode**. Skip to Step 4 and ask the user: "Python or TypeScript?"
+
+**Multiple manifests in subdirectories (monorepo)** → ask the user which sub-project to integrate into. Do **not** pick automatically.
+
+## Step 2: Stack signature
+
+Within the chosen manifest, look for these dependency signatures:
+
+### Web framework dependencies (route pattern)
+
+**TypeScript/JavaScript** — look in `dependencies` and `devDependencies`:
+- `next`, `next.js` → Next.js
+- `express` → Express
+- `fastify` → Fastify
+- `hono` → Hono
+- `koa`, `koa-router` → Koa
+- `@nestjs/core` → NestJS
+- `remix`, `@remix-run/react` → Remix
+
+**Python** — look in `pyproject.toml` `[project.dependencies]` or `requirements.txt`:
+- `fastapi` → FastAPI
+- `flask` → Flask
+- `django` → Django
+- `aiohttp` → aiohttp
+- `starlette` → Starlette
+
+### Agent framework dependencies (agent tool pattern)
+
+**TypeScript/JavaScript:**
+- `langchain`, `@langchain/*` → LangChain
+- `@anthropic-ai/sdk` → Anthropic SDK
+- `openai` → OpenAI SDK
+- `mastra`, `@mastra/*` → Mastra
+- `@ai-sdk/*`, `ai` → Vercel AI SDK
+- `@modelcontextprotocol/sdk` → MCP SDK
+
+**Python:**
+- `langchain`, `langchain-*` → LangChain
+- `anthropic` → Anthropic SDK
+- `openai` → OpenAI SDK
+- `llama-index` → LlamaIndex
+- `crewai` → CrewAI
+- `mcp` → MCP SDK
+
+## Step 3: Pick the single pattern
+
+Apply this decision tree:
+
+| Signals | Pattern | Template family |
+|---------|---------|-----------------|
+| Web framework deps present | **API route** | `templates/route/` |
+| Agent framework deps present, no web framework | **Agent tool** | `templates/tool/` |
+| Both web and agent | Ask the user which surface they prefer (route or tool) |
+| Library / CLI / unrecognized | **Module** | `templates/module/` |
+| Greenfield (no manifest) | **Module**, language asked above | `templates/module/` |
+
+**Inform the user of the choice but don't put it up for vote** — the detection is the choice.
+
+## Step 4: Targeted scraping question
+
+Ask in **one** message:
+
+> What do you want to scrape, and which fields? (Examples: 'product name + price + image from amazon.com search results', 'all job titles + companies from greenhouse.io listings'.) Roughly how many pages or items?
+
+Do NOT ask separately about pagination type, output format, or language preference:
+- **Pagination type** → discovered in Phase 2 reconnaissance.
+- **Output format** → defaults to typed return value; the caller decides what to do with it.
+- **Language** → already determined by manifest (TypeScript for `package.json`, Python for `pyproject.toml`/`requirements.txt`); greenfield is handled in Step 1.
+
+### Canonical framework slugs
+
+When emitting the decision record's `framework` field, use these exact slugs (so Phase 3's template lookup works):
+
+| Framework | Slug |
+|-----------|------|
+| Next.js (App Router) | `next-app-router` |
+| Next.js (Pages Router) | `next-pages-router` |
+| Express | `express` |
+| Fastify | `fastify` |
+| Hono | `hono` |
+| Koa | `koa` |
+| NestJS | `nestjs` |
+| Remix | `remix` |
+| FastAPI | `fastapi` |
+| Flask | `flask` |
+| Django | `django` |
+| aiohttp | `aiohttp` |
+| Starlette | `starlette` |
+| LangChain (TS) | `langchain-ts` |
+| LangChain (Python) | `langchain-py` |
+| Anthropic SDK (TS) | `anthropic-sdk-ts` |
+| Anthropic SDK (Python) | `anthropic-sdk-py` |
+| OpenAI SDK (TS) | `openai-ts` |
+| OpenAI SDK (Python) | `openai-py` |
+| Mastra | `mastra` |
+| Vercel AI SDK | `vercel-ai-sdk` |
+| LlamaIndex | `llama-index` |
+| CrewAI | `crewai` |
+
+If the detected framework isn't in this list, use the bare lowercase package name and tell the user a fallback template will be used.
+
+## Step 5: Present plan and wait for confirmation
+
+Format:
+
+```
+## Plan
+
+**Detected:** <stack signature, e.g., "Next.js 14 (App Router) project, TypeScript">
+**Pattern:** <module | API route | agent tool>
+**Scraping target:** <user's site/data>
+**Estimated volume:** <single | small (<50) | bulk (>=50)>
+
+**Phases I'll run:**
+  1. ✓ Detect & plan (this phase, just confirmed)
+  2. Scraping playbook — pick the right Bright Data API and selectors
+  3. Integrate — generate <files I'll write> in your project
+  4. MCP & verify — wire Bright Data MCP, run a smoke test
+
+Ready to proceed to Phase 2?
+```
+
+**WAIT for the user to confirm before returning control to the orchestrator.**
+
+## Output of this phase
+
+The orchestrator carries forward this decision record:
+
+```
+{
+  "language": "typescript" | "python" | "other",
+  "language_other_name": "<e.g., 'go'>" | null,
+  "pattern": "module" | "route" | "tool",
+  "framework": "<e.g., 'next-app-router', 'fastapi', 'anthropic-sdk-ts'>",
+  "target_url": "<user's site>",
+  "fields": ["<field1>", "<field2>", ...],
+  "volume": "single" | "small" | "bulk",
+  "monorepo_subproject": "<path>" | null
+}
+```
+
+Subsequent phases reference this record by name. If anything is missing from it, return to Phase 1.
diff --git a/brightdata-scrape/steering/phase2-scraping-playbook.md b/brightdata-scrape/steering/phase2-scraping-playbook.md
new file mode 100644
index 0000000..b4d8228
--- /dev/null
+++ b/brightdata-scrape/steering/phase2-scraping-playbook.md
@@ -0,0 +1,85 @@
+# Phase 2: Scraping Playbook (Condensed)
+
+Pick the right Bright Data API and selectors for the user's target. Output a decision record the next phase consumes.
+
+> This is a **condensed** version of the long-form `scraper-builder` skill. For deeper analysis (anti-bot escalation, multi-site parallelism, retry semantics, browser-session reuse), the brightdata-plugin `scraper-builder` skill is the reference. This phase is a working subset.
+
+## Step 1: Decision tree (the four-line core)
+
+1. **Pre-built scraper exists for this domain?** → use **Web Scraper API** (zero parsing, structured JSON).
+2. **Static HTML, no interaction needed?** → use **Web Unlocker** (cheapest, simplest).
+3. **JS-rendered, or needs clicks/scrolls/form fills?** → use **Browser API** (full automation).
+4. **Search engine results page (Google/Bing/Yandex)?** → use **SERP API**.
+
+## Step 2: Pre-built scraper check
+
+One curl to discover all available pre-built scrapers:
+
+```bash
+curl -H "Authorization: Bearer $BRIGHTDATA_API_KEY" \
+     https://api.brightdata.com/datasets/list
+```
+
+Search the response for the target domain. If you find a match, record the `dataset_id` and **skip to Step 5** — no reconnaissance needed.
+
+Common matches: `amazon`, `linkedin`, `instagram`, `tiktok`, `youtube`, `facebook`, `twitter` (X), `reddit`, `walmart`, `ebay`, `crunchbase`, `zillow`, `booking`, `yahoo-finance`, `google-play`, `apple-app-store`.
+
+## Step 3: Reconnaissance (no pre-built scraper)
+
+### Step 3a: Fetch raw HTML
+
+```bash
+curl -X POST https://api.brightdata.com/request \
+  -H "Authorization: Bearer $BRIGHTDATA_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"zone": "'"${BRIGHTDATA_UNLOCKER_ZONE:-unblocker}"'", "url": "<TARGET_URL>", "format": "raw"}'
+```
+
+### Step 3b: Inspect
+
+- **Is the data in the HTML?** If yes → Web Unlocker is sufficient.
+- **Is the HTML mostly an empty shell** (`<div id="root"></div>`, `<div id="__next"></div>`, `ng-app`)? → content is client-rendered → **escalate to Browser API**.
+- **Does the page reference internal JSON endpoints** (look for `fetch('/api/...')`, `XMLHttpRequest`, hardcoded JSON in `<script>` tags)? → hitting the API endpoint directly via Web Unlocker is cleaner than HTML parsing.
+
+### Step 3c: Pick selectors (priority order)
+
+Prefer data attributes (`data-*`) over structural selectors — they survive redesigns.
+
+1. **`data-*` attributes** (e.g., `[data-testid="product-price"]`) — survive redesigns.
+2. **Semantic class names** (e.g., `.product-card .price`).
+3. **`id` attributes** — unique, but may change.
+4. **Structural selectors** (e.g., `div > span:nth-child(2)`) — fragile, **avoid**.
+
+## Step 4: Pagination patterns
+
+| Pattern | Detection | Implementation |
+|---------|-----------|----------------|
+| **URL-based** | URLs like `?page=N`, `?offset=20` | Loop `?page=N` until response has no items |
+| **Next-link** | HTML has `<a rel="next">` or `.pagination .next a` | Follow the next-link until absent |
+| **Cursor** | API responses include `next_cursor`, `next_token` | Loop with `?cursor=<token>` from previous response |
+| **Infinite scroll** | Content loads on scroll, no URL change | Browser API only — scroll until item count stops growing |
+
+## Step 5: Concurrency
+
+If the user said "bulk" volume in Phase 1 (50+ URLs), the generated code **must** use semaphore-bounded async with `CONCURRENCY=20` as the default. Sequential `time.sleep(1)` loops at this volume are unacceptable.
+
+## Step 6: Output the decision record
+
+Hand back to the orchestrator:
+
+```
+{
+  "approach": "web-unlocker" | "browser-api" | "pre-built" | "serp",
+  "dataset_id": "<if pre-built>" | null,
+  "selectors": { "<field>": "<css selector>", ... },
+  "pagination": "url-based" | "next-link" | "cursor" | "infinite-scroll" | "none",
+  "concurrency_required": true | false,
+  "hidden_api_endpoint": "<URL or null>"
+}
+```
+
+Confirm the choice with the user in one short message before returning to the orchestrator:
+
+> I'll use **Web Unlocker** with these selectors: `<list>`. Pagination is **URL-based**. Sound right?
+
+WAIT for confirmation. Then return.
diff --git a/brightdata-scrape/steering/phase3-integrate.md b/brightdata-scrape/steering/phase3-integrate.md
new file mode 100644
index 0000000..08ee56d
--- /dev/null
+++ b/brightdata-scrape/steering/phase3-integrate.md
@@ -0,0 +1,134 @@
+# Phase 3: Integrate
+
+Generate the scraper code into the user's project. The pattern (module / route / tool) was chosen in Phase 1; the API and selectors were chosen in Phase 2. This phase picks the right template, fills it, and writes files — but only after confirming each path with the user.
+
+## Step 1: Pick the template
+
+Use the Phase 1 decision record's `pattern` and `framework` fields. Look up the canonical template:
+
+| Pattern | Framework | Template path |
+|---------|-----------|---------------|
+| `module` | TypeScript | `templates/module/ts-cheerio.ts` (if user has cheerio) or `templates/module/ts-fetch.ts` (otherwise) |
+| `module` | Python | `templates/module/py-bs4.py` (if bs4 acceptable) or `templates/module/py-stdlib.py` (otherwise) |
+| `route` | Next.js App Router | `templates/route/next-app-router.ts` |
+| `route` | Next.js Pages Router | `templates/route/next-pages-router.ts` |
+| `route` | Express | `templates/route/express.ts` |
+| `route` | Fastify | `templates/route/fastify.ts` |
+| `route` | Hono | `templates/route/hono.ts` |
+| `route` | Koa | `templates/route/koa.ts` |
+| `route` | FastAPI | `templates/route/fastapi.py` |
+| `route` | Flask | `templates/route/flask.py` |
+| `route` | Django | `templates/route/django.py` |
+| `tool` | LangChain (TS) | `templates/tool/langchain-ts.ts` |
+| `tool` | LangChain (Python) | `templates/tool/langchain-py.py` |
+| `tool` | Anthropic SDK (TS) | `templates/tool/anthropic-sdk-ts.ts` |
+| `tool` | Anthropic SDK (Python) | `templates/tool/anthropic-sdk-py.py` |
+| `tool` | OpenAI SDK (TS) | `templates/tool/openai-ts.ts` |
+| `tool` | OpenAI SDK (Python) | `templates/tool/openai-py.py` |
+| `tool` | Mastra | `templates/tool/mastra.ts` |
+| `tool` | Vercel AI SDK | `templates/tool/vercel-ai-sdk.ts` |
+| **other language** | any | `templates/fallback/curl.sh` (adapt by hand, tell the user) |
+
+**If a template file does not exist** (because v1 ships a subset), fall back to the closest available template in the same family and tell the user:
+
+> "I don't have a canonical template for `<framework>` yet — I'm using the `<closest>` template as a starting point and adapting it. You may need to adjust imports/syntax."
+
+### Routes and tools also need a module template
+
+The route and tool patterns import the scraper from a sibling module file. So when the pattern is `route` or `tool`, you must also pick a **module** template:
+
+- TypeScript projects: `templates/module/ts-cheerio.ts` if the project already depends on `cheerio`; otherwise `templates/module/ts-fetch.ts` (no parser dep).
+- Python projects: `templates/module/py-bs4.py` if `beautifulsoup4` is acceptable to add (or already a dep); otherwise `templates/module/py-stdlib.py` (stdlib only).
+
+In other words: route and tool patterns generate **two** files — the route/tool wrapper and the module it imports.
+
+## Step 2: Fill the template
+
+Replace these placeholders in the template with values from the decision records:
+
+- `{{TARGET_URL}}` → Phase 1 `target_url`
+- `{{TARGET_NAME}}` → derived from URL host, snake_case (e.g., `amazon_com`, `competitor_prices`)
+- `{{FIELDS}}` → Phase 1 `fields`, formatted per template (TS interface, Python TypedDict, etc.)
+- `{{SELECTORS}}` → Phase 2 `selectors` (CSS strings)
+- `{{PAGINATION}}` → Phase 2 `pagination` ('url-based' / 'next-link' / 'cursor' / 'infinite-scroll' / 'none')
+- `{{APPROACH}}` → Phase 2 `approach`
+- `{{DATASET_ID}}` → Phase 2 `dataset_id` (only for pre-built scrapers)
+- `{{CONCURRENCY}}` → 20 if `concurrency_required` else 1
+- `{{HIDDEN_API_ENDPOINT}}` → Phase 2 `hidden_api_endpoint` if present
+
+Generated files always read **`BRIGHTDATA_API_KEY`** and **`BRIGHTDATA_UNLOCKER_ZONE`** (default `"unblocker"`) from environment.
+
+## Step 3: Pick destination paths
+
+For the **module** pattern:
+- TS: `src/scrapers/{{TARGET_NAME}}.ts`
+- Python: `src/scrapers/{{TARGET_NAME}}.py` — or use the project's existing source directory if `src/` doesn't exist (check for `app/`, `lib/`, top-level `.py` files)
+
+For the **route** pattern:
+- Next.js App Router: `app/api/scrape/route.ts`
+- Next.js Pages Router: `pages/api/scrape.ts`
+- Express / Fastify / Hono / Koa: `src/routes/scrape.ts` (or wherever the project's existing routes live — inspect)
+- FastAPI: `app/api/scrape.py` (with router include line shown to user)
+- Flask: `app/scrape.py` (blueprint, with `app.register_blueprint(...)` line shown)
+- Django: `<app>/views/scrape.py` (with URL pattern line shown)
+
+The route pattern **also** generates the module file (route imports the module).
+
+For the **tool** pattern:
+- TS: `src/tools/scrape.ts`
+- Python: `src/tools/scrape.py`
+
+The tool pattern **also** generates the module file (tool calls the module).
+
+## Step 4: Update env and README
+
+Always update:
+
+- `.env.example` — append (skip lines already present):
+  ```
+  # Get token at https://brightdata.com/cp/setting/users
+  BRIGHTDATA_API_KEY=
+  # Optional — defaults to the account's "unblocker" zone if unset.
+  # Manage zones at https://brightdata.com/cp/zones
+  BRIGHTDATA_UNLOCKER_ZONE=
+  ```
+
+- `README.md` — append (or create) a `## Web scraping` section with one usage example showing how to call the generated function/route/tool.
+
+## Step 5: Confirmation gate
+
+Before writing **any** file, present the user with a list:
+
+```
+I'll write or modify these files:
+  • CREATE src/scrapers/competitor_prices.ts
+  • CREATE app/api/scrape/route.ts
+  • MODIFY .env.example (append BRIGHTDATA_API_KEY, BRIGHTDATA_UNLOCKER_ZONE)
+  • MODIFY README.md (append "## Web scraping" section)
+
+OK to write?
+```
+
+**WAIT for confirmation. Do not edit a single file before the user says yes.**
+
+## Step 6: Existing-file safety
+
+- **Never overwrite an existing scraper file.** If `src/scrapers/competitor_prices.ts` exists, suggest `competitor_prices_2.ts` or ask the user where to put it.
+- **Never overwrite `README.md` or `.env.example` wholesale.** Append only. If `BRIGHTDATA_API_KEY` is already in `.env.example`, skip it. If a `## Web scraping` section already exists, append a sub-section.
+- **Never duplicate a route registration line.** If the user's `app.ts` already has `app.use('/api/scrape', ...)`, skip the suggestion.
+
+## Step 7: Output
+
+After writing, summarize for the user:
+
+```
+Files written:
+  ✓ src/scrapers/competitor_prices.ts
+  ✓ app/api/scrape/route.ts
+  ✓ .env.example
+  ✓ README.md
+
+Next: Phase 4 will wire Bright Data MCP and run a smoke test.
+```
+
+Return control to the orchestrator.
diff --git a/brightdata-scrape/steering/phase4-mcp-and-verify.md b/brightdata-scrape/steering/phase4-mcp-and-verify.md
new file mode 100644
index 0000000..98408df
--- /dev/null
+++ b/brightdata-scrape/steering/phase4-mcp-and-verify.md
@@ -0,0 +1,113 @@
+# Phase 4: MCP Wiring & Smoke Test
+
+Wire the Bright Data MCP server into the project, run a one-page smoke test, and write the README wrap-up.
+
+## Step 1: Project-level MCP config
+
+Read or create `.kiro/settings/mcp.json`. Apply the following merge logic:
+
+- **File doesn't exist** → create with this content:
+  ```json
+  {
+    "mcpServers": {
+      "brightdata": {
+        "url": "https://mcp.brightdata.com/mcp?token=${BRIGHTDATA_API_KEY}",
+        "disabled": false
+      }
+    }
+  }
+  ```
+
+- **File exists, no `brightdata` key** → merge the entry above into `mcpServers`.
+
+- **File exists, `brightdata` key with the same URL** → no-op.
+
+- **File exists, `brightdata` key with a different URL** → show the diff to the user and ask:
+  > "There's an existing `brightdata` MCP server pointing at `<existing-url>`. Want me to: (a) replace it with the standard URL, (b) leave it alone, or (c) append `&pro=1` to enable Pro tools?"
+
+**Always show the diff before writing.** Do not write silently.
+
+## Step 2: User-level alternative
+
+Tell the user:
+
+> "If you'd rather have Bright Data MCP available across **every** Kiro project (not just this one), copy the same `brightdata` block to `~/.kiro/settings/mcp.json` instead. The project-level `.kiro/settings/mcp.json` overrides user-level if both exist."
+
+## Step 3: Token onboarding inline check
+
+Verify the token is actually available at runtime:
+
+1. **Env var path:** `echo $BRIGHTDATA_API_KEY` should be non-empty.
+2. **Hardcoded path:** the URL in `.kiro/settings/mcp.json` (or `~/.kiro/settings/mcp.json`) does not contain the literal `${BRIGHTDATA_API_KEY}` (it has been replaced with a real token).
+
+If neither is true, **STOP** and ask the user to set the env var or hardcode the token before continuing. Do not skip to Step 4.
+
+In **greenfield mode** (no project shell context), offer to set the env var inline for the smoke test only:
+
+```bash
+BRIGHTDATA_API_KEY=<token> python scrape.py
+```
+
+Tell the user this is for the smoke test only — they should add it to their shell profile or `.env` afterward.
+
+## Step 4: Smoke test
+
+Run the generated scraper on the user's target URL with a 1-page sample (or 1–3 items, whichever is faster).
+
+**For a module:** call the function directly from a one-line REPL invocation or a temporary script.
+
+**For a route:** start the dev server (or call the handler function directly if possible) and hit the endpoint with one curl.
+
+**For an agent tool:** invoke the tool's `run`/`call`/`execute` function directly with a sample input.
+
+Show the result to the user.
+
+### Outcomes
+
+- **Empty result, all-null fields, or error** → **return to Phase 2 reconnaissance**, fix selectors, regenerate the affected module file in Phase 3, re-run the smoke test. **Do not declare success.**
+- **Partial result** (some fields populated, some null) → ask the user if it's good enough or to iterate.
+- **Clean result** → proceed to Step 5.
+
+## Step 5: README wrap-up
+
+Append to `README.md`:
+
+```markdown
+## Bright Data MCP
+
+This project has the Bright Data MCP server configured (`.kiro/settings/mcp.json`).
+Any AI agent (Claude Code, Cursor, Cline, Kiro) running against this project
+gains live web tools — `search_engine`, `scrape_as_markdown`, and structured-data
+extractors for 40+ platforms.
+
+To enable the full 60+ Pro tools (e.g., `web_data_amazon_product`,
+`web_data_linkedin_person_profile`), append `&pro=1` to the MCP URL in
+`.kiro/settings/mcp.json`. To enable specific groups only, use
+`&groups=social,ecommerce` (groups: `social`, `ecommerce`, `business`,
+`finance`, `research`, `app_stores`, `travel`, `browser`, `advanced_scraping`).
+```
+
+If the section already exists, **skip** — do not duplicate.
+
+## Step 6: Final summary
+
+Tell the user:
+
+```
+Done. Here's what was added:
+
+  Code:
+    ✓ <files written by Phase 3>
+
+  MCP:
+    ✓ .kiro/settings/mcp.json — Bright Data server registered
+    ℹ︎ Append `&pro=1` to the MCP URL to enable 60+ Pro tools
+
+  Smoke test:
+    ✓ Scraped 1 page — extracted <N> items, all fields populated
+
+Try it out:
+    <one-line invocation appropriate to the pattern>
+```
+
+Workflow complete. Return to the orchestrator with no further action.
diff --git a/brightdata-scrape/steering/scrape-workflow.md b/brightdata-scrape/steering/scrape-workflow.md
new file mode 100644
index 0000000..b8a4189
--- /dev/null
+++ b/brightdata-scrape/steering/scrape-workflow.md
@@ -0,0 +1,65 @@
+# brightdata-scrape Workflow
+
+Orchestrated workflow for adding Bright Data scraping to a project.
+
+## When to use this workflow
+
+Use for any scraping or web-data task — the user said something like "scrape X", "extract data from Y", "monitor competitor prices", "give my agent web search", or any keyword from this power's frontmatter.
+
+## Critical rules
+
+1. **All four phases run in order.** No skipping, no reordering.
+2. **One phase steering file at a time.** Read only the next phase's file. Do NOT read ahead.
+3. **Wait for user confirmation between phases.** Each phase ends with a confirmation gate.
+4. **If you lose track, re-read this orchestrator file.** Identify the last completed phase, dispatch the next one.
+5. **Do not improvise the integration code.** Use the templates in `brightdata-scrape/templates/` as canonical references.
+
+## Step 1: Validate prerequisites
+
+Run these checks before proceeding:
+
+1. **`BRIGHTDATA_API_KEY` is set OR hardcoded in `~/.kiro/settings/mcp.json`.**
+   - Check env: `echo $BRIGHTDATA_API_KEY` (non-empty)
+   - OR check `~/.kiro/settings/mcp.json` for a `brightdata` entry with the token in the URL
+
+2. **The user is in a workspace** (current working directory is set).
+
+If `BRIGHTDATA_API_KEY` is missing, **STOP** and present the onboarding from `POWER.md` Step 1–2. Do not proceed.
+
+## Step 2: Dispatch Phase 1
+
+Read **only** the Phase 1 steering file:
+
+```
+Call action "readSteering" with powerName="brightdata-scrape", steeringFile="phase1-detect-and-plan.md"
+```
+
+**Do NOT read any other phase file yet.** Phase 1 will summarize a plan and ask the user to confirm. After the user confirms, proceed to Step 3 of this file.
+
+## Step 3: Dispatch subsequent phases
+
+After each phase completes and the user confirms, dispatch the next phase. The phase order is fixed:
+
+1. `phase1-detect-and-plan.md`
+2. `phase2-scraping-playbook.md`
+3. `phase3-integrate.md`
+4. `phase4-mcp-and-verify.md`
+
+After Phase 4 completes, the workflow is done. Tell the user what was added and where.
+
+(See Step 4 below for the exact transition protocol.)
+
+## Step 4: Phase transition pattern
+
+When a phase finishes, it will summarize what it did and stop. The orchestrator then:
+
+1. Tells the user which phase just finished and what's next.
+2. Asks: `[Phase name] is complete. Ready to proceed to [next phase name]?`
+3. **Waits for the user to confirm.**
+4. Once confirmed, reads the next phase steering file with `readSteering` and dispatches it.
+
+## Troubleshooting
+
+- **Smoke test in Phase 4 returns empty data** → re-enter Phase 2 reconnaissance, fix selectors, regenerate the affected files in Phase 3, re-run smoke test. Do not declare success.
+- **User asks to change scope mid-flow** → ask if they want to abort and restart Phase 1, or continue with current plan.
+- **Multiple manifests in repo (monorepo)** → Phase 1 handles this; ask the user which sub-project.
diff --git a/brightdata-scrape/templates/fallback/curl.sh b/brightdata-scrape/templates/fallback/curl.sh
new file mode 100644
index 0000000..06c6b8d
--- /dev/null
+++ b/brightdata-scrape/templates/fallback/curl.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Bright Data Web Unlocker — generic fallback for languages without a first-class template.
+#
+# Generated by the brightdata-scrape Kiro power.
+# Adapt this curl invocation into your language's HTTP client (Go's net/http,
+# Ruby's Net::HTTP, Java's HttpClient, etc.). The contract is:
+#
+#   POST https://api.brightdata.com/request
+#   Headers: Authorization: Bearer $BRIGHTDATA_API_KEY
+#            Content-Type: application/json
+#   Body:   {"zone": "<zone>", "url": "<target>", "format": "raw"}
+#
+#   Response: raw HTML body of the target page, or JSON if the target is a JSON endpoint.
+#
+# Translate the request, parse the HTML in your language's idiomatic parser
+# (e.g., goquery for Go, Nokogiri for Ruby, jsoup for Java).
+
+set -euo pipefail
+
+: "${BRIGHTDATA_API_KEY:?BRIGHTDATA_API_KEY must be set}"
+ZONE="${BRIGHTDATA_UNLOCKER_ZONE:-unblocker}"
+TARGET_URL="{{TARGET_URL}}"
+
+curl -s -X POST https://api.brightdata.com/request \
+  -H "Authorization: Bearer ${BRIGHTDATA_API_KEY}" \
+  -H "Content-Type: application/json" \
+  -d "{\"zone\": \"${ZONE}\", \"url\": \"${TARGET_URL}\", \"format\": \"raw\"}"
diff --git a/brightdata-scrape/templates/module/py-bs4.py b/brightdata-scrape/templates/module/py-bs4.py
new file mode 100644
index 0000000..4fe9dfb
--- /dev/null
+++ b/brightdata-scrape/templates/module/py-bs4.py
@@ -0,0 +1,100 @@
+"""Bright Data scraper for {{TARGET_URL}}.
+
+Generated by the brightdata-scrape Kiro power. Customize selectors below.
+
+Usage:
+    from src.scrapers.{{TARGET_NAME}} import scrape_{{TARGET_NAME}}
+    items = scrape_{{TARGET_NAME}}("https://example.com")
+"""
+from __future__ import annotations
+
+import os
+import time
+from typing import Iterator, TypedDict
+
+import requests
+from bs4 import BeautifulSoup
+
+API_KEY = os.environ["BRIGHTDATA_API_KEY"]
+ZONE = os.environ.get("BRIGHTDATA_UNLOCKER_ZONE", "unblocker")
+BASE_URL = "{{TARGET_URL}}"
+
+
+class {{TARGET_NAME}}_Item(TypedDict, total=False):
+    name: str
+    url: str
+    # TODO: add fields from {{FIELDS}}
+
+
+def _fetch(url: str, retries: int = 3) -> str:
+    """Fetch a page through Bright Data Web Unlocker with exponential backoff."""
+    last_exc: Exception | None = None
+    for attempt in range(retries):
+        try:
+            resp = requests.post(
+                "https://api.brightdata.com/request",
+                headers={"Authorization": f"Bearer {API_KEY}"},
+                json={"zone": ZONE, "url": url, "format": "raw"},
+                timeout=60,
+            )
+            resp.raise_for_status()
+            return resp.text
+        except requests.RequestException as exc:
+            last_exc = exc
+            time.sleep(2 ** attempt)
+    raise RuntimeError(f"failed to fetch {url} after {retries} attempts") from last_exc
+
+
+def _parse(html: str) -> list[{{TARGET_NAME}}_Item]:
+    """Extract structured items from a page's HTML.
+
+    Selectors come from Phase 2 reconnaissance. Adjust these to match the target site.
+    """
+    soup = BeautifulSoup(html, "html.parser")
+    items: list[{{TARGET_NAME}}_Item] = []
+    for card in soup.select(".item"):  # TODO: replace with {{SELECTORS}} root
+        try:
+            item: {{TARGET_NAME}}_Item = {
+                "name": card.select_one(".name").get_text(strip=True),
+                "url": card.select_one("a").get("href", ""),
+                # TODO: extract remaining {{FIELDS}}
+            }
+            items.append(item)
+        except (AttributeError, TypeError):
+            continue
+    return items
+
+
+def _paginate(start_url: str, max_pages: int = 50) -> Iterator[str]:
+    """Yield page URLs. Default: URL-based pagination (?page=N).
+
+    Phase 2 chose pagination = {{PAGINATION}}. If different, replace the body.
+    """
+    for n in range(1, max_pages + 1):
+        sep = "&" if "?" in start_url else "?"
+        yield f"{start_url}{sep}page={n}"
+
+
+def scrape_{{TARGET_NAME}}(start_url: str | None = None) -> list[{{TARGET_NAME}}_Item]:
+    """Scrape {{TARGET_URL}} and return a list of items.
+
+    Args:
+        start_url: Override the default {{TARGET_URL}}.
+
+    Returns:
+        A list of typed item dicts.
+    """
+    url = start_url or BASE_URL
+    all_items: list[{{TARGET_NAME}}_Item] = []
+    for page_url in _paginate(url):
+        html = _fetch(page_url)
+        items = _parse(html)
+        if not items:
+            break
+        all_items.extend(items)
+    return all_items
+
+
+if __name__ == "__main__":
+    import json
+    print(json.dumps(scrape_{{TARGET_NAME}}(), indent=2, ensure_ascii=False))
diff --git a/brightdata-scrape/templates/module/py-stdlib.py b/brightdata-scrape/templates/module/py-stdlib.py
new file mode 100644
index 0000000..2875831
--- /dev/null
+++ b/brightdata-scrape/templates/module/py-stdlib.py
@@ -0,0 +1,140 @@
+"""Bright Data scraper for {{TARGET_URL}}.
+
+Generated by the brightdata-scrape Kiro power. Customize selectors below.
+This module uses html.parser from the Python standard library — no third-party
+HTML parser required.
+
+Usage:
+    from src.scrapers.{{TARGET_NAME}} import scrape_{{TARGET_NAME}}
+    items = scrape_{{TARGET_NAME}}("https://example.com")
+"""
+from __future__ import annotations
+
+import os
+import time
+import urllib.request
+import urllib.error
+import json
+from html.parser import HTMLParser
+from typing import Iterator, TypedDict
+
+API_KEY = os.environ["BRIGHTDATA_API_KEY"]
+ZONE = os.environ.get("BRIGHTDATA_UNLOCKER_ZONE", "unblocker")
+BASE_URL = "{{TARGET_URL}}"
+
+
+class {{TARGET_NAME}}_Item(TypedDict, total=False):
+    name: str
+    url: str
+    # TODO: add fields from {{FIELDS}}
+
+
+class _ItemParser(HTMLParser):
+    """Minimal HTMLParser subclass that collects items from the page.
+
+    TODO: replace the class selector logic with real selectors from {{SELECTORS}}.
+    Currently looks for <div class="item"> blocks and extracts name + href.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._items: list[{{TARGET_NAME}}_Item] = []
+        self._in_item: bool = False
+        self._in_name: bool = False
+        self._current: {{TARGET_NAME}}_Item = {}
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        attr_dict = dict(attrs)
+        classes = (attr_dict.get("class") or "").split()
+        if tag == "div" and "item" in classes:  # TODO: replace with {{SELECTORS}} root
+            self._in_item = True
+            self._current = {}
+        if self._in_item and tag == "a" and not self._current.get("url"):
+            href = attr_dict.get("href")
+            if href:
+                self._current["url"] = href
+        if self._in_item and tag in ("span", "h2", "h3") and "name" in classes:
+            self._in_name = True
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in ("span", "h2", "h3"):
+            self._in_name = False
+        if tag == "div" and self._in_item:
+            if self._current:
+                self._items.append(self._current)
+            self._in_item = False
+
+    def handle_data(self, data: str) -> None:
+        if self._in_name:
+            existing = self._current.get("name", "")
+            self._current["name"] = (existing + data).strip()
+
+    def items(self) -> list[{{TARGET_NAME}}_Item]:
+        return list(self._items)
+
+
+def _fetch(url: str, retries: int = 3) -> str:
+    """Fetch a page through Bright Data Web Unlocker with exponential backoff."""
+    last_exc: Exception | None = None
+    for attempt in range(retries):
+        try:
+            payload = json.dumps({"zone": ZONE, "url": url, "format": "raw"}).encode()
+            req = urllib.request.Request(
+                "https://api.brightdata.com/request",
+                data=payload,
+                headers={
+                    "Authorization": f"Bearer {API_KEY}",
+                    "Content-Type": "application/json",
+                },
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                return resp.read().decode("utf-8", errors="replace")
+        except (urllib.error.URLError, OSError) as exc:
+            last_exc = exc
+            time.sleep(2 ** attempt)
+    raise RuntimeError(f"failed to fetch {url} after {retries} attempts") from last_exc
+
+
+def _parse(html: str) -> list[{{TARGET_NAME}}_Item]:
+    """Extract structured items from a page's HTML.
+
+    Selectors come from Phase 2 reconnaissance. Adjust these to match the target site.
+    """
+    parser = _ItemParser()
+    parser.feed(html)
+    return parser.items()
+
+
+def _paginate(start_url: str, max_pages: int = 50) -> Iterator[str]:
+    """Yield page URLs. Default: URL-based pagination (?page=N).
+
+    Phase 2 chose pagination = {{PAGINATION}}. If different, replace the body.
+    """
+    for n in range(1, max_pages + 1):
+        sep = "&" if "?" in start_url else "?"
+        yield f"{start_url}{sep}page={n}"
+
+
+def scrape_{{TARGET_NAME}}(start_url: str | None = None) -> list[{{TARGET_NAME}}_Item]:
+    """Scrape {{TARGET_URL}} and return a list of items.
+
+    Args:
+        start_url: Override the default {{TARGET_URL}}.
+
+    Returns:
+        A list of typed item dicts.
+    """
+    url = start_url or BASE_URL
+    all_items: list[{{TARGET_NAME}}_Item] = []
+    for page_url in _paginate(url):
+        html = _fetch(page_url)
+        items = _parse(html)
+        if not items:
+            break
+        all_items.extend(items)
+    return all_items
+
+
+if __name__ == "__main__":
+    print(json.dumps(scrape_{{TARGET_NAME}}(), indent=2, ensure_ascii=False))
diff --git a/brightdata-scrape/templates/module/ts-cheerio.ts b/brightdata-scrape/templates/module/ts-cheerio.ts
new file mode 100644
index 0000000..4052855
--- /dev/null
+++ b/brightdata-scrape/templates/module/ts-cheerio.ts
@@ -0,0 +1,80 @@
+/**
+ * Bright Data scraper for {{TARGET_URL}}.
+ *
+ * Generated by the brightdata-scrape Kiro power. Customize selectors below.
+ *
+ * Usage:
+ *   import { scrape{{TARGET_NAME}} } from "@/scrapers/{{TARGET_NAME}}";
+ *   const items = await scrape{{TARGET_NAME}}();
+ */
+import * as cheerio from "cheerio";
+
+const API_KEY = process.env.BRIGHTDATA_API_KEY;
+const ZONE = process.env.BRIGHTDATA_UNLOCKER_ZONE ?? "unblocker";
+const BASE_URL = "{{TARGET_URL}}";
+
+if (!API_KEY) {
+  throw new Error("BRIGHTDATA_API_KEY is not set");
+}
+
+export interface {{TARGET_NAME}}_Item {
+  name?: string;
+  url?: string;
+  // TODO: add fields from {{FIELDS}}
+}
+
+async function fetchPage(url: string, retries = 3): Promise<string> {
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      const resp = await fetch("https://api.brightdata.com/request", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${API_KEY}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ zone: ZONE, url, format: "raw" }),
+      });
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      return await resp.text();
+    } catch (err) {
+      if (attempt === retries - 1) throw err;
+      await new Promise((r) => setTimeout(r, 2 ** attempt * 1000));
+    }
+  }
+  throw new Error("unreachable");
+}
+
+function parseItems(html: string): {{TARGET_NAME}}_Item[] {
+  const $ = cheerio.load(html);
+  const items: {{TARGET_NAME}}_Item[] = [];
+  $(".item").each((_i, el) => {
+    // TODO: replace with {{SELECTORS}}
+    const $el = $(el);
+    items.push({
+      name: $el.find(".name").text().trim(),
+      url: $el.find("a").attr("href") ?? "",
+      // TODO: extract remaining {{FIELDS}}
+    });
+  });
+  return items;
+}
+
+function* paginate(startUrl: string, maxPages = 50): Generator<string> {
+  for (let n = 1; n <= maxPages; n++) {
+    const sep = startUrl.includes("?") ? "&" : "?";
+    yield `${startUrl}${sep}page=${n}`;
+  }
+}
+
+export async function scrape{{TARGET_NAME}}(
+  startUrl: string = BASE_URL,
+): Promise<{{TARGET_NAME}}_Item[]> {
+  const all: {{TARGET_NAME}}_Item[] = [];
+  for (const pageUrl of paginate(startUrl)) {
+    const html = await fetchPage(pageUrl);
+    const items = parseItems(html);
+    if (items.length === 0) break;
+    all.push(...items);
+  }
+  return all;
+}
diff --git a/brightdata-scrape/templates/module/ts-fetch.ts b/brightdata-scrape/templates/module/ts-fetch.ts
new file mode 100644
index 0000000..e270086
--- /dev/null
+++ b/brightdata-scrape/templates/module/ts-fetch.ts
@@ -0,0 +1,91 @@
+/**
+ * Bright Data scraper for {{TARGET_URL}}.
+ *
+ * Generated by the brightdata-scrape Kiro power. Customize selectors below.
+ * This module uses the built-in fetch API and regex-based parsing — no
+ * third-party HTML parser required.
+ *
+ * Usage:
+ *   import { scrape{{TARGET_NAME}} } from "@/scrapers/{{TARGET_NAME}}";
+ *   const items = await scrape{{TARGET_NAME}}();
+ */
+
+const API_KEY = process.env.BRIGHTDATA_API_KEY;
+const ZONE = process.env.BRIGHTDATA_UNLOCKER_ZONE ?? "unblocker";
+const BASE_URL = "{{TARGET_URL}}";
+
+if (!API_KEY) {
+  throw new Error("BRIGHTDATA_API_KEY is not set");
+}
+
+export interface {{TARGET_NAME}}_Item {
+  name?: string;
+  url?: string;
+  // TODO: add fields from {{FIELDS}}
+}
+
+async function fetchPage(url: string, retries = 3): Promise<string> {
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      const resp = await fetch("https://api.brightdata.com/request", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${API_KEY}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ zone: ZONE, url, format: "raw" }),
+      });
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      return await resp.text();
+    } catch (err) {
+      if (attempt === retries - 1) throw err;
+      await new Promise((r) => setTimeout(r, 2 ** attempt * 1000));
+    }
+  }
+  throw new Error("unreachable");
+}
+
+function parseItems(html: string): {{TARGET_NAME}}_Item[] {
+  const items: {{TARGET_NAME}}_Item[] = [];
+  // TODO: replace with real selectors — adapt the regexes to match the target page structure.
+  // Example: extract every <a> tag inside a container with class "item":
+  //   const blockRe = /<div[^>]+class="item"[^>]*>([\s\S]*?)<\/div>/gi;
+  //   const nameRe  = /<span[^>]+class="name"[^>]*>([^<]*)<\/span>/i;
+  //   const hrefRe  = /<a[^>]+href="([^"]+)"/i;
+  const blockRe = /<div[^>]+class="item"[^>]*>([\s\S]*?)<\/div>/gi;
+  const nameRe = /<[^>]+class="name"[^>]*>([^<]*)</i;
+  const hrefRe = /<a[^>]+href="([^"]+)"/i;
+
+  let match: RegExpExecArray | null;
+  while ((match = blockRe.exec(html)) !== null) {
+    const block = match[1];
+    const nameMatch = nameRe.exec(block);
+    const hrefMatch = hrefRe.exec(block);
+    items.push({
+      name: nameMatch ? nameMatch[1].trim() : undefined,
+      url: hrefMatch ? hrefMatch[1] : undefined,
+      // TODO: extract remaining {{FIELDS}}
+    });
+  }
+  return items;
+}
+
+function* paginate(startUrl: string, maxPages = 50): Generator<string> {
+  for (let n = 1; n <= maxPages; n++) {
+    const sep = startUrl.includes("?") ? "&" : "?";
+    yield `${startUrl}${sep}page=${n}`;
+  }
+}
+
+export async function scrape{{TARGET_NAME}}(
+  startUrl: string = BASE_URL,
+): Promise<{{TARGET_NAME}}_Item[]> {
+  const all: {{TARGET_NAME}}_Item[] = [];
+  for (const pageUrl of paginate(startUrl)) {
+    const html = await fetchPage(pageUrl);
+    const items = parseItems(html);
+    if (items.length === 0) break;
+    all.push(...items);
+  }
+  return all;
+}
diff --git a/brightdata-scrape/templates/route/django.py b/brightdata-scrape/templates/route/django.py
new file mode 100644
index 0000000..6f1e210
--- /dev/null
+++ b/brightdata-scrape/templates/route/django.py
@@ -0,0 +1,32 @@
+"""Django function-based view — GET /api/scrape/
+
+Generated by the brightdata-scrape Kiro power.
+Calls into src/scrapers/{{TARGET_NAME}}.py
+
+Wire it up in your urls.py:
+
+    from django.urls import path
+    from app.views.scrape import scrape
+
+    urlpatterns = [
+        path("api/scrape/", scrape, name="scrape"),
+    ]
+"""
+from __future__ import annotations
+
+import json
+
+from django.http import HttpRequest, JsonResponse
+from django.views.decorators.http import require_GET
+
+from src.scrapers.{{TARGET_NAME}} import scrape_{{TARGET_NAME}}
+
+
+@require_GET
+def scrape(request: HttpRequest) -> JsonResponse:
+    url: str | None = request.GET.get("url")
+    try:
+        items = scrape_{{TARGET_NAME}}(url) if url else scrape_{{TARGET_NAME}}()
+    except Exception as exc:  # surface scraping failures as 500s
+        return JsonResponse({"error": str(exc)}, status=500)
+    return JsonResponse({"count": len(items), "items": items})
diff --git a/brightdata-scrape/templates/route/express.ts b/brightdata-scrape/templates/route/express.ts
new file mode 100644
index 0000000..40f7f87
--- /dev/null
+++ b/brightdata-scrape/templates/route/express.ts
@@ -0,0 +1,27 @@
+/**
+ * Express route — GET /scrape
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ * Calls into src/scrapers/{{TARGET_NAME}}.ts
+ *
+ * Wire it up in your app:
+ *   import { scrapeRouter } from "./routes/scrape";
+ *   app.use("/api", scrapeRouter);
+ */
+import { Router, Request, Response } from "express";
+import { scrape{{TARGET_NAME}} } from "../scrapers/{{TARGET_NAME}}";
+
+export const scrapeRouter = Router();
+
+scrapeRouter.get("/scrape", async (req: Request, res: Response) => {
+  const url =
+    typeof req.query.url === "string" ? req.query.url : undefined;
+
+  try {
+    const items = await scrape{{TARGET_NAME}}(url);
+    res.json({ count: items.length, items });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    res.status(500).json({ error: msg });
+  }
+});
diff --git a/brightdata-scrape/templates/route/fastapi.py b/brightdata-scrape/templates/route/fastapi.py
new file mode 100644
index 0000000..befab8e
--- /dev/null
+++ b/brightdata-scrape/templates/route/fastapi.py
@@ -0,0 +1,26 @@
+"""FastAPI route — GET /api/scrape
+
+Generated by the brightdata-scrape Kiro power.
+Calls into src/scrapers/{{TARGET_NAME}}.py
+
+Wire it up by adding to your app:
+
+    from app.api.scrape import router as scrape_router
+    app.include_router(scrape_router, prefix="/api")
+"""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Query
+
+from src.scrapers.{{TARGET_NAME}} import scrape_{{TARGET_NAME}}
+
+router = APIRouter()
+
+
+@router.get("/scrape")
+async def scrape(url: str | None = Query(default=None)) -> dict:
+    try:
+        items = scrape_{{TARGET_NAME}}(url) if url else scrape_{{TARGET_NAME}}()
+    except Exception as exc:  # surface scraping failures as 500s
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+    return {"count": len(items), "items": items}
diff --git a/brightdata-scrape/templates/route/fastify.ts b/brightdata-scrape/templates/route/fastify.ts
new file mode 100644
index 0000000..4378422
--- /dev/null
+++ b/brightdata-scrape/templates/route/fastify.ts
@@ -0,0 +1,35 @@
+/**
+ * Fastify plugin — GET /scrape
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ * Calls into src/scrapers/{{TARGET_NAME}}.ts
+ *
+ * Wire it up in your app:
+ *   import Fastify from "fastify";
+ *   import { scrapePlugin } from "./routes/scrape";
+ *
+ *   const app = Fastify();
+ *   app.register(scrapePlugin, { prefix: "/api" });
+ */
+import type { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
+import { scrape{{TARGET_NAME}} } from "../scrapers/{{TARGET_NAME}}";
+
+export async function scrapePlugin(fastify: FastifyInstance): Promise<void> {
+  fastify.get(
+    "/scrape",
+    async (
+      request: FastifyRequest<{ Querystring: { url?: string } }>,
+      reply: FastifyReply,
+    ) => {
+      const { url } = request.query;
+      try {
+        const items = await scrape{{TARGET_NAME}}(url);
+        return { count: items.length, items };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "unknown error";
+        reply.status(500);
+        return { error: msg };
+      }
+    },
+  );
+}
diff --git a/brightdata-scrape/templates/route/flask.py b/brightdata-scrape/templates/route/flask.py
new file mode 100644
index 0000000..c36b84e
--- /dev/null
+++ b/brightdata-scrape/templates/route/flask.py
@@ -0,0 +1,27 @@
+"""Flask blueprint — GET /scrape
+
+Generated by the brightdata-scrape Kiro power.
+Calls into src/scrapers/{{TARGET_NAME}}.py
+
+Wire it up by adding to your app factory:
+
+    from app.api.scrape import bp as scrape_bp
+    app.register_blueprint(scrape_bp, url_prefix="/api")
+"""
+from __future__ import annotations
+
+from flask import Blueprint, jsonify, request
+
+from src.scrapers.{{TARGET_NAME}} import scrape_{{TARGET_NAME}}
+
+bp = Blueprint("scrape", __name__)
+
+
+@bp.route("/scrape")
+def scrape() -> tuple:
+    url: str | None = request.args.get("url")
+    try:
+        items = scrape_{{TARGET_NAME}}(url) if url else scrape_{{TARGET_NAME}}()
+    except Exception as exc:  # surface scraping failures as 500s
+        return jsonify({"error": str(exc)}), 500
+    return jsonify({"count": len(items), "items": items}), 200
diff --git a/brightdata-scrape/templates/route/hono.ts b/brightdata-scrape/templates/route/hono.ts
new file mode 100644
index 0000000..6172a40
--- /dev/null
+++ b/brightdata-scrape/templates/route/hono.ts
@@ -0,0 +1,29 @@
+/**
+ * Hono app — GET /scrape
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ * Calls into src/scrapers/{{TARGET_NAME}}.ts
+ *
+ * Wire it up in your main app:
+ *   import { Hono } from "hono";
+ *   import { scrapeApp } from "./routes/scrape";
+ *
+ *   const app = new Hono();
+ *   app.route("/api", scrapeApp);
+ */
+import { Hono } from "hono";
+import { scrape{{TARGET_NAME}} } from "../scrapers/{{TARGET_NAME}}";
+
+export const scrapeApp = new Hono();
+
+scrapeApp.get("/scrape", async (c) => {
+  const url = c.req.query("url") ?? undefined;
+
+  try {
+    const items = await scrape{{TARGET_NAME}}(url);
+    return c.json({ count: items.length, items });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    return c.json({ error: msg }, 500);
+  }
+});
diff --git a/brightdata-scrape/templates/route/koa.ts b/brightdata-scrape/templates/route/koa.ts
new file mode 100644
index 0000000..dc76d1e
--- /dev/null
+++ b/brightdata-scrape/templates/route/koa.ts
@@ -0,0 +1,33 @@
+/**
+ * Koa route — GET /scrape
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ * Calls into src/scrapers/{{TARGET_NAME}}.ts
+ *
+ * Dependencies: koa, @koa/router
+ * Wire it up in your main app:
+ *   import Koa from "koa";
+ *   import { scrapeRouter } from "./routes/scrape";
+ *
+ *   const app = new Koa();
+ *   app.use(scrapeRouter.routes()).use(scrapeRouter.allowedMethods());
+ */
+import Router from "@koa/router";
+import type { Context } from "koa";
+import { scrape{{TARGET_NAME}} } from "../scrapers/{{TARGET_NAME}}";
+
+export const scrapeRouter = new Router({ prefix: "/api" });
+
+scrapeRouter.get("/scrape", async (ctx: Context) => {
+  const url =
+    typeof ctx.query.url === "string" ? ctx.query.url : undefined;
+
+  try {
+    const items = await scrape{{TARGET_NAME}}(url);
+    ctx.body = { count: items.length, items };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    ctx.status = 500;
+    ctx.body = { error: msg };
+  }
+});
diff --git a/brightdata-scrape/templates/route/next-app-router.ts b/brightdata-scrape/templates/route/next-app-router.ts
new file mode 100644
index 0000000..b71ff6f
--- /dev/null
+++ b/brightdata-scrape/templates/route/next-app-router.ts
@@ -0,0 +1,23 @@
+/**
+ * Next.js App Router route — GET /api/scrape
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ * Calls into src/scrapers/{{TARGET_NAME}}.ts
+ */
+import { NextResponse } from "next/server";
+import { scrape{{TARGET_NAME}} } from "@/scrapers/{{TARGET_NAME}}";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const url = searchParams.get("url") ?? undefined;
+
+  try {
+    const items = await scrape{{TARGET_NAME}}(url);
+    return NextResponse.json({ count: items.length, items });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}
diff --git a/brightdata-scrape/templates/route/next-pages-router.ts b/brightdata-scrape/templates/route/next-pages-router.ts
new file mode 100644
index 0000000..bd6180d
--- /dev/null
+++ b/brightdata-scrape/templates/route/next-pages-router.ts
@@ -0,0 +1,36 @@
+/**
+ * Next.js Pages Router route — GET /api/scrape
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ * Calls into src/scrapers/{{TARGET_NAME}}.ts
+ *
+ * File location: pages/api/scrape.ts
+ */
+import type { NextApiRequest, NextApiResponse } from "next";
+import { scrape{{TARGET_NAME}} } from "@/scrapers/{{TARGET_NAME}}";
+
+type ResponseData =
+  | { count: number; items: unknown[] }
+  | { error: string };
+
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse<ResponseData>,
+) {
+  if (req.method !== "GET") {
+    res.setHeader("Allow", "GET");
+    res.status(405).json({ error: "Method Not Allowed" });
+    return;
+  }
+
+  const url =
+    typeof req.query.url === "string" ? req.query.url : undefined;
+
+  try {
+    const items = await scrape{{TARGET_NAME}}(url);
+    res.status(200).json({ count: items.length, items });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    res.status(500).json({ error: msg });
+  }
+}
diff --git a/brightdata-scrape/templates/tool/anthropic-sdk-py.py b/brightdata-scrape/templates/tool/anthropic-sdk-py.py
new file mode 100644
index 0000000..7973448
--- /dev/null
+++ b/brightdata-scrape/templates/tool/anthropic-sdk-py.py
@@ -0,0 +1,49 @@
+"""Anthropic SDK tool definition for scraping {{TARGET_URL}}.
+
+Generated by the brightdata-scrape Kiro power.
+
+Usage:
+    import anthropic
+    from src.tools.scrape import SCRAPE_TOOL, run_scrape_tool
+
+    client = anthropic.Anthropic()
+    response = client.messages.create(
+        model="claude-opus-4-7",
+        max_tokens=1024,
+        tools=[SCRAPE_TOOL],
+        messages=[{"role": "user", "content": "Scrape latest items from {{TARGET_URL}}"}],
+    )
+    # When the model returns a tool_use block:
+    #   result = run_scrape_tool(tool_use.input)
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from src.scrapers.{{TARGET_NAME}} import scrape_{{TARGET_NAME}}
+
+SCRAPE_TOOL: dict[str, Any] = {
+    "name": "scrape_{{TARGET_NAME}}",
+    "description": (
+        "Scrape items from {{TARGET_URL}}. Use when the user asks for live data "
+        "from this site. Returns a JSON list of items."
+    ),
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "url": {
+                "type": "string",
+                "description": (
+                    "Optional override URL. If omitted, scrapes the default starting URL "
+                    "({{TARGET_URL}})."
+                ),
+            },
+        },
+    },
+}
+
+
+def run_scrape_tool(tool_input: dict[str, Any]) -> dict[str, Any]:
+    url = tool_input.get("url")
+    items = scrape_{{TARGET_NAME}}(url) if url else scrape_{{TARGET_NAME}}()
+    return {"count": len(items), "items": items}
diff --git a/brightdata-scrape/templates/tool/anthropic-sdk-ts.ts b/brightdata-scrape/templates/tool/anthropic-sdk-ts.ts
new file mode 100644
index 0000000..6d785aa
--- /dev/null
+++ b/brightdata-scrape/templates/tool/anthropic-sdk-ts.ts
@@ -0,0 +1,43 @@
+/**
+ * Anthropic SDK tool definition for scraping {{TARGET_URL}}.
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ *
+ * Usage:
+ *   import Anthropic from "@anthropic-ai/sdk";
+ *   import { scrapeTool, runScrapeTool } from "./tools/scrape";
+ *
+ *   const client = new Anthropic();
+ *   const response = await client.messages.create({
+ *     model: "claude-opus-4-7",
+ *     max_tokens: 1024,
+ *     tools: [scrapeTool],
+ *     messages: [{ role: "user", content: "Scrape latest items from {{TARGET_URL}}" }],
+ *   });
+ *   // When the model returns a tool_use block:
+ *   //   const result = await runScrapeTool(toolUse.input);
+ */
+import { scrape{{TARGET_NAME}} } from "../scrapers/{{TARGET_NAME}}";
+
+export const scrapeTool = {
+  name: "scrape_{{TARGET_NAME}}",
+  description:
+    "Scrape items from {{TARGET_URL}}. Use when the user asks for live data from this site. Returns a JSON list of items.",
+  input_schema: {
+    type: "object" as const,
+    properties: {
+      url: {
+        type: "string",
+        description:
+          "Optional override URL. If omitted, scrapes the default starting URL ({{TARGET_URL}}).",
+      },
+    },
+  },
+};
+
+export async function runScrapeTool(
+  input: { url?: string },
+): Promise<{ count: number; items: unknown[] }> {
+  const items = await scrape{{TARGET_NAME}}(input.url);
+  return { count: items.length, items };
+}
diff --git a/brightdata-scrape/templates/tool/langchain-py.py b/brightdata-scrape/templates/tool/langchain-py.py
new file mode 100644
index 0000000..f22809d
--- /dev/null
+++ b/brightdata-scrape/templates/tool/langchain-py.py
@@ -0,0 +1,44 @@
+"""LangChain tool definition for scraping {{TARGET_URL}}.
+
+Generated by the brightdata-scrape Kiro power.
+
+Usage:
+    from src.tools.scrape import scrape_{{TARGET_NAME}}_tool
+
+    from langchain.agents import AgentExecutor, create_react_agent
+    agent = create_react_agent(llm, tools=[scrape_{{TARGET_NAME}}_tool])
+"""
+from __future__ import annotations
+
+from typing import Optional, Type
+
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from src.scrapers.{{TARGET_NAME}} import scrape_{{TARGET_NAME}}
+
+
+class _ScrapeInput(BaseModel):
+    url: Optional[str] = Field(
+        default=None,
+        description=(
+            "Optional override URL. If omitted, scrapes the default starting URL "
+            "({{TARGET_URL}})."
+        ),
+    )
+
+
+class _Scrape{{TARGET_NAME}}Tool(BaseTool):
+    name: str = "scrape_{{TARGET_NAME}}"
+    description: str = (
+        "Scrape items from {{TARGET_URL}}. Use when the user asks for live data "
+        "from this site. Returns a JSON list of items."
+    )
+    args_schema: Type[BaseModel] = _ScrapeInput
+
+    def _run(self, url: Optional[str] = None) -> dict:
+        items = scrape_{{TARGET_NAME}}(url) if url else scrape_{{TARGET_NAME}}()
+        return {"count": len(items), "items": items}
+
+
+scrape_{{TARGET_NAME}}_tool = _Scrape{{TARGET_NAME}}Tool()
diff --git a/brightdata-scrape/templates/tool/langchain-ts.ts b/brightdata-scrape/templates/tool/langchain-ts.ts
new file mode 100644
index 0000000..5a2ef63
--- /dev/null
+++ b/brightdata-scrape/templates/tool/langchain-ts.ts
@@ -0,0 +1,32 @@
+/**
+ * LangChain tool definition for scraping {{TARGET_URL}}.
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ *
+ * Usage:
+ *   import { scrape{{TARGET_NAME}}Tool } from "./tools/scrape";
+ *   const agent = await createReactAgent({ llm, tools: [scrape{{TARGET_NAME}}Tool] });
+ */
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { scrape{{TARGET_NAME}} } from "../scrapers/{{TARGET_NAME}}";
+
+export const scrape{{TARGET_NAME}}Tool = tool(
+  async (input) => {
+    const items = await scrape{{TARGET_NAME}}(input.url);
+    return JSON.stringify({ count: items.length, items });
+  },
+  {
+    name: "scrape_{{TARGET_NAME}}",
+    description:
+      "Scrape items from {{TARGET_URL}}. Use when the user asks for live data from this site. Returns a JSON list of items.",
+    schema: z.object({
+      url: z
+        .string()
+        .optional()
+        .describe(
+          "Optional override URL. If omitted, scrapes the default starting URL ({{TARGET_URL}}).",
+        ),
+    }),
+  },
+);
diff --git a/brightdata-scrape/templates/tool/mastra.ts b/brightdata-scrape/templates/tool/mastra.ts
new file mode 100644
index 0000000..d7a7c83
--- /dev/null
+++ b/brightdata-scrape/templates/tool/mastra.ts
@@ -0,0 +1,37 @@
+/**
+ * Mastra tool definition for scraping {{TARGET_URL}}.
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ *
+ * Usage:
+ *   import { mastra } from "@/mastra";
+ *   import { scrape{{TARGET_NAME}}Tool } from "./tools/scrape";
+ *
+ *   // Register in your Mastra instance:
+ *   export const mastra = new Mastra({ tools: { scrape{{TARGET_NAME}}Tool } });
+ *
+ * Note: This template targets the Mastra v0.x / v1.x API.
+ * If the Tool constructor signature has changed, refer to the official
+ * Mastra docs at https://mastra.ai/docs and adjust accordingly.
+ */
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import { scrape{{TARGET_NAME}} } from "../scrapers/{{TARGET_NAME}}";
+
+export const scrape{{TARGET_NAME}}Tool = createTool({
+  id: "scrape_{{TARGET_NAME}}",
+  description:
+    "Scrape items from {{TARGET_URL}}. Use when the user asks for live data from this site. Returns a JSON list of items.",
+  inputSchema: z.object({
+    url: z
+      .string()
+      .optional()
+      .describe(
+        "Optional override URL. If omitted, scrapes the default starting URL ({{TARGET_URL}}).",
+      ),
+  }),
+  execute: async ({ context }) => {
+    const items = await scrape{{TARGET_NAME}}(context.url);
+    return { count: items.length, items };
+  },
+});
diff --git a/brightdata-scrape/templates/tool/openai-py.py b/brightdata-scrape/templates/tool/openai-py.py
new file mode 100644
index 0000000..873fa06
--- /dev/null
+++ b/brightdata-scrape/templates/tool/openai-py.py
@@ -0,0 +1,53 @@
+"""OpenAI function-calling tool definition for scraping {{TARGET_URL}}.
+
+Generated by the brightdata-scrape Kiro power.
+
+Usage:
+    from openai import OpenAI
+    from src.tools.scrape import SCRAPE_TOOL, run_scrape_tool
+
+    client = OpenAI()
+    response = client.chat.completions.create(
+        model="gpt-4o",
+        tools=[SCRAPE_TOOL],
+        messages=[{"role": "user", "content": "Scrape latest items from {{TARGET_URL}}"}],
+    )
+    # When the model calls the tool:
+    #   import json
+    #   args = json.loads(tool_call.function.arguments)
+    #   result = run_scrape_tool(args)
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from src.scrapers.{{TARGET_NAME}} import scrape_{{TARGET_NAME}}
+
+SCRAPE_TOOL: dict[str, Any] = {
+    "type": "function",
+    "function": {
+        "name": "scrape_{{TARGET_NAME}}",
+        "description": (
+            "Scrape items from {{TARGET_URL}}. Use when the user asks for live data "
+            "from this site. Returns a JSON list of items."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "url": {
+                    "type": "string",
+                    "description": (
+                        "Optional override URL. If omitted, scrapes the default starting URL "
+                        "({{TARGET_URL}})."
+                    ),
+                },
+            },
+        },
+    },
+}
+
+
+def run_scrape_tool(args: dict[str, Any]) -> dict[str, Any]:
+    url = args.get("url")
+    items = scrape_{{TARGET_NAME}}(url) if url else scrape_{{TARGET_NAME}}()
+    return {"count": len(items), "items": items}
diff --git a/brightdata-scrape/templates/tool/openai-ts.ts b/brightdata-scrape/templates/tool/openai-ts.ts
new file mode 100644
index 0000000..9f21847
--- /dev/null
+++ b/brightdata-scrape/templates/tool/openai-ts.ts
@@ -0,0 +1,46 @@
+/**
+ * OpenAI function-calling tool definition for scraping {{TARGET_URL}}.
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ *
+ * Usage:
+ *   import OpenAI from "openai";
+ *   import { scrapeTool, runScrapeTool } from "./tools/scrape";
+ *
+ *   const client = new OpenAI();
+ *   const response = await client.chat.completions.create({
+ *     model: "gpt-4o",
+ *     tools: [scrapeTool],
+ *     messages: [{ role: "user", content: "Scrape latest items from {{TARGET_URL}}" }],
+ *   });
+ *   // When the model calls the tool:
+ *   //   const args = JSON.parse(toolCall.function.arguments);
+ *   //   const result = await runScrapeTool(args);
+ */
+import { scrape{{TARGET_NAME}} } from "../scrapers/{{TARGET_NAME}}";
+
+export const scrapeTool = {
+  type: "function" as const,
+  function: {
+    name: "scrape_{{TARGET_NAME}}",
+    description:
+      "Scrape items from {{TARGET_URL}}. Use when the user asks for live data from this site. Returns a JSON list of items.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description:
+            "Optional override URL. If omitted, scrapes the default starting URL ({{TARGET_URL}}).",
+        },
+      },
+    },
+  },
+};
+
+export async function runScrapeTool(
+  args: { url?: string },
+): Promise<{ count: number; items: unknown[] }> {
+  const items = await scrape{{TARGET_NAME}}(args.url);
+  return { count: items.length, items };
+}
diff --git a/brightdata-scrape/templates/tool/vercel-ai-sdk.ts b/brightdata-scrape/templates/tool/vercel-ai-sdk.ts
new file mode 100644
index 0000000..44fde9e
--- /dev/null
+++ b/brightdata-scrape/templates/tool/vercel-ai-sdk.ts
@@ -0,0 +1,36 @@
+/**
+ * Vercel AI SDK tool definition for scraping {{TARGET_URL}}.
+ *
+ * Generated by the brightdata-scrape Kiro power.
+ *
+ * Usage:
+ *   import { openai } from "@ai-sdk/openai";
+ *   import { generateText } from "ai";
+ *   import { scrape{{TARGET_NAME}}Tool } from "./tools/scrape";
+ *
+ *   const result = await generateText({
+ *     model: openai("gpt-4o"),
+ *     tools: { scrape{{TARGET_NAME}}: scrape{{TARGET_NAME}}Tool },
+ *     prompt: "Scrape latest items from {{TARGET_URL}}",
+ *   });
+ */
+import { tool } from "ai";
+import { z } from "zod";
+import { scrape{{TARGET_NAME}} } from "../scrapers/{{TARGET_NAME}}";
+
+export const scrape{{TARGET_NAME}}Tool = tool({
+  description:
+    "Scrape items from {{TARGET_URL}}. Use when the user asks for live data from this site. Returns a JSON list of items.",
+  parameters: z.object({
+    url: z
+      .string()
+      .optional()
+      .describe(
+        "Optional override URL. If omitted, scrapes the default starting URL ({{TARGET_URL}}).",
+      ),
+  }),
+  execute: async ({ url }) => {
+    const items = await scrape{{TARGET_NAME}}(url);
+    return { count: items.length, items };
+  },
+});