# Avvo Scraper — Lawyer & Attorney Leads (`b2b_leads/avvo-real-time-data-scraper`) Actor

Scrape Avvo lawyer leads at scale. Search any practice area and location, then enrich every result with phone numbers, emails, firm websites, ratings, reviews and license details. Clean structured JSON or CSV, streamed live — ready for legal marketing, lead-gen agencies and CRM enrichment.

- **URL**: https://apify.com/b2b\_leads/avvo-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Avvo Real-Time Data

**Collect lawyer directory data from Avvo at scale.** Search multiple practice areas and cities in one run, enrich every lawyer with profile details and firm contacts, and stream clean, structured JSON to your Apify dataset in real time.

> **⚠️ Paid-only note (please read):** Free Apify accounts are limited to a **small sample of results per run (2 by default)**. To get **full, unlimited data**, upgrade to a **paid Apify plan**. This restriction is stated here, in the input form, and in the run output — it is a deliberate policy, not a bug.

Built for legal marketers, lead-gen agencies, law-firm growth teams, recruiters, and data engineers who need **fresh lawyer contact data** without slow, expensive, low-yield tooling.

***

### Why this Actor

| | Avvo Real-Time Data | Typical scraper |
|---|---------------------|-------------------------|
| **Speed** | Fast per-result collection | Often 5–15 s per profile |
| **Memory** | **512 MB** default | 2–4 GB+ |
| **Setup** | Organized input UI, run immediately | Fragile & high-maintenance |
| **Output** | Structured JSON, LLM-ready | Often messy HTML |
| **Predictability** | Every lawyer is exported — output is never filtered by lead completeness | Filtering makes run cost unpredictable |
| **Multi-market** | Many practice-area + location pairs per run | Usually one query at a time |

***

### What it does

- **Search** Avvo's public lawyer directory by **practice area + location** (city, state). Run many pairs in a single run.
- **Lead details (enabled, not filtered):** for each lawyer, pull the public profile details — phone, firm name, practice areas, bar-admission year when listed — and, when the lawyer's firm site is published, scan that site for **emails and social profiles**.
- **Profile URLs:** paste profile links you already have and enrich them directly.
- **Streaming output:** every record is pushed to the dataset the moment it is final, so long runs stay memory-light and results arrive in real time.
- **Webhooks:** push each record to your CRM, Slack, Zapier, Make, or custom URL as it is collected.

Every lawyer found goes to the dataset — even if no lead details were published for them. Each row carries a `leadDetails` status object (`complete` / `partial` / `none`) so you can segment downstream without the run silently dropping rows. Enrichment adds a little extra time per lawyer; output volume stays fully predictable, which keeps per-run pricing predictable too.

***

### Who it is for

- **Legal marketing agencies** — build and refresh lawyer prospect lists across states and practice areas.
- **Lead-generation teams** — SDR teams prospecting attorneys with phone numbers and firm sites.
- **Law-firm growth / BD** — map competitors by city and practice area; monitor who is listing where.
- **Legal recruiters & staffing** — candidate discovery by practice area and market.
- **Legal-tech & SaaS** — feed CRM and product data with structured lawyer profiles.
- **Consultants & analysts** — market mapping: how many injury lawyers operate in Austin vs Dallas.
- **AI / LLM builders** — clean JSON records for enrichment agents, scoring, and RAG pipelines.

***

### Use cases

- **Attorney lead lists** — export lawyers by practice area + city with phone and firm details for outreach.
- **Email discovery for B2B outreach** — with lead details enabled, emails are added when a firm publishes them on its own website.
- **Multi-market prospecting** — one run across dozens of practice-area + location pairs.
- **Competitive mapping** — who practices personal injury in Phoenix? Family law in Chicago?
- **Bar-admission intelligence** — `licensedSince` and `yearsExperience` when the directory lists them.
- **CRM enrichment** — start from profile URLs you already have and backfill structured fields.
- **Reputation snapshots** — rating and review counts per lawyer for market research.
- **Territory planning** — density analysis by practice area across states.
- **CRM & warehouse feeds** — dataset via Apify API, optional real-time webhook, or scheduled runs.
- **AI pipelines** — JSON Lines-friendly output for LLM workflows.

***

### Features

#### 🔎 Search (on by default)

Pair one or more **practice areas** with **locations**. The directory organizes listings by state and city; your location is parsed into state + city automatically (e.g. `Austin, TX`). Each task collects until it reaches its `lawyersPerTask` cap, walking up to `maxDepthPerTask` for very large markets.

