Skip to main content

How to enrich Browse AI data with Claude

M
Written by Melissa Shires

Claude is Anthropic's AI assistant, known for strong reasoning, long context windows, and structured output. When paired with Browse AI, you can enrich your scraped data with AI-generated fields like summaries, sentiment scores, categories, and extracted entities, turning raw web data into analysis-ready datasets.

πŸ“– Browse AI includes a built-in Formula AI feature for quick data transformations like cleaning, formatting, and conditional logic, all without leaving your table. This guide covers when you need to go further: using Claude's full reasoning capabilities for tasks like generating multi-sentence summaries, classifying data with external context, extracting structured entities, or producing free-form content from your scraped data.

This guide covers three ways to connect Browse AI to Claude for data enrichment:

Method

Best for

Difficulty

Zapier / Make

No-code enrichment pipelines

Easy

Webhooks + Claude API

Real-time enrichment as data arrives

Intermediate

API polling

Batch enrichment of large datasets

Intermediate

What you can do

Here are some common enrichment use cases:

Use case

Example

Summarization

Scrape product pages, generate one-paragraph summaries for each

Sentiment analysis

Scrape reviews, classify each as positive, neutral, or negative with a confidence score

Categorization

Scrape job listings, tag each with industry, seniority level, and remote status

Entity extraction

Scrape news articles, extract company names, people, locations, and dates

Content generation

Scrape competitor products, generate comparison blurbs for your sales team

Data standardization

Scrape listings with inconsistent formats, normalize to a clean schema

Method 1: Zapier / Make (no-code)

The fastest way to enrich Browse AI data with Claude. No coding required.

Zapier setup

  1. Create a new Zap with Browse AI as the trigger. Select the New Successful Task Run event and connect your Browse AI account.

  2. Choose the robot you want to enrich data from.

  3. Add a Claude (Anthropic) action step. Select the Send Message event.

  4. Connect your Anthropic API key (get one from console.anthropic.com).

  5. Configure the message:

    1. Model: Choose claude-sonnet-4-6 for a good balance of speed and quality, or claude-opus-4-6 for the most capable model.

    2. User Message: Write your enrichment prompt and map in the Browse AI data fields. For example:

Analyze the following product listing and return a JSON object with these fields:- "category": the product category (e.g., Electronics, Clothing, Home & Garden)- "sentiment": overall sentiment of the description (positive, neutral, negative)- "summary": a one-sentence summary of the product- "key_features": an array of up to 5 key featuresProduct Name: {{product_name}}Price: {{price}}Description: {{description}}

6. Add a downstream action to store the enriched data. For example, add a Google Sheets step to write both the original Browse AI data and Claude's enrichment to a spreadsheet row.

Make (Integromat) setup

  1. Create a new scenario with the Browse AI module. Use the Watch Successful Task Runs trigger.

  2. Add an Anthropic (Claude) module and select Create a Message.

  3. Connect your Anthropic API key and configure the prompt with mapped Browse AI fields.

  4. Add a downstream module (Google Sheets, Airtable, or your preferred storage) to capture the enriched output.

βœ… Tip: Ask Claude to respond in JSON format for structured enrichments. This makes it easy to parse specific fields downstream in your Zapier or Make workflow. Include "Respond with valid JSON only, no other text" at the end of your prompt.

Method 2: Webhooks + Claude API (real-time)

For real-time enrichment with full control over the pipeline. Browse AI sends data to your server via webhook, your server calls Claude's API, and the enriched result is stored wherever you need it.

Prerequisites

  • An Anthropic API key from console.anthropic.com

  • A server or cloud function to receive webhooks (Python example below)

  • The anthropic Python package: pip install anthropic flask

Step 1: Set up the webhook endpoint

Create a Flask server that receives Browse AI webhook events and enriches each record with Claude:

import jsonfrom flask import Flask, request, jsonifyfrom anthropic import Anthropicapp = Flask(__name__)client = Anthropic(api_key="your-anthropic-api-key")ENRICHMENT_PROMPT = """Analyze the following scraped data and return a JSON object with:- "summary": a one-sentence summary- "category": the most appropriate category- "sentiment": positive, neutral, or negative- "tags": an array of up to 5 relevant tags- "quality_score": a score from 1-10 rating the data quality/completenessRespond with valid JSON only, no other text.Data:{data}"""@app.route("/webhook/browse-ai", methods=["POST"])def handle_webhook():    event = request.json    event_type = event.get("event")    # Only process successful task completions    if event_type != "taskFinishedSuccessfully":        return jsonify({"status": "ignored"}), 200    task = event.get("task", {})    captured_data = task.get("capturedTexts", {})    # Enrich each record with Claude    enriched = enrich_with_claude(captured_data)    # Store enriched data (replace with your storage logic)    save_enriched_data(task.get("id"), captured_data, enriched)    return jsonify({"status": "enriched"}), 200def enrich_with_claude(data):    message = client.messages.create(        model="claude-sonnet-4-6",        max_tokens=1024,        messages=[{            "role": "user",            "content": ENRICHMENT_PROMPT.format(data=json.dumps(data, indent=2))        }]    )    return json.loads(message.content[0].text)def save_enriched_data(task_id, original, enriched):    # Replace this with your preferred storage    # Examples: database insert, Google Sheets append, S3 upload    print(f"Task {task_id}: {json.dumps(enriched, indent=2)}")if __name__ == "__main__":    app.run(port=5000)

Step 2: Handle list data (tables)

