Web-Scraper aus einem Prompt mit Kiro und Bright Data erstellen

Ein Web-Scraper bricht zusammen, wenn eine Website ihr Markup ändert oder dich zu blockieren beginnt. Die brightdata-scrape Kiro Power erstellt einen Scraper aus einem Prompt in natürlicher Sprache und führt ihn gegen Bright Data’s Web MCP aus, das die Entsperrung und das Parsing übernimmt. Diese Anleitung wendet ein wiederholbares Power-Muster auf 4 Anwendungsfälle an, wobei 2 bis zu einem Live-API-Aufruf durchgeführt werden, einschließlich eines, der prüft, ob ChatGPT deine Marke nennt.

TL;DR

Am Ende wirst du ein Power-Muster haben, das du auf 4 Anwendungsfälle anwenden kannst, jeder durch einen einzigen Prompt in natürlicher Sprache gesteuert, mit 2 die bis zu einem Live-API-Aufruf durchgeführt werden:

• Retail-Preistracker, verfolgt ein Produkt auf Amazon und Walmart.
• Markensichtbarkeits-Monitor, zeigt, welche KI-Assistenten deine Marke erwähnen.
• LinkedIn-Lead-Gen-Pipeline, überwacht eine Interessentenliste auf Jobwechsel.
• Crunchbase-Intelligence-Dashboard, ruft Dutzende von Live-Feldern pro Unternehmen ab.

Der Kiro-Agent führt 2 Live-Tool-Aufrufe durch – search_engine, dann scrape_as_markdown – und gibt einen echten Amazon-Preis von $248 zurück.

Was ist eine Kiro Power?

Kiro ist die von AWS entwickelte KI-IDE. Eine Power ist Kiros eigenes Erweiterungsformat: ein Ordner mit einem Manifest, einer MCP-Server-Konfiguration, Steuerungsdateien und Code-Templates. Kiro lädt eine Power nur dann in den Kontext, wenn dein Prompt sie aktiviert. Durchsuche den offiziellen Katalog auf kiro.dev/powers. Bright Data veröffentlicht brightdata-scrape separat auf GitHub, sodass du sie direkt importieren kannst.

Powers unterscheiden sich von Claude Skills in einem wichtigen Punkt: Jede Power enthält bereits eine MCP-Server-Konfiguration (Model Context Protocol). Der Agent erhält also neue Tools zum Aufrufen, nicht nur Anweisungen. Für brightdata-scrape ist dieser Server Bright Data’s Web MCP.

Dieser Endpunkt bietet dir Web Unlocker, SERP-API, Browser-API und Bright Data’s vorgefertigten Datensatz-Katalog. Bright Data’s MCP ermöglicht dem Agenten, alle davon in einem einzigen Tool-Aufruf zu nutzen. Diese Tools (search_engine, scrape_as_markdown, die 50 web_data_* Pro-Tools, scraping_browser_* und discover) ersetzen, was früher 3 separate Integrationen waren – ein Proxy, eine SERP-API und eine Browser-Farm – durch einen Satz Zugangsdaten und ein Retry-Muster.

Die brightdata-scrape Kiro Power installieren

Es gibt 5 Schritte, um das Projekt einzurichten und die Verbindung zu bestätigen:

1. Einen Bright Data API-Token holen. Unter Benutzer und API-Schlüssel → API-Schlüssel einen Schlüssel mit Benutzer-Berechtigung hinzufügen, ein Ablaufdatum festlegen und den Wert kopieren. Für den kostenlosen Tarif ist keine Kreditkarte erforderlich.
2. Kiro installieren, dann das Projekt erstellen und öffnen. Kiro herunterladen und installieren. Die Power benötigt ein Projekt, in dem sie arbeiten kann, und diese Anleitung verwendet Next.js. Erstelle daher eines und öffne den price-tracker-Ordner in Kiro:

npx create-next-app@latest price-tracker \

–typescript, app, tailwind, src-dir, use-npm

cd price-tracker

Du musst jetzt nichts anderes installieren. Kiro fügt alle Pakete hinzu, die der generierte Scraper später benötigt, in Phase 3.

1. Die Power installieren. Das Powers-Panel in Kiro öffnen (das Symbol in der linken Aktivitätsleiste). Auf Custom Power hinzufügen klicken, dann Power von GitHub importieren, dann diese URL einfügen:

https://github.com/brightdata/kiro-powers/tree/main/brightdata-scrape

1. Kiro den Token geben. Durch die Installation der Power wird ein brightdata-Server zur .kiro/settings/mcp.json deines Projekts mit der URL https://mcp.brightdata.com/mcp?token=${BRIGHTDATA_API_KEY} hinzugefügt. Öffne diese Datei, ersetze ${BRIGHTDATA_API_KEY} durch den wörtlichen Token, den du in Schritt 1 kopiert hast, und speichere. Füge dann .kiro/settings/mcp.json zu .gitignore hinzu, damit der Token nie committed wird.

> Warum der wörtliche Token, nicht der ${…}-Platzhalter? Kiro expandiert ${VAR} in mcp.json derzeit nicht (ein bekanntes offenes Problem), sodass der Platzhalter statt einer Verbindung Connection Failed / HTTP 404 zurückgibt.

1. Die Verbindung bestätigen. Das MCP-Server-Panel erneut öffnen. Nach einigen Sekunden zeigt brightdata Verbunden mit search_engine und scrape_as_markdown unter seinen Tools, was das benötigte Signal ist.

Erstelle nun .env.local im Projektstamm und füge denselben Token ein. Du fügst den Token bewusst zweimal ein: Die Kopie in .kiro/settings/mcp.json (Schritt 4) verbindet Kiro während des Builds mit Bright Data, und diese Kopie wird von der generierten App beim Ausführen gelesen.

BRIGHTDATA_API_KEY=...          # der oben generierte Token
BRIGHTDATA_UNLOCKER_ZONE=...    # Platzhalter ist für den Retail-Build in Ordnung; vor einem Web-Unlocker-Anwendungsfall setzen