Every result includes name, profile link, and the data published on the listing (rating, review count, firm name when shown).

#### 🎯 Lead details (enabled by default)

Enriches **every** lawyer with whatever the public profile publishes:

- **Phone** (when listed)
- **Firm name, practice areas, specialties**
- **Years of experience / licensed since** (when listed)
- **Firm website** (when published)
- **Emails + social profiles** — when the firm's own website is published, that site is scanned for contact emails and social accounts
- A `leadDetails` status object: `complete`, `partial` (with a short reason), or `none`

**Nothing is filtered out.** If a lawyer publishes no contact details, their row still lands in the dataset with `leadDetails.status: "none"` — so 1,000 lawyers in ≈ 1,000 rows out, always.

Set `crawlFirmSites: false` to skip the firm-website email scan and finish runs faster.

#### 🔗 Lawyer Profiles by URL

Paste Avvo profile URLs (one per line) to enrich specific lawyers — same rich output as search enrichment.

#### 🌐 Connection

A residential US proxy connection is enabled by default for reliability. Change it in the input only if you need a different setup.

***

### Input reference

Full schema: see `.actor/input_schema.json` or the **Input** tab on Apify Console.

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| **Search terms & locations** | | | |
| `enableSearch` | boolean | `true` | Practice-area + location search |
| `searchTasks` | object\[] | 2 example tasks | `{ practiceArea, location, lawyersPerTask? }` per row |
| `lawyersPerTask` | integer | `10` | Default max lawyers per search task |
| `maxDepthPerTask` | integer | `20` | Collection depth cap per task (1–100) |
| `minRating` | number | — | Only keep lawyers rated at least this high (0–5). Leave empty for no filter |
| **Lead details** | | | |
| `enableLeadDetails` | boolean | `true` | Enrich every lawyer with profile details + firm contacts. Adds a little extra time per lawyer. Results are never filtered by lead completeness |
| `crawlFirmSites` | boolean | `true` | Scan a lawyer's published firm website for emails and social profiles |
| **Lawyer Profiles by URL** | | | |
| `enableProfileUrls` | boolean | `false` | Enrich specific profile URLs |
| `profileUrls` | string\[] | — | Avvo profile URLs, one per line |
| **Output & limits** | | | |
| `maxItems` | integer | `10000` | Global cap on total dataset rows. Free accounts are additionally capped to a small sample (see the paid-only note) |
| `webhookUrl` | string | — | Optional real-time POST URL — dataset is always written; webhook is additional |
| `webhookFormat` | enum | `json` | `json` (full record) or `slack` (Slack message) |
| **Connection** | | | |
| `proxyConfiguration` | object | residential US | Apify proxy settings |

**Notes**

- Practice areas use directory slugs: `personal-injury`, `family-law`, `divorce`, `criminal-defense`, `dui`, `bankruptcy`, `immigration`, `real-estate`, `business`, `employment`, `estate-planning`, `intellectual-property`, `medical-malpractice`, `workers-compensation`, `social-security-disability`, and more.
- Locations are `City, ST` pairs (e.g. `Chicago, IL`). State-only searches also work (`TX`).

***

### Output reference

Each dataset row is one lawyer. Fields present when the data is published for that lawyer:

| Field | Type | Description |
|-------|------|-------------|
| `featureType` | string | `search` (from a search task) or `scrape_by_url` (from profile URLs) |
| `type` | string | Listing kind (`attorney`) |
| `name` | string | Lawyer's name |
| `profileUrl` | string | Link to the lawyer's public profile |
| `avvoId` | string | The lawyer's identifier on Avvo |
| `phone` | string | Phone number when published |
| `email` | string | Email when published (typically found via the firm's own website scan) |
| `website` | string | Firm website when published |
| `socials` | string\[] | Social profile URLs found on the firm's site |
| `firmName` | string | Firm / office name |
| `practiceAreas` | string\[] | Listed practice areas |
| `specialties` | string\[] | Listed specialties |
| `city` / `state` | string | Location from the profile or the search |
| `location` | string | Free-form location when published |
| `rating` | number | Star rating (0–5) |
| `reviewCount` | integer | Number of client reviews |
| `avvoRating` | number | Directory rating when displayed |
| `yearsExperience` | integer | Years in practice when listed |
| `licensedSince` | integer | Bar-admission year when listed |
| `imageUrl` | string | Profile photo URL |
| `firmName` / `firmUrl` | string | Firm identity fields |
| `searchPracticeArea` | string | The practice area that produced this row |
| `searchLocation` | string | The location that produced this row |
| `leadDetails` | object | `{ status: "complete" \| "partial" \| "none", reason?: string }` — outcome indicator; rows are never filtered by it |
| `enriched` | boolean | Whether profile details were merged into this row |
| `scrapedAt` | string | ISO timestamp |

Export formats: **JSON**, **CSV**, **Excel**, **RSS**, or via the **Apify API**.

The run also writes a **summary record** (`OUTPUT`) to the run's key-value storage with counts and a `paywall` object (`detected`, `isPaying`, `pricingTier`, `limited`, `blocked`) for transparency.

***

### Webhook delivery (optional)

Every record is **always saved to the Apify dataset** first. If you set `webhookUrl`, each new record is **also POSTed in real time** to your service — CRMs, Slack, Zapier, Make, Google Sheets, or your own API.

| Setting | Description |
|---------|-------------|
| `webhookUrl` | Your service URL (http/https). Leave empty for dataset only. |
| `webhookFormat` | `json` — the full record object. `slack` — compact Slack incoming-webhook message. |

- Delivery is **best-effort**: a failed webhook never stops the run or blocks dataset writes.
- Webhook payloads contain **only the documented output fields** — the same JSON you see in the dataset, nothing more.

**Example — search with Slack alerts**

```json
{
  "enableSearch": true,
  "searchTasks": [{ "practiceArea": "family-law", "location": "Chicago, IL", "lawyersPerTask": 25 }],
  "webhookUrl": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
  "webhookFormat": "slack"
}
```

**Example — JSON webhook to a CRM**

```json
{
  "enableSearch": true,
  "searchTasks": [{ "practiceArea": "criminal-defense", "location": "Phoenix, AZ", "lawyersPerTask": 100 }],
  "enableLeadDetails": true,
  "webhookUrl": "https://your-crm.example.com/api/leads",
  "webhookFormat": "json"
}
```

***

### Paid-only / free tier

- **Paying Apify plans:** full, uncapped output.
- **Free accounts:** capped to a **small sample per run — 2 results by default** — then the run stops gracefully with a clear message to upgrade.
- The cap is a deliberate monetization policy (also shown in the input form and the run output), configurable by the actor owner via environment variables.
- Upgrading to **any paid Apify plan** removes the cap — no other change needed.

***

### FAQ

**Is this Actor available for free Apify accounts?**
Free accounts can run it, but output is limited to a small sample (2 results by default). Upgrade to a paid Apify plan for full, unlimited data.

**Why don't you filter out lawyers without contact info?**
Filtering would make runtime — and therefore cost — unpredictable per 1,000 lawyers. Instead every lawyer is exported with a `leadDetails` status, and you filter downstream if you want.

**Why is there no `email` on every row?**
Emails are only exported when a lawyer's firm actually publishes them on its own website. Phone numbers are far more commonly published in this directory. The `leadDetails` object tells you what was found and what wasn't.

**How current is the data?**
Each run queries the directory live and stamps rows with `scrapedAt`.

**Can I run multiple practice areas and cities in one run?**
Yes — add as many rows to `searchTasks` as you need. Each row runs with its own cap.

**Do you support state-only searches?**
Yes. Use just the state (`TX`) in the location field, or a `City, ST` pair.

**How do I get the results?**
From the run's **Storage** tab (JSON/CSV/Excel export), the Apify API, a webhook, or the Apify MCP server.

**What do the `Busy — retrying shortly…` log lines mean?**
The directory intermittently slows a visitor down. The Actor refreshes its connection automatically and carries on — most runs finish with a few of those lines and no missing data. If a run logs `Connection preflight: challenged`, the connection had to be refreshed repeatedly at startup: re-check the **Proxy configuration** on that run (and, if you manage your own connection, the proxy environment variables on the Actor).

**What does `Connection credentials were rejected` mean?**
The connection itself was refused before any collection happened — this is a proxy credential/entitlement problem on that run, not a data problem. Fix the proxy configuration and run again.

**A task reported "No results" — is that a bug?**
No. It means the combination of practice area and location returned no lawyers (usually a spelling or slug mismatch). If everything looked correct and every task reports it, the connection was challenged at startup — see the preflight line above and re-run.

**Is this affiliated with Avvo?**
No. This Actor collects publicly available directory data. Use it responsibly and in compliance with applicable laws and the directory's terms.

**What does `leadDetails.status` mean?**
`complete` — contact details and a firm site were found. `partial` — some details were found; `reason` explains what was missing (e.g. extra details were unavailable at collection time). `none` — no lead details were published for this lawyer.

***

### LLM & MCP integration

Output is **JSON Lines–friendly structured data** — ideal for ChatGPT, Claude, Gemini, LangChain, LlamaIndex, and custom agents.

#### Apify MCP (Model Context Protocol)

Use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so AI assistants can:

- **Run** this Actor with natural-language instructions
- **Read** dataset results directly in the chat
- **Chain** with other Actors (e.g. enrich → score → outreach)

Typical MCP tool flow:

```
User: "Find 30 personal injury lawyers in Texas with phone numbers and summarize each for outreach"
→ MCP runs the Actor with searchTasks=[{ practiceArea: "personal-injury", location: "Austin, TX" }]
→ MCP reads dataset items
→ LLM summarizes and drafts emails
```

#### Example record for an LLM prompt

```json
{
  "featureType": "search",
  "name": "Jane Smith",
  "phone": "(512) 555-0142",
  "firmName": "Smith Law Group",
  "practiceAreas": ["Personal Injury", "Car Accidents"],
  "city": "Austin",
  "state": "TX",
  "rating": 4.9,
  "reviewCount": 87,
  "leadDetails": { "status": "complete" },
  "profileUrl": "https://www.avvo.com/attorneys/..."
}
```

#### API quick start

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "enableSearch": true,
    "searchTasks": [
      { "practiceArea": "personal-injury", "location": "Austin, TX", "lawyersPerTask": 50 },
      { "practiceArea": "divorce", "location": "Dallas, TX", "lawyersPerTask": 50 }
    ],
    "enableLeadDetails": true
  }'