If your robot captures tabular data (like product listings or search results), the data arrives in the capturedLists field. Here's how to enrich each row:

@app.route("/webhook/browse-ai/list", methods=["POST"])def handle_list_webhook():    event = request.json    if event.get("event") != "taskFinishedSuccessfully":        return jsonify({"status": "ignored"}), 200    task = event.get("task", {})    rows = task.get("capturedLists", {}).get("items", [])    enriched_rows = []    for row in rows:        enriched = enrich_with_claude(row)        enriched_rows.append({**row, **enriched})    save_enriched_data(task.get("id"), enriched_rows)    return jsonify({"status": "enriched", "rows": len(enriched_rows)}), 200

Step 3: Configure the webhook in Browse AI

  1. Open your robot in Browse AI and go to the Integrations tab.

  2. Click Add Webhook.

  3. Enter your endpoint URL (e.g., https://your-server.com/webhook/browse-ai).

  4. Select the events to listen for. For enrichment, Task finished successfully is usually all you need.

  5. Save the webhook.

⚠️ Browse AI does not support webhook signature verification. To verify that webhook requests are coming from Browse AI, allowlist the IP address 3.228.254.190 on your server. See our webhook IP allowlisting guide for details.

Using structured output for reliable parsing

For production enrichment pipelines, you want Claude to return data in a consistent, parseable format every time. Here's a pattern using a detailed system prompt:

def enrich_with_structured_output(data):    message = client.messages.create(        model="claude-sonnet-4-6",        max_tokens=1024,        system="""You are a data enrichment engine. You ONLY respond with valid JSON.Never include explanations, markdown, or text outside the JSON object.If a field cannot be determined, use null.""",        messages=[{            "role": "user",            "content": f"""Enrich this scraped data. Return a JSON object with exactly these fields:{{  "summary": "one sentence summary",  "category": "primary category",  "subcategory": "more specific category",  "sentiment": "positive|neutral|negative",  "confidence": 0.0 to 1.0,  "tags": ["tag1", "tag2"],  "language": "detected language code"}}Data: {json.dumps(data)}"""        }]    )    return json.loads(message.content[0].text)

Method 3: API polling (batch enrichment)

Best for enriching large datasets on a schedule rather than in real time. Poll Browse AI for completed tasks, then batch-process them through Claude.

Step 1: Fetch tasks from Browse AI

import requestsfrom anthropic import AnthropicBROWSE_AI_API_KEY = "your-browse-ai-api-key"ANTHROPIC_API_KEY = "your-anthropic-api-key"ROBOT_ID = "your-robot-id"client = Anthropic(api_key=ANTHROPIC_API_KEY)def get_recent_tasks(robot_id, page=1):    """Fetch recent successful tasks from Browse AI."""    response = requests.get(        f"https://api.browse.ai/v2/robots/{robot_id}/tasks",        headers={"Authorization": f"Bearer {BROWSE_AI_API_KEY}"},        params={"page": page}    )    return response.json().get("result", {}).get("robotTasks", {}).get("items", [])

Step 2: Batch-enrich with Claude

def batch_enrich(tasks):    """Enrich a batch of Browse AI tasks with Claude."""    enriched_results = []    for task in tasks:        if task.get("status") != "successful":            continue        captured = task.get("capturedTexts", {})        if not captured:            continue        message = client.messages.create(            model="claude-sonnet-4-6",            max_tokens=1024,            messages=[{                "role": "user",                "content": f"""Analyze this scraped data and return a JSON object with:- "summary": one-sentence summary- "category": primary category- "sentiment": positive, neutral, or negative- "tags": up to 5 relevant tagsRespond with valid JSON only.Data: {json.dumps(captured)}"""            }]        )        enrichment = json.loads(message.content[0].text)        enriched_results.append({            "task_id": task["id"],            "original": captured,            "enrichment": enrichment        })    return enriched_results# Run the enrichmenttasks = get_recent_tasks(ROBOT_ID)results = batch_enrich(tasks)# Save resultsfor r in results:    print(f"Task {r['task_id']}: {r['enrichment']}")

Step 3: Schedule with cron

Set up a cron job or cloud scheduler to run your enrichment script on a regular interval. For example, to run every hour:

0 * * * * cd /path/to/project && python3 enrich.py >> enrich.log 2>&1

πŸ“– Rate limits: The Anthropic API has rate limits based on your plan tier. For large batch jobs, add a short delay between requests (e.g., time.sleep(1)) to stay within limits. See Anthropic's documentation for current rate limits.

Choosing the right model

Anthropic offers several Claude models. Here's how to choose for enrichment tasks:

Model

Best for

Speed

Cost

claude-haiku-4-5-20251001

Simple classification, tagging, short summaries

Fastest

Lowest

claude-sonnet-4-6

Most enrichment tasks (recommended default)

Fast

Medium

claude-opus-4-6

Complex analysis, nuanced categorization

Slower

Highest

βœ… Tip: Start with claude-haiku-4-5-20251001 for high-volume enrichment jobs where speed and cost matter most. Upgrade to Sonnet or Opus if you need higher accuracy or more nuanced reasoning.

Next steps

  • Analyze your enriched data: Learn how to use Claude to find patterns, generate reports, and build knowledge bases from your scraped data in our analysis guide.

  • Automate your workflows: Set up monitor-triggered pipelines that enrich and act on data automatically in our automation guide.

  • Browse AI API reference: See the full Browse AI API documentation for all available endpoints and parameters.

Did this answer your question?