Bei einem brandneuen Konto oder vor der Ausführung eines Web-Unlocker-Anwendungsfalls zuerst den Zone-Namen festlegen. Siehe Web-Unlocker-Zone einrichten unter Alle 4 Anwendungsfälle auf Produktion skalieren weiter unten.

Bei allen 4 Anwendungsfällen ändert sich nur der Prompt; der 4-Phasen-Workflow bleibt gleich.

Kiros 4-Phasen-Workflow (ein Muster für alle 4)

Die Power durchläuft für jeden Prompt dieselben 4 Phasen. Jede Phase wartet auf deine Genehmigung, bevor sie fortfährt:

1. Erkennen & planen. Die Power prüft das Workspace-Manifest (package.json, pyproject.toml, Cargo.toml, go.mod usw.) und die darin enthaltenen Abhängigkeiten. Sie wählt dann, wie sie integriert werden soll: Wenn sie ein Web-Framework findet, generiert sie eine API-Route; wenn sie ein Agent-SDK findet, generiert sie ein Agent-Tool; und wenn das Projekt eine Bibliothek ist, generiert sie ein Modul. Sie fragt dich, was gescrapt werden soll und wie viele Elemente.

1. Scraping-Playbook. Die Power prüft Bright Data’s Tool-Leiter und wählt für jede Zielseite den besten Pfad, den dein Tarif erlaubt: ein Web Data Pro-Tool (eines von 50 web_data_*-Tools für 30+ Plattformen, typisierte Felder, erfordert &pro=1) → ein Datensatz-Trigger (dieselben Daten, abgefragt, kein &pro=1 erforderlich) → Web Unlocker (Proxy + Parsing für Long-Tail-Sites) → Browser-API (Login/Klick-Flows) → SERP-API (Suchergebnisse).

1. Integrieren. Die Power generiert die Dateien. Der Retail-Lauf unten produzierte 4: ein Scraper-Modul, eine API-Route, eine Dashboard-Seite und einen neuen ## Web-Scraping-Abschnitt in README.md. (.env.local enthielt bereits den API-Token, daher hat Phase 3 ihn übersprungen. Das ist die Dateisicherheitsregel: Eine bereits vorhandene Datei wird nicht überschrieben.)

1. MCP & verifizieren. Die Power fügt Bright Data’s MCP-Server in .kiro/settings/mcp.json zusammen und führt einen Smoke-Test gegen die Ziel-URL durch. In dieser Phase laufen zwei Produktionssicherungen: das Diff-vor-Überschreiben und die FAIL → ITERATE-Wiederherstellung. Phase 4 von Anwendungsfall 1 zeigt die vollständige Wiederherstellung.

Was live ausgeführt wurde und was gezeigt wird

Alles hier wurde gegen die Live-API verifiziert, kein Mockup. Die genauen Preise, Tools und Zeitangaben stammen aus spezifischen erfassten Läufen. Da die Scraper Live-Daten lesen, spiegeln deine eigenen Ergebnisse aktuelle Preise, Seiten und Modellantworten wider, nicht diese erfassten.

• Anwendungsfälle 1 und 4 liefen vollständig gegen die Live-API: Retail (ohne Pro-Ausgaben) und Crunchbase (im Pro-Tarif). Jeder Retail-Screenshot unten stammt aus diesem Lauf, und der vollständige Code von Anwendungsfall 4 befindet sich in seinem Abschnitt.
• Anwendungsfälle 2 und 3 werden gezeigt, nicht neu erstellt: der Prompt, die Tools, die Phase 2 auswählen würde, und Feldformen, deren Namen wir live gegen jedes Tool verifiziert haben. Sie verwenden den callMcpTool-Client von Anwendungsfall 4 wieder, sodass kein nahezu identischer Code erneut eingefügt werden muss.
• Anwendungsfälle 2, 3 und 4 laufen im Pro-Modus (&pro=1), was der Abschnitt ‘Auf Produktion skalieren’ weiter unten behandelt.

Anwendungsfall 1: Multi-Retailer-Preisverfolgung

Hier ist der Prompt für Kiro:

Prompt an Kiro: “Füge einen Preisvergleichs-Agenten hinzu, der Sony WH-1000XM5-Preise von Amazon und Walmart scrapt.”

Auswahl in Phase 2: Im erfassten Zero-Pro-Lauf wählte die Power den Datensatz-Trigger-Pfad (dieselben Daten, abgefragt). Mit &pro=1 würde sie stattdessen die Pro-Tools web_data_amazon_product und web_data_walmart_product wählen.

Auf weitere Retailer erweitern: Dasselbe Muster fügt web_data_ebay_product, web_data_homedepot_products und web_data_bestbuy_products hinzu, indem Kiro mit einer erweiterten Retailer-Liste erneut aufgefordert wird. Einige Retailer (Best Buy, Target) benötigen typischerweise Premium-Domains, die in der Zone aktiviert sind; Amazon und Walmart benötigten das im erfassten Lauf nicht.

Die von Kiro generierte Architektur

Das Dashboard ruft die API beim Laden ab. Die API ruft Bright Data’s Datensatz-Trigger parallel auf und gibt die strukturierten Datensätze zurück.

       Browser öffnet /
                │
                ▼ (automatischer Abruf beim Laden)
        GET /api/scrape-prices
                │
                ▼
    src/scrapers/price-tracker.ts
        fetchAllPrices()
                │
                ▼ (Promise.allSettled, parallel)
   ┌────────────────────────────────────┐
   │  Bright Data Datasets API          │
   │  gd_l7q7dkf244hwjntr0 → Amazon     │
   │  gd_l95fol7l1ru6rlo116 → Walmart   │
   └────────────────────────────────────┘

Ein Lesepfad: Dashboard → API-Route → Scraper-Modul → 2 Bright Data Datensatz-Trigger. Mit &pro=1 wird das Scraper-Modul zu direkten web_data_ MCP-Aufrufen, und die clientseitige Polling-Schleife wechselt in den MCP-Server.*

Das Scraper-Modul