```

Dataset items: `GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json`

***

### Quick start examples

**Multi-city lead gen (default pattern)**

```json
{
  "enableSearch": true,
  "searchTasks": [
    { "practiceArea": "personal-injury", "location": "Austin, TX", "lawyersPerTask": 100 },
    { "practiceArea": "personal-injury", "location": "Houston, TX", "lawyersPerTask": 100 }
  ],
  "enableLeadDetails": true,
  "crawlFirmSites": true
}
```

**Fast listing-only scan (no enrichment)**

```json
{
  "enableSearch": true,
  "searchTasks": [{ "practiceArea": "immigration", "location": "Miami, FL", "lawyersPerTask": 200 }],
  "enableLeadDetails": false,
  "maxItems": 5000
}
```

**Enrich profile URLs you already have**

```json
{
  "enableSearch": false,
  "enableProfileUrls": true,
  "profileUrls": [
    "https://www.avvo.com/attorneys/78701-tx-jane-smith-1234567.html",
    "https://www.avvo.com/attorneys/75201-tx-john-doe-2345678.html"
  ],
  "enableLeadDetails": true
}
```

**High-rated lawyers only**

```json
{
  "enableSearch": true,
  "searchTasks": [{ "practiceArea": "estate-planning", "location": "Denver, CO" }],
  "minRating": 4.5,
  "enableLeadDetails": true
}
```

***

### Proxy & performance

- **Residential US proxy** is enabled by default — no extra setup on Apify.
- Default memory: **512 MB** — enough headroom for most runs.
- Results are **streamed to the dataset** as they are collected; long runs do not pile up data in memory.
- Run timeout: **10,000 seconds** — sized for very large runs.
- Free-tier runs stop early by design (see the paid-only note).

### Reliability

- Transient busy spells are retried automatically, with a fresh connection taken before each retry.
- A challenged connection is **refreshed, never abandoned** — one bad spell can't strand the rest of the run.
- **Connection preflight** runs once at the start and reports a single outcome-only line (`ready`, `ready after refreshing`, or `challenged`) so a slow run is easy to diagnose.
- Failures are reported as plain sentences — `Busy`, `Connection trouble`, `Connection credentials were rejected` — never as technical error dumps or stack traces.
- A lawyer whose profile cannot be enriched still appears in the dataset with a `leadDetails` reason — no silent drops.
- Webhook failures never stop the run.

### Limitations & compliance

- Fields are present only when the lawyer or their firm has published them.
- Not affiliated with Avvo. Use responsibly and comply with applicable laws and the directory's Terms of Service.
- Respect rate limits and local regulations when collecting professional data.

***

### Contact & custom work

Need something beyond this Actor? I build **custom scrapers**, **data pipelines**, and **full-stack web applications** for startups and enterprises.

- **Email:** <dubem115@gmail.com>
- **GitHub:** [github.com/DrunkCodes](https://github.com/DrunkCodes)

Reach out for:

- Custom Apify Actors (any website or data source)
- Legal-directory and lead-gen data projects at scale
- LLM & MCP integrations with your data stack
- Web apps, dashboards, and automation tools

***

*Avvo Real-Time Data · by [DrunkCodes](https://github.com/DrunkCodes)*

# Actor input Schema

## `enableSearch` (type: `boolean`):

Find lawyers by practice area and location. Enabled by default.

## `searchTasks` (type: `array`):

Add one row per search. Pair a practice area with a city and state.

## `lawyersPerTask` (type: `integer`):

Default maximum lawyers per search task. Override per task in the list above.

## `maxDepthPerTask` (type: `integer`):

Maximum depth to collect for each search task (safety cap for very large runs).

## `minRating` (type: `number`):

Only keep lawyers rated at least this high (0–5). Leave empty for no filter.

## `enableLeadDetails` (type: `boolean`):

Visit each lawyer's profile to add phone, firm name, practice areas, years licensed, and — when listed — the firm website, then scan the firm's own site for emails and social profiles. Adds a little extra time per lawyer. Recommended for outreach and CRM enrichment.

## `crawlFirmSites` (type: `boolean`):

When a profile lists the firm's website, scan that site for contact emails and social profiles. Requires lead details. Adds a little extra time per lawyer with a website.

## `enableProfileUrls` (type: `boolean`):

Enrich specific Avvo profile URLs you already have.

## `profileUrls` (type: `array`):

Avvo lawyer profile URLs (one per line).

## `maxItems` (type: `integer`):

Global cap on total dataset rows across all features. Set high for large runs (e.g. 10000+).

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run's dataset — this webhook is an ADDITIONAL real-time push. When set, each new record is also POSTed to this URL (CRM, Slack incoming webhook, Zapier, Make, Google Sheets).

## `webhookFormat` (type: `string`):

json = full record object; slack = Slack-friendly message payload.

## `proxyConfiguration` (type: `object`):

A residential US proxy connection is enabled by default for reliable collection.

## Actor input object example

```json
{
  "enableSearch": true,
  "searchTasks": [
    {
      "practiceArea": "personal-injury",
      "location": "Austin, TX",
      "lawyersPerTask": 10
    },
    {
      "practiceArea": "family-law",
      "location": "Dallas, TX",
      "lawyersPerTask": 10
    }
  ],
  "lawyersPerTask": 10,
  "maxDepthPerTask": 20,
  "enableLeadDetails": true,
  "crawlFirmSites": true,
  "enableProfileUrls": false,
  "profileUrls": [],
  "maxItems": 10000,
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every lawyer row from all enabled features in this run.

## `search` (type: `string`):

Lawyers from practice-area + location search.

## `runSummary` (type: `string`):

KEY\_VALUE\_STORE record named OUTPUT with counts, paywall status, and feature breakdown.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "enableSearch": true,
    "searchTasks": [
        {
            "practiceArea": "personal-injury",
            "location": "Austin, TX",
            "lawyersPerTask": 10
        },
        {
            "practiceArea": "family-law",
            "location": "Dallas, TX",
            "lawyersPerTask": 10
        }
    ],
    "lawyersPerTask": 10,
    "enableLeadDetails": true,
    "crawlFirmSites": true,
    "maxItems": 10000,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/avvo-real-time-data-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "enableSearch": True,
    "searchTasks": [
        {
            "practiceArea": "personal-injury",
            "location": "Austin, TX",
            "lawyersPerTask": 10,
        },
        {
            "practiceArea": "family-law",
            "location": "Dallas, TX",
            "lawyersPerTask": 10,
        },
    ],
    "lawyersPerTask": 10,
    "enableLeadDetails": True,
    "crawlFirmSites": True,
    "maxItems": 10000,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/avvo-real-time-data-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "enableSearch": true,
  "searchTasks": [
    {
      "practiceArea": "personal-injury",
      "location": "Austin, TX",
      "lawyersPerTask": 10
    },
    {
      "practiceArea": "family-law",
      "location": "Dallas, TX",
      "lawyersPerTask": 10
    }
  ],
  "lawyersPerTask": 10,
  "enableLeadDetails": true,
  "crawlFirmSites": true,
  "maxItems": 10000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/avvo-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/avvo-real-time-data-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dGcRtcg7G7v32RRxb/builds/mo502fenG3vjmxg5i/openapi.json