src/scrapers/price-tracker.ts enthält die Datensatz-IDs, einen triggerAndPoll-Helfer und einen normalise-Schritt, der Bright Data’s Antwort in eine konsistente PriceResult-Form abflacht. Hier ist der Kern der Datei, die vollständige Datei umfasst etwa 85 Zeilen:

// src/scrapers/price-tracker.ts (Auszug)
const BASE = "https://api.brightdata.com/datasets/v3";
const DATASETS = { Amazon: "gd_l7q7dkf244hwjntr0", Walmart: "gd_l95fol7l1ru6rlo116" } as const;

async function triggerAndPoll(datasetId: string, url: string) {
  // 1. POST-Trigger mit der Ziel-URL
  const trigger = await fetch(`${BASE}/trigger?dataset_id=${datasetId}&include_errors=true`, {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.BRIGHTDATA_API_KEY}`,
               "Content-Type": "application/json" },
    body: JSON.stringify([{ url }]),
  });
  const { snapshot_id } = await trigger.json();
  if (!snapshot_id) throw new Error("no snapshot_id returned from trigger");

  // 2. Snapshot-Endpunkt abfragen (in-progress = HTTP 202; ~120 s Limit)
  for (let i = 0; i < 24; i++) {
    await new Promise((r) => setTimeout(r, 5000));
    const res = await fetch(`${BASE}/snapshot/${snapshot_id}?format=json`,
      { headers: { Authorization: `Bearer ${process.env.BRIGHTDATA_API_KEY}` } });
    if (res.status === 202) continue;
    return await res.json();
  }
  throw new Error("snapshot timed out after 120s");
}

// löst beide Retailer parallel aus; Promise.allSettled isoliert Fehler pro Retailer,
// sodass ein schlechter Snapshot den anderen nicht fehlschlagen lässt. Die vollständige Datei mappt
// jedes abgeschlossene Ergebnis in ein PriceResult (abgelehnte tragen ein `error`-Feld).
export async function fetchAllPrices() {
  return Promise.allSettled(
    Object.entries(DATASETS).map(([retailer, id]) =>
      triggerAndPoll(id, PRODUCT_URLS[retailer]).then((r) => normalise(r[0], retailer, PRODUCT_URLS[retailer]))),
  );
}

Kiros Chat ist ein Live-MCP-Client, kein Speicher-Lookup

Während des Builds kommuniziert Kiros Chat-Panel mit demselben brightdata-Server, den dein Code aufruft. Nach dem Sony-Preis gefragt, antwortete der Chat nicht aus dem Modellspeicher. Er führte Live-Aufrufe von search_engine und scrape_as_markdown durch und gab eine Tabelle zurück ($195,55 refurb bis $248 neu, plus einen XM6-Vergleich bei $398):

Der Chat ist dein Erkundungswerkzeug beim Bauen. Das Dashboard unten ist das, was deine Endnutzer sehen.

Das Dashboard

Die von Kiro generierte Home-Route (/) rendert das JSON, das die API zurückgibt, als 2 farbige Karten (Amazon orange und Walmart blau) plus ein grünes “Bester Preis”-Banner, das den günstigeren der beiden auswählt:

Die Home-Route (/). Sony WH-1000XM5 bei $248 auf Amazon und Walmart mit Produkttiteln, Lagerstatus und retailerspezifischen Zeitstempeln, direkt aus jeder Quelle gelesen. Walmarts rohes in_stock und Amazons In Stock werden unverändert weitergegeben, sodass du genau siehst, was jede Quelle zurückgibt. Normalisiere auf dein eigenes Schema, wenn du Benachrichtigungen darauf aufbaust.

Wenn du die Rohseiten selbst untersuchst, gibt Amazons offensichtlicher Preisselektor (span.a-price-whole) normalerweise leer zurück, und der echte ist .a-price .a-offscreen. Walmart fügt den Preis überhaupt nicht in das gerenderte HTML ein; er befindet sich in einem JSON-Blob in <script id="NEXT_DATA">. Die obigen Datensatz-Trigger umgehen beide Probleme, weil Bright Data die Seiten serverseitig parst und typisierte Felder zurückgibt.

Phase 4: Selbstheilung bei URL-Drift

Phase 4 ist die Wiederherstellungsroutine, die die Power automatisch ausführt, wenn ein Smoke-Test fehlschlägt. Im erfassten Lauf gab Amazon saubere Daten zurück ($248, In Stock), aber Walmart gab jedes Feld als null zurück. Kiro erklärte keinen Erfolg. Stattdessen las es den error-Schlüssel des Rohdatensatzes ("dead page (404)"), rief search_engine auf, um die aktuelle Walmart-URL zu finden, löste den Datensatz erneut aus und wechselte zu scrape_as_markdown, als das Polling ins Stocken geriet (gab $248 zurück, übereinstimmend mit Amazon). Dann patchte es den generierten Scraper:

Phase 4 erkennt die tote Walmart-URL, findet die aktive und patcht den Scraper eigenständig. Die 18m 54s beinhalten den erneut abgefragten Datensatz-Job, und die 4,5 Credits sind einmalige Build-Phasen-Kosten, keine Laufzeitkosten.

Die Wiederherstellungsschleife fängt Fehler ab, die einen Fehler werfen oder null-Felder zurückgeben (tote 404s, neu gestaltete Seiten, Snapshot-Fehler). Sie fängt jedoch nicht eine URL ab, die noch aufgelöst wird, aber auf das falsche Produkt zeigt. Zum Beispiel gibt eine walmart.com/ip/...-ID, die stillschweigend von Sony-Kopfhörern auf eine PS5-Liste gewechselt hat, gültige Daten für das falsche Produkt zurück. Um diesen Fall abzufangen, benötigst du suchgesteuerte URLs statt fest codierten IDs (behandelt im Abschnitt zur Skalierung auf Produktion weiter unten).

Erfasste Kosten über die Phasen 2 und 4 (jeweils in den obigen Screenshots sichtbar): 0,38 → 1,38 → 4,5 Credits (laufende Summe). Dies sind Kiro IDE Build-Zeit-Credits, die Nutzung des Agenten beim Schreiben des Codes, getrennt von der Bright Data-Abrechnung. Dieser erfasste Lauf kostete also 4,5 Credits insgesamt, aber der Großteil davon war die einmalige Phase-4-Selbstheilung. Ein sauberer Build ohne Wiederherstellung beträgt etwa 2 Credits (geschätzt, da wir keinen Lauf ohne Selbstheilung erfasst haben).

Produktionssicherungen: Selbstheilung, keine stillen Überschreibungen, CI-validierte Templates

In Anwendungsfall 1 erkannte Phase 4 eine tote Walmart-URL und weigerte sich, Erfolg zu erklären. Dieses Verhalten wird nicht bei jedem Lauf improvisiert. Es stammt aus den Produktionsregeln, die in die Steuerungsdateien der Power eingebaut sind. Hier ist der vollständige Satz dieser Regeln:

• Dateisicherheit (Phase 3). Die Power überschreibt keinen vorhandenen Scraper (sie schlägt _2.ts vor), hängt an README.md / .env.example an statt zu ersetzen, und zeigt eine CREATE/MODIFY-Liste vor dem Schreiben.
• MCP-Konfigurations-Merge (Phase 4). Die Power erkennt einen vorhandenen brightdata-Eintrag in .kiro/settings/mcp.json, zeigt ein Diff, wenn die URL abweicht, und fragt vor dem Ersetzen, sodass es keine stillen Überschreibungen gibt.
• Smoke-Test FAIL → ITERATE. Nach dem Verbinden des MCP führt die Power den Scraper gegen dein Ziel aus. Bei leerem, null oder Fehler sagen die Steuerungsanweisungen wörtlich: “Zurück zu Phase 2… Keinen Erfolg erklären.”
• CI-getestete Templates (49 Tests bestehen). validate_power.py und test_validate_power.py prüfen Frontmatter, MCP-Konfiguration, Steuerung und Template-Präsenz. Sie testen nicht generierten Code gegen eine Live-Site; das ist die Aufgabe des Phase-4-Smoke-Tests, pro Projekt.
• Automatische Zone-Bereitstellung. Der MCP-Server ruft /zone/get_active_zones auf und erstellt fehlende Zonen beim ersten Lauf, sodass ein neues Konto keine Web-Unlocker-Zone manuell erstellen muss.

Anwendungsfall 2: GEO-Markensichtbarkeits-Monitor

Das Sichtbarkeitsproblem. Käufer bilden ihre Shortlist zunehmend auf LLM-Antwortseiten (ChatGPT, Grok, Perplexity), bevor sie mit dem Vertrieb sprechen, sodass wer nicht unter den Top 3 ist, von vielen Käufern möglicherweise nie gesehen wird. Das Problem ist, dass traditionelle Marken-Monitoring-Tools (PR, Social Listening, SEO) nicht dafür entwickelt wurden, LLM-Antworten zu beobachten, sodass du deinen Rang nicht zuverlässig sehen kannst.

Prompt an Kiro: “Füge einen Markensichtbarkeits-Monitor hinzu, der scrapt, wie ChatGPT, Grok und Perplexity meine 5 wichtigsten Käufer-Anfragen beantworten, und mich benachrichtigt, wenn meine Marke nicht mehr erwähnt wird.”

Die GEO-Tools und was sie zurückgeben

Pro-Tools für diesen Anwendungsfall: Phase 2 würde die geo-Gruppe wählen: web_data_chatgpt_ai_insights, web_data_grok_ai_insights und web_data_perplexity_ai_insights. Jedes Tool ist seine Engine (es gibt keinen Engine-Selektor), nimmt ein einzelnes prompt-Argument und gibt die gerenderte LLM-Antwort als Markdown zurück. Mit einem Tool pro Engine deckst du die 3 wichtigsten Antwortseiten ab, die deine Käufer heute nutzen, nicht nur ChatGPT.

Phase 3 generiert ein src/scrapers/brand_visibility.ts-Modul, das jedes web_data_*-Tool mit einem einzelnen { prompt } aufruft und dessen answer_text_markdown sammelt. ChatGPT und Perplexity geben inline zurück und laufen zusammen unter Promise.all. Grok läuft normalerweise über das MCP-Poll-Fenster hinaus und gibt asynchron zurück, daher bleibt es auf einem separaten nicht-blockierenden Pfad; behandle es als eventually-consistent, nicht als blockierenden Aufruf.

Hier ist die Live-Antwortform, direkt von web_data_chatgpt_ai_insights und web_data_perplexity_ai_insights mit dem Prompt “Was ist das beste CDP für Mid-Market-SaaS?” erfasst, und beide gaben dieselbe einfeldi​ge Form zurück (Groks asynchroner Aufruf lief über ein 9-minütiges Poll hinaus):

{
  "answer_text_markdown": "For most **mid-market SaaS companies (roughly 50,1,000 employees)**, the answer depends less on \"which CDP is best\" than on your data-stack maturity. My ranking: 1) [Hightouch](https://hightouch.com?utm_source=chatgpt.com) , warehouse-native; 2) [Twilio Segment](https://segment.com?utm_source=chatgpt.com) , all-in-one; 3) [RudderStack](https://www.rudderstack.com?utm_source=chatgpt.com) , engineering-led..."
}

Das Tool gibt die Modellantwort als einzelnen answer_text_markdown-String zurück, nicht als vorparsiertes Marken-Ranking. Der Marken-Extraktionsschritt liegt bei dir. Ein naiver erster Ansatz ist eine einzelne includes()-Prüfung gegen den Markdown, aber sie übersieht Groß-/Kleinschreibung, Namensvarianten und deine Marke innerhalb eines anderen Wortes. Für den realen Einsatz übergib den Markdown an einen günstigen LLM-Aufruf und frage nach der Rangliste.

Die Alert-Schleife und wer sie installiert

Die Alert-Schleife funktioniert so: Sie speichert 1 answer_text_markdown-Zeile pro Engine pro Tag, dann extrahiert sie, ob (und wo) deine Marke erscheint, dann benachrichtigt sie dich, wenn deine Marke aus einer Antwort verschwindet, in der sie zuvor war, und schließlich rendert sie ein 3-Engine-Raster der heutigen Antworten mit Markenpräsenz-Flags.

Ein Vorbehalt, bevor du Benachrichtigungen einrichtest: LLM-Antworten sind nicht-deterministisch, sodass derselbe Prompt Marken von einem Lauf zum nächsten unterschiedlich ranken kann. Ein einzelner täglicher Abruf ist eine Stichprobe, kein stabiles Signal, sodass eine Marke, die einen Tag lang verschwindet, oft Rauschen ist und keine echte Änderung. Sample jeden Prompt einige Male oder glätte über mehrere Tage, bevor du einen Rückgang als real behandelst.

Wer das installiert: Dies ist für B2B-SaaS-Marketing- und DevRel-Teams, Marken-Monitoring-Agenturen, die LLM-Abdeckung hinzufügen, und KI/ML-Forscher, die Modell-Output-Drift verfolgen. Die Nutzung beläuft sich auf 5 Prompts über 3 täglich abgefragte Engines, was etwa 450 Aufrufe/Monat oder ungefähr $0,68/Monat bei Pay-per-Use-Tarifen sind.

Anwendungsfall 3: LinkedIn-Lead-Gen-Pipeline

Das B2B-Problem ist, dass du 50 Vertriebsinteressenten (oder Kandidaten oder Partner-Programm-Kontakte) auf Jobwechsel, Unternehmenswechsel oder Beförderungen verfolgen musst. Die übliche Lösung ist LinkedIn Sales Navigator plus ein manueller Review-Workflow. Die Option mit strukturierten Daten ist 1 MCP-Aufruf pro Interessent, täglich abgefragt.

Prompt an Kiro: “Beobachte diese 50 LinkedIn-Interessenten auf Jobwechsel, Unternehmenswechsel oder Beförderungen. Benachrichtige mein CRM, wenn sich etwas ändert.”

Die LinkedIn-Tools und was sie zurückgeben

Pro-Tools für diesen Anwendungsfall. Phase 2 würde den LinkedIn-Cluster innerhalb der social-Gruppe wählen: web_data_linkedin_person_profile, web_data_linkedin_company_profile, web_data_linkedin_job_listings und web_data_linkedin_people_search.

Hier ist, was Phase 3 generiert (Feldnamen live gegen das Tool verifiziert):

// src/scrapers/linkedin_prospects.ts (Auszug)
import { callMcpTool } from "@/lib/mcp-client"; // Kiro generiert diesen MCP-Client-Aufruf in Phase 3 , kein installierbares Paket

interface ProspectSnapshot {
  url: string;
  current_company_name: string;  // current_company ist ein verschachteltes Objekt; *_name ist der String
  position: string;              // Berufsbezeichnungsfeld , es gibt kein "current_title"
  location: string;
  followers: number;
}

type Change = { field: string; from: string; to: string };

export const snapshotProspect = (url: string) =>
  callMcpTool("web_data_linkedin_person_profile", { url }) as Promise<ProspectSnapshot>;

// Vergleicht heute mit gestern; gibt ein Change für jedes Feld aus, das sich geändert hat.
export function diffProspect(prev: ProspectSnapshot, now: ProspectSnapshot): Change[] {
  return (["current_company_name", "position"] as const)
    .filter((f) => prev[f] !== now[f])
    .map((f) => ({ field: f, from: prev[f], to: now[f] }));
}

Der vollständige Datensatz gibt 30+ typisierte Felder zurück, einschließlich current_company (Objekt), experience[], education[], about, followers, connections, city, country_code und mehr.

Die CRM-Benachrichtigungsschleife und wer sie installiert

Die CRM-Benachrichtigungsschleife funktioniert so: Sie speichert den gestrigen Snapshot pro Interessent, führt dann täglich den aktuellen Abruf und Vergleich aus einem Hintergrundworker durch, und postet dann Änderungen an den Webhook deines CRM (Salesforce, HubSpot, Attio, nicht Bright Data’s MCP).

Wer das installiert: Dies ist für B2B-Vertrieb, Recruiting, RevOps und Partner-Programm-Manager. Die Nutzung beläuft sich auf 50 täglich abgefragte Interessenten, was etwa 1.500 Aufrufe/Monat oder ungefähr $2,25/Monat bei Bezahlung pro Nutzung sind.

Anwendungsfall 4: Wettbewerbsanalyse-Dashboard

Das Corp-Dev- und Strategie-Problem ist folgendes: Teams müssen eine Beobachtungsliste von Wettbewerbern und Akquisitionszielen auf Finanzierungsrunden, Mitarbeiterzahländerungen und Momentum-Verschiebungen verfolgen. Die übliche Grundlage ist ein manueller Crunchbase-Refresh-und-Tabellenkalkulations-Workflow. Die Option mit strukturierten Daten ist 1 MCP-Aufruf pro Unternehmen, wöchentlich abgefragt.

Prompt an Kiro: “Verfolge diese 30 Wettbewerber auf Crunchbase. Benachrichtige mich, wenn einer eine Finanzierungsrunde abschließt, eine Mitarbeiterzahl-Schwelle überschreitet oder im Wachstumsranking aufsteigt.”

Das Crunchbase-Tool und was es zurückgibt

In Phase 2 ausgewähltes Pro-Tool: Die Power wählt web_data_crunchbase_company (die business-Gruppe). Live verifiziert gibt es 93 typisierte Felder pro Unternehmen zurück, einschließlich funds_raised, num_funding_rounds, acquisitions, exits, num_employees, cb_rank, growth_score, heat_score, founders, built_with_tech, ipo_status und region.

Hier ist, was Phase 3 generiert:

// src/scrapers/competitor_intel.ts
import { callMcpTool } from "@/lib/mcp-client"; // Kiro generiert diesen MCP-Client-Aufruf in Phase 3 , kein installierbares Paket

interface CompanySnapshot {
  name: string;
  num_employees: string;      // Band, z.B. "5001-10000"
  cb_rank: number;            // Crunchbase-Rang (niedriger = prominenter)
  growth_score: number;       // 0-100
  heat_score: number;         // 0-100 Momentum-Signal
  funds_raised: unknown[];    // Array von Finanzierungs-/Investitionsereignissen
  ipo_status: string;         // "private" | "public" | ...
  region: string;
  url: string;
}

type Alert =
  | { kind: "headcount_band"; from: string; to: string }
  | { kind: "new_funding_event"; count: number }
  | { kind: "growth_surge"; from: number; to: number };

// die MCP-Zeile kommt untypisiert an, daher werden nur die verfolgten Felder in einen typisierten CompanySnapshot gemappt
export async function snapshotCompany(url: string): Promise<CompanySnapshot> {
  const row = await callMcpTool<Record<string, unknown>>("web_data_crunchbase_company", { url });
  return {
    name: String(row.name ?? ""),
    num_employees: String(row.num_employees ?? ""),
    cb_rank: Number(row.cb_rank ?? 0),
    growth_score: Number(row.growth_score ?? 0),
    heat_score: Number(row.heat_score ?? 0),
    funds_raised: Array.isArray(row.funds_raised) ? row.funds_raised : [],
    ipo_status: String(row.ipo_status ?? ""),
    region: String(row.region ?? ""),
    url,
  };
}

export function detectMoves(
  prev: CompanySnapshot, now: CompanySnapshot,
): Alert[] {
  const alerts: Alert[] = [];
  if (now.num_employees !== prev.num_employees) {
    alerts.push({ kind: "headcount_band", from: prev.num_employees, to: now.num_employees });
  }
  if (now.funds_raised.length !== prev.funds_raised.length) {
    alerts.push({ kind: "new_funding_event", count: now.funds_raised.length - prev.funds_raised.length });
  }
  if (now.growth_score - prev.growth_score >= 5) {
    alerts.push({ kind: "growth_surge", from: prev.growth_score, to: now.growth_score });
  }
  return alerts;
}

Live-Beispiel. Ein echter Aufruf von web_data_crunchbase_company für Stripe gab num_employees: "5001-10000", cb_rank: 300, growth_score: 98, heat_score: 60, ipo_status: "private", region: "California" zurück, plus ein befülltes funds_raised-Array von Investitionsereignissen.

Die Power generierte die 4 Dateien (den obigen Scraper, den Client unten, eine API-Route, eine Dashboard-Seite), und der generierte Code kompilierte mit null TypeScript-Fehlern. Mit gesetztem BRIGHTDATA_API_KEY gab das Ausführen gegen den Live-MCP (~58 s für den Live-Scrape) den Stripe-Datensatz oben zurück und renderte dies:

Die Home-Route (/), live gerendert aus demselben web_data_crunchbase_company-Aufruf, der den Stripe-Datensatz oben zurückgab.

Um es selbst auszuführen, klone das Beispiel-Repo: git clone https://github.com/triposat/crunchbase-intel-demo && cd crunchbase-intel-demo && npm install && cp .env.example .env.local, füge einen Pro-fähigen Token ein und führe npm run dev aus. (&pro=1 ist bereits in der mcp-client.ts des Repos; du benötigst nur ein Konto mit aktiviertem Pro-Modus.)

Der gemeinsame MCP-Client

Das callMcpTool, das der Scraper importiert, ist ein schlanker MCP-Client, den die Power in Phase 3 generiert – derselbe, für den die GEO- und LinkedIn-Module geschrieben wurden, um ihn wiederzuverwenden. Hier ist er vollständig:

// src/lib/mcp-client.ts , der Client, zu dem callMcpTool auflöst
const MCP_URL = `https://mcp.brightdata.com/mcp?token=${process.env.BRIGHTDATA_API_KEY}&pro=1`;

async function post(body: unknown, sessionId?: string) {
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    Accept: "application/json, text/event-stream",
  };
  if (sessionId) headers["mcp-session-id"] = sessionId;
  return fetch(MCP_URL, { method: "POST", headers, body: JSON.stringify(body) });
}

// der Server antwortet als SSE: ein JSON-Objekt pro `data:`-Zeile
function parseSse(text: string) {
  if (!text.includes("data:")) {
    try { return [JSON.parse(text)]; }
    catch { throw new Error(`MCP returned a non-JSON response: ${text.slice(0, 120)}`); }
  }
  return text.split("\n").filter((l) => l.startsWith("data:"))
    .map((l) => { try { return JSON.parse(l.slice(5).trim()); } catch { return null; } })
    .filter(Boolean);
}

export async function callMcpTool<T = unknown>(name: string, args: Record<string, unknown>): Promise<T> {
  // 1. initialisieren , die Session-ID kommt als Antwort-Header zurück
  const init = await post({ jsonrpc: "2.0", id: 1, method: "initialize",
    params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "intel", version: "1.0" } } });
  if (!init.ok) throw new Error(`MCP connection failed: HTTP ${init.status} ${init.statusText}. Check BRIGHTDATA_API_KEY.`);
  const sessionId = init.headers.get("mcp-session-id") ?? undefined;
  await init.text();

  // 2. initialisiert bestätigen, dann 3. Tool aufrufen
  await post({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }, sessionId);
  const res = await post({ jsonrpc: "2.0", id: 2, method: "tools/call", params: { name, arguments: args } }, sessionId);
  if (!res.ok) throw new Error(`MCP tool call failed: HTTP ${res.status} ${res.statusText}.`);

  const reply = parseSse(await res.text()).find((m: { id?: number }) => m?.id === 2);
  if (reply?.error) throw new Error(`MCP error: ${reply.error.message}`);
  const text = reply?.result?.content?.find((c: { type: string }) => c.type === "text")?.text;
  const payload = text ? JSON.parse(text) : reply?.result;
  return (Array.isArray(payload) ? payload[0] : payload) as T;
}

Lege diese Datei in src/lib/, und der obige Crunchbase-Scraper ist bereit zum Ausführen.

Die Beobachtungsschleife und wer sie installiert

Die Beobachtungsschleife funktioniert so: Sie speichert den Snapshot der letzten Woche pro Unternehmen, vergleicht dann den Snapshot dieser Woche mit dem der letzten Woche, und postet dann alle Finanzierungsereignisse, Mitarbeiterzahl-Schwellenüberschreitungen oder Wachstumsscore-Anstiege in deinen Strategie-Slack-Kanal. Die Nutzung beläuft sich auf 30 wöchentlich abgefragte Unternehmen, was etwa 120 Aufrufe/Monat oder ungefähr $0,18/Monat bei Bezahlung pro Nutzung sind.

Wer das installiert: Dies ist für Unternehmensentwicklung, Wettbewerbsanalyse, Strategie, VC/PE-Deal-Teams und Vertriebsmitarbeiter, die Account-Intelligence aufbauen. Diese Teams benötigen Datentiefe statt Retail-Volumen, weil sie 93 strukturierte Felder pro Unternehmen benötigen, die sie sonst manuell sammeln würden.

Alle 4 Anwendungsfälle auf Produktion skalieren

Die generierten Scraper kompilieren mit null TypeScript-Fehlern und laufen gegen die Live-API (die Retail- und Crunchbase-Läufe oben), mit den obigen Sicherungen. Diese Änderungen bringen sie auf Produktionsmaßstab, indem die Hintergrundjobs, Snapshot-Tabellen und Volumeneinstellungen hinzugefügt werden, die echte Workloads benötigen:

• Auf Pro-Tools umstellen. &pro=1 an die MCP-URL in .kiro/settings/mcp.json anhängen, sodass sie https://mcp.brightdata.com/mcp?token=<dein-token>&pro=1 lautet, und den Server neu starten. (Beachte das führende &, da token= bereits den Query-String öffnet.) Phase 2 wählt web_data_*-Tools statt Datensatz-Trigger. Das Polling fällt typischerweise auf Sekunden, und das Parsing wird zu einem typisierten Feldlesen. Das Flag wird an 2 Stellen gesetzt: in .kiro/settings/mcp.json, damit Kiros Agent die Pro-Tools sieht, und in der generierten App’s src/lib/mcp-client.ts, damit die laufende App sie aufruft.
• Web-Unlocker-Zone einrichten. Der Web-Unlocker-Pfad liest BRIGHTDATA_UNLOCKER_ZONE, und deine Zone hat einen kontospezifischen Namen (web_unlocker, mcp_unlocker, web_unlocker1 usw.). Den genauen Namen im Web-Access-Dashboard finden und in .env.local setzen. Eine Nichtübereinstimmung gibt HTTP 400 mit zone not found zurück. Bei einem brandneuen Konto kann die Tabelle leer sein, bis der MCP-Server beim ersten Aufruf automatisch eine Zone bereitstellt. Wenn 2 Zonen erscheinen, die mit Kostenloser Tarif markierte wählen.
• Polling vom Request-Pfad trennen. In unseren Läufen gab ein einzelner web_data_*-Trigger in etwa 10–90 s zurück und Multi-Record in mehreren Minuten. Die Latenz variiert, und LLM-Antwort-Tools wie Grok können weit über das Poll-Fenster hinauslaufen. Der MCP-Server pollt mehrere Minuten weiter, bevor er ein Timeout hat (die POLLING_TIMEOUT-Umgebungsvariable setzt die Obergrenze). Für die Produktion Trigger aus einem Hintergrundworker ausführen (Vercel Cron, Inngest, Trigger.dev) und in eine Snapshot-Tabelle schreiben. Das Dashboard liest aus der Tabelle, nicht aus dem Live-Scrape. (Die direkte Datasets-API außerhalb von MCP unterstützt Webhook-Lieferung, wenn du Push statt Poll benötigst, gesetzt mit den notify– und endpoint-Parametern. Siehe Bright Data’s Trigger-a-Collection-Docs.)
• Batch + Scope. scrape_batch und search_engine_batch führen mehrere URLs pro Aufruf aus und reduzieren den Token-Overhead pro URL. Das Anhängen von &groups=ecommerce,social,geo,business an die MCP-URL lädt nur die Tool-Gruppen, die dein Anwendungsfall benötigt, und verkleinert den Tool-Listen-Handshake, den der Agent lesen muss. Die 11 Gruppen sind ecommerce, social, finance, business, research, app_stores, travel, geo, code, browser und advanced_scraping.
• Cross-Stack-Templates. Die Power enthält 22 Produktions-Templates: Web-Framework-Routen für TS (Next, Express, Fastify, Hono, Koa) und Python (FastAPI, Flask, Django), Agent-SDK-Tools (Anthropic, OpenAI, LangChain, Vercel AI SDK, Mastra) und generische Module (TS fetch + Cheerio, Python stdlib + BeautifulSoup und ein universelles curl.sh). Kiro erkennt 7 Sprachen per Manifest und wählt die Übereinstimmung, aber erstklassige Codegenerierung ist nur für TS und Python. Go, Rust, Ruby, Java und PHP werden erkannt und zum curl.sh-Fallback geleitet.
• Suchgesteuerte URLs, nicht fest codierte. Fest codierte URLs können bei Listing-ID-Rotation brechen, bei der eine veraltete ID noch aufgelöst wird, aber auf das falsche Produkt zeigt (der PS5-vs-Kopfhörer-Fehler aus Anwendungsfall 1, den die Wiederherstellungsschleife nicht erkennen kann). Die eingebaute Lösung ist, Datensätze im Discovery-Modus statt per URL zu triggern. Den Datensatz-Trigger-Body von [{ url }] auf eine Discovery-Abfrage (discover_by=keyword, category_url oder best_sellers_url) umstellen, damit Bright Data das aktuelle Produkt findet. Siehe Bright Data’s Trigger-a-Collection-Docs für die Discovery-Request-Form.
• Login-Flows + Steuerung. Die Browser-API verarbeitet auth-geschützte Sites mit einer ARIA-Snapshot-Schnittstelle (Playwright-MCP-Stil-Refs), die für die Agent-Nutzung konzipiert ist. .kiro/steering/<deine-domain>.md zum Workspace hinzufügen, um die eingebaute Steuerung der Power zu überschreiben, ohne sie zu forken. Offizielle APIs verwenden, wenn die Quelle sie veröffentlicht.

Mit gesetztem &pro=1 zeigt das erneute Öffnen des MCP-Panels den vollständigen Tool-Katalog:

Nächste Schritte

Eine Power steuert alle 4 Anwendungsfälle von einem einzigen MCP-Endpunkt, sodass du deine Zeit auf Integrations- und Alert-Logik verwendest statt auf Scraper-Infrastruktur.

Den Retail-Tracker selbst bauen. https://github.com/brightdata/kiro-powers/tree/main/brightdata-scrape in Kiros Custom Power hinzufügen → Power von GitHub importieren einfügen, dann den Prompt von Anwendungsfall 1 ausführen. In unserem Lauf dauerte das 20–30 Minuten, verbrauchte null Pro-Ausgaben und bestätigte sowohl die Installation als auch den 4-Phasen-Workflow. In Eile? Stattdessen die fertige App klonen: git clone https://github.com/triposat/retail-price-tracker && cd retail-price-tracker && npm install && cp .env.example .env.local, einen kostenlosen Bright Data Token hinzufügen und npm run dev ausführen.

Dann durch erneutes Auffordern skalieren, nicht durch Neuschreiben. &pro=1 in .kiro/settings/mcp.json hinzufügen und einen der 3 Pro-Tarif-Prompts oben (GEO, LinkedIn oder Crunchbase Intel) zu Bezahlung-pro-Nutzung-Tarifen ausführen. Kein neuer Code, nur ein neuer Prompt gegen dieselbe Power.

Weiterführende Lektüre: die Web-MCP-Seite für die vollständige Tool-Liste und Bright Data’s Kiro-Chat-Workflow-Artikel für dieselben Tools, interaktiv verwendet.

Häufig gestellte Fragen

Was ist kostenlos und was kostenpflichtig?

Kostenlos: Du erhältst 5 Basis-Tools im Web MCP (search_engine, search_engine_batch, scrape_as_markdown, scrape_batch und discover), mit 5.000 Anfragen/Monat ohne Kosten (gemäß Bright Data’s MCP README). Kostenpflichtig: Die Pro web_data*-Tools kosten Geld, ebenso der Datensatz-Trigger-Pfad, den der Retail-Build verwendet, der Bright Data’s Datasets-API direkt aufruft. Dieser Pfad wird separat abgerechnet, mit einer kostenlosen Testphase von ~1.000 Datensätzen zuerst und dann ~$1,50/1.000 Datensätze, sodass das Scrapen einiger Produkte pro Lauf normalerweise einen Bruchteil eines Cents kostet.

Was kosten die Pro-Tools?

Die Pro web_data_*-Tools kosten $1,00–$1,50 pro 1.000 Ergebnisse, abhängig von deinem Plan (Bright Data’s Preisseite):

Für einzelne Pro-Aufrufe – 1 LLM-Antwort-Abruf, 1 LinkedIn-Profil oder 1 Crunchbase-Unternehmen pro Aufruf – gehen die monatlichen Schätzungen von 1 Aufruf = 1 abgerechnetes Ergebnis aus, was Bright Data’s nutzungsbasierter Abrechnung für einzelne web_data_*-Tools entspricht. Für Bulk-Such-Tools wie web_data_amazon_product_search skaliert die Ergebnisanzahl mit den zurückgegebenen Elementen. Den limit-Parameter beim Prototyping verwenden und aktuelle Tarife gegen dein Konto prüfen, bevor du budgetierst.

Die Browser-API wird separat mit $5–8/GB Bandbreite abgerechnet. Wenn du eine KI-Agenten-Schicht hinzufügst, gelten auch Anthropic-, OpenAI- oder Google-Preise, pro LLM-Aufruf.

Funktioniert das mit GPT oder Gemini?

Ja, die brightdata-scrape Power funktioniert mit OpenAI (GPT) und Google (Gemini), nicht nur mit Anthropic. Wenn du Kiro nach einer Agenten-Schicht fragst (“füge eine /api/agent-Route hinzu, die diese Scraper als Tools verwendet”), wählt es das passende Tool-Template (Anthropic SDK, OpenAI SDK, LangChain, Mastra oder Vercel AI SDK) basierend auf den Abhängigkeiten deines Projekts. anthropic(...) durch openai(...) oder google(...) in der generierten Route ersetzen und dann das Client-Setup und die Modell-ID des Anbieters entsprechend anpassen.

Kann es Sites scrapen, die einen Login erfordern?

Die brightdata-scrape Power kann login-geschützte Sites scrapen, aber nicht über den Datensatz-Trigger-Standard. Zur Browser-API für zustandsbehaftete Sessions wechseln und eigene Credential-Speicherung hinzufügen. Die Phase-2-Leiter der Power eskaliert zur Browser-API für Login- und Klick-Flows.

Kann ich alle 4 Anwendungsfälle in einem Projekt ausführen?

Ja. Jeder Anwendungsfall ist ein eigenständiges Modul (seine eigene src/scrapers/-Datei, API-Route und View), das denselben MCP-Server wiederverwendet, sodass alle 4 in einem Next.js-Projekt koexistieren können. Diese Anleitung kombiniert sie nicht in einer App (die 2 Live-Builds, Retail und Crunchbase, sind separate Demo-Repos, und GEO und LinkedIn werden als Prompts gezeigt), aber nichts hindert dich daran.

Kann ich das von Claude Code oder Cursor aus verwenden?

Für Claude Code oder Cursor verwende statt der brightdata-scrape Kiro Power Bright Data’s Claude Skills. Bright Data veröffentlicht Scraping-Skills unter github.com/brightdata/skills (wie scraper-builder und scrape), die in Claude Code, Cursor oder jedem Agenten-Host laufen, der Skills unterstützt. Sie decken weitgehend dieselben Scraping-Aufgaben auf derselben Bright Data-Infrastruktur ab, sind aber als Skills plus die bdata-CLI statt als MCP-und-Next.js-Codegen dieser Power verpackt, sodass die Installation und der generierte Code sich unterscheiden.