# Avvo Scraper \[$1💰] | US Lawyers | Contact Data | Lead Gen (`ahmed_jasarevic/avvo-scraper`) Actor

Build attorney lead lists from the Avvo US lawyer directory: lawyer data with names, firms, phone numbers, addresses, practice areas, Avvo ratings and reviews — by state and practice area. No API key, $0.001 per result, free preview capped at 10 attorneys.

- **URL**: https://apify.com/ahmed\_jasarevic/avvo-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.89 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper — US Attorney Leads & Lawyer Contact Data

Extract attorney lead lists and lawyer contact data from the Avvo lawyer directory — the largest US legal marketplace, with 17+ million annual visitors — filtered by practice area and state. One structured JSON row per attorney: name, firm, phone, full address, practice areas, Avvo ratings (1–10), review counts, education, awards, bio and price range — for **$0.001 per result**, no browser and no API key.

### Build Attorney Lead Lists by Practice Area and State

- **Legal-tech and legal services lead generation** — prospect lists of attorneys by practice area and US state, with firm name, phone and address in one row, ready for CRM import.
- **Attorney prospect lists for outreach** — target personal injury, divorce, criminal defense, real estate, medical malpractice and 120+ more practice areas in any state.
- **Legal market research** — analyze Avvo ratings, review counts and practice-area mixes across regions to size a market or benchmark competitors.
- **Legal recruiting by specialty** — find attorneys by practice area, education and awards (e.g. prospective partners or counsel with specific credentials).
- **Competitive intelligence on lawyer density** — count how many attorneys practice a given area in a state or metro market and track firm movement.
- **Legal marketing campaigns** — build segmented mailing or call lists owned by no one but you, refreshed on a schedule.

### How It Works: Plain HTTP + JSON-LD, No Browser or API Key

The actor reads Avvo's public search pages exactly as a browser would (20 attorneys per request) and parses the **JSON-LD structured data embedded in each server-rendered page** — the same data that powers Avvo's own search results. No headless browser, no login, no CAPTCHA solving, no OAuth. Each request returns a clean flat record:

- plain HTTP with browser-like headers and a shared cookie jar
- automatic pagination (walking the `rel=next` chain) until `maxResults` is reached
- polite throttling (120–300 ms between requests) and a worker pool tuned for Avvo
- Cloudflare challenge detection with automatic sticky-proxy session rotation and exponential backoff retries

The result: fast, cheap, dependable attorney data extraction — at a small fraction of the cost of browser-based scrapers.

### Get Lawyer Contact Data Without the Official Avvo API

Avvo has **no public JSON API**. The official `api.avvo.com` endpoint requires partner credentials, and Avvo's consumer-facing site exposes no developer API either. The leanest available surface is the internal JSON-LD that powers the public search pages — and that is exactly what this actor reads.

That means you get lawyer contact information — phone, full street address, firm, practice areas, Avvo rating, reviews, education, awards, bio and price range — without paying for an API subscription, without partner approval, and without maintaining your own scraper. Every field comes back in a single consistent JSON row per attorney, de-duplicated by Avvo profile ID.

### Choose Your Input: Practice Area, State, Start URLs or Result Cap

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `practiceArea` | string | No\* | `personal-injury` | Practice-area slug, e.g. `personal-injury`, `divorce`, `criminal-defense`, `real-estate`, `estate-planning`, `medical-malpractice`, `employment-labor`, `business`. Combined with `location` to build the Avvo search URL (`https://www.avvo.com/{practiceArea}-lawyer/{location}.html`). Comma-separated values are supported. |
| `location` | string | No\* | `ny` | Two-letter US state code, e.g. `ny`, `ca`, `tx`, `fl`, `il`. Comma-separated values are supported. |
| `startUrls` | array | No | — | Custom Avvo search URLs to start from, e.g. `https://www.avvo.com/all-lawyers/il/chicago.html`. **When provided, `practiceArea` and `location` are ignored.** |
| `maxResults` | integer | No | `100` | Maximum number of attorneys to scrape (1–100,000). Free accounts are hard-capped at 10 attorneys per run. |
| `proxy` | object | No | disabled | Apify Proxy configuration. **Recommended: US residential group** — Avvo is Cloudflare-protected and datacenter IPs are frequently challenged. |

\* No field is individually required by the schema, but the actor needs either `startUrls` or both `practiceArea` and `location` to build search URLs.

### What Data You Get: One Structured Row per US Attorney

| Field | Type | Description |
|---|---|---|
| `attorneyName` | string | Attorney full name |
| `profileUrl` | string | Avvo profile URL — stable identifier for de-duplication across runs |
| `avvoId` | string | Numeric Avvo profile ID (digits at the end of `profileUrl`) |
| `firmName` | string | Law firm or organization name |
| `phone` | string | The phone number published on the attorney's listing |
| `streetAddress` | string | Office street address |
| `city` | string | Office city |
| `state` | string | Two-letter US state |
| `postalCode` | string | ZIP code |
| `country` | string | Country (US for domestic listings) |
| `practiceAreas` | array | Practice areas as `{ "name": "..." }` entries |
| `avvoRating` | number | Avvo Rating on the 1–10 scale |
| `reviewCount` | number | Number of client reviews |
| `education` | array | Law schools / universities (from the JSON-LD `alumniOf` data) |
| `awards` | array | Awards and recognitions (e.g. Clients' Choice, Super Lawyers) |
| `bio` | string | Attorney bio or tagline |
| `priceRange` | string | Hourly or flat-fee range when the attorney publishes one |

**Note on emails:** Avvo's directory listings do not publish attorney email addresses, so this actor does not extract emails. Phone numbers come from each firm's published listing — use them (or the firm website) as the contact channel, or pair this dataset with an email-finder.

### Example Input

```json
{
  "practiceArea": "personal-injury",
  "location": "ny",
  "maxResults": 100
}
```

### Example Output

```json
{
  "attorneyName": "Jane A. Attorney",
  "profileUrl": "https://www.avvo.com/attorneys/10001-ny-jane-attorney-1234567.html",
  "avvoId": "1234567",
  "firmName": "Attorney & Partners LLP",
  "phone": "(212) 555-0123",
  "streetAddress": "123 Main St, Suite 400",
  "city": "New York",
  "state": "NY",
  "postalCode": "10001",
  "country": "US",
  "practiceAreas": [{ "name": "Personal Injury" }, { "name": "Car Accidents" }],
  "avvoRating": 9.5,
  "reviewCount": 42,
  "education": ["Columbia Law School"],
  "awards": ["Clients' Choice"],
  "bio": "Jane represents injured clients across New York State, handling car accident and premises liability cases from intake through trial.",
  "priceRange": "$300 - $500/hour"
}
```

### Integrate with Your CRM and Track Avvo Ratings Over Time

- **Apify API** — run the actor from your own stack via `POST /v2/acts/{actorId}/runs` and pull results from the dataset endpoint (`&format=json`, `csv`, `xlsx` and more).
- **Schedules** — recurring runs turn a one-off lead list into a living dataset. Quarterly or monthly schedules are ideal for tracking Avvo ratings and review counts over time (e.g. monitoring a market's top-rated attorneys), and recurring usage improves your Apify Store recommendations.
- **Webhooks** — fire a webhook on run finish to push new attorney records into your pipeline.
- **Zapier / Make** — connect dataset output to over 5,000 apps (HubSpot, Salesforce, Sheets, Airtable) without code.
- **CSV / Excel export** — download directly from the Apify Console, or filter rows (e.g. `avvoRating >= 9`) and sort in Sheets before CRM import.

### Related Actors: The Legal Data & Lawyer Directory Cluster

- [Avvo Scraper with Mails | US Lawyer Directory](https://apify.com/fatihtahta/avvo-scraper) — Avvo attorney profiles with optional email enrichment; the most-used Avvo scraper on the Store.
- [Attorney Contact List & Lawyer Directory Data — Justia](https://apify.com/jungle_synthesizer/justia-scraper) — free Justia.com lawyer directory: names, contacts, education, bar admissions and reviews by state and practice area.
- [Martindale Scraper with Mails | US & Canada Lawyer Directory](https://apify.com/fatihtahta/martindale-scraper) — Martindale-Hubbell profiles with peer-review ratings, useful for cross-checking Avvo ratings.
- [FindLaw Attorney Directory Scraper](https://apify.com/moving_beacon-owner1/findlaw-attorney-directory-scraper) — attorney and firm profiles from FindLaw with emails, ratings and badges.
- [Attorney Database & Lawyer Directory Data — Avvo Scraper](https://apify.com/jungle_synthesizer/avvo-scraper) — deep Avvo records including bar admissions and discipline, for verification-heavy workflows.

### FAQ

#### Is there an Avvo API?

No public one. `api.avvo.com` requires partner credentials and Avvo offers no consumer developer API. This actor is effectively an **Avvo API alternative**: it returns the same field set (name, firm, phone, address, practice areas, ratings, reviews) as clean JSON — pulled from the JSON-LD that powers Avvo's public search pages — with no API key, no login and no partner approval.

#### How do I scrape Avvo lawyers?

Enter a practice-area slug (e.g. `personal-injury`) and a two-letter US state code (e.g. `ny`), optionally set `maxResults`, and start the run. For large runs, enable Apify Proxy with a US residential group. Results stream to a dataset you can export as JSON, CSV or Excel.

#### Is it legal to scrape Avvo?

This actor reads only publicly available directory pages and the structured data embedded in them — no login, no partner-API bypass, no CAPTCHA solving, no private data. That said, you are responsible for complying with Avvo's Terms of Service and applicable data-protection law for how you use the data. See the Legal & Compliance Disclaimer below.

#### Do I need proxies?

Avvo is fronted by Cloudflare and regularly challenges datacenter traffic. The actor detects challenge pages, rotates sticky proxy sessions and retries with backoff, but for reliable large runs a **US residential proxy group is strongly recommended**. Without a proxy, expect occasional blocked pages on high-volume runs.

#### What fields are returned?

One flat row per attorney: `attorneyName`, `profileUrl`, `avvoId`, `firmName`, `phone`, `streetAddress`, `city`, `state`, `postalCode`, `country`, `practiceAreas`, `avvoRating`, `reviewCount`, `education`, `awards`, `bio`, `priceRange`. See the output table above for details.

#### Does it include phone numbers and emails?

Phone: **yes** — the phone number published on each attorney's listing. Email: **no** — Avvo does not publish attorney email addresses in its directory listings or JSON-LD, so this actor never returns emails (and never guesses them).

#### Is there a free preview?

Yes. Free Apify accounts are capped at **10 attorneys per run**; paid accounts can collect up to `maxResults` (max 100,000). Pricing is pay-per-event: **$0.001 per result** plus **$0.00005 per actor start** — among the cheapest per-result pricing of any Avvo scraper on the Store (for comparison, the next-cheapest alternatives charge $0.0013–$0.004 per profile plus additional-data fees).

#### What are the alternatives to Avvo for lawyer data?

Justia, FindLaw, Martindale-Hubbell, Lawyers.com, Super Lawyers and state bar directories each cover the US attorney market with different depth and pricing — Justia is free, Martindale adds peer reviews, state bars are the source of license records. Avvo is the largest by audience (17+ million annual visitors) and the only one exposing ratings, reviews and full contact data through page-level JSON-LD this cleanly. See Related Actors above.

### SEO Keywords

avvo scraper, avvo lawyer scraper, avvo api alternative, lawyer directory data, legal directory scraping, attorney lead generation, legal lead generation, personal injury lawyer data, personal injury attorneys list, plaintiff attorney data, attorney contact data, lawyer contact information, law firm leads, legal marketing leads, us lawyer database, us attorney database, avvo rating data, avvo ratings and reviews, divorce attorneys california, criminal defense lawyers texas, real estate attorneys florida, medical malpractice attorneys, estate planning attorneys, business attorney database, chicago lawyer directory

### For AI Agents & LLM Apps

**Purpose.** Given a practice-area slug and a US state code (or explicit Avvo search URLs), returns one dataset row per attorney with identity, firm, phone, full address, practice areas, Avvo rating (1–10), review count, education, awards, bio and price range from Avvo's public JSON-LD — no browser, no API key.

**Minimal working input.**

```json
{
  "practiceArea": "personal-injury",
  "location": "ny",
  "maxResults": 10
}
```

**Variant input (directory pages instead of built URLs).**

```json
{
  "startUrls": ["https://www.avvo.com/divorce-lawyer/ca.html"],
  "maxResults": 50
}
```

**Output fields.** `attorneyName`, `profileUrl`, `avvoId`, `firmName`, `phone`, `streetAddress`, `city`, `state`, `postalCode`, `country`, `practiceAreas` (array of `{name}`), `avvoRating`, `reviewCount`, `education` (array), `awards` (array), `bio`, `priceRange`.

**Behaviors an agent should know.**

- `startUrls` overrides `practiceArea` + `location` whenever it is non-empty — do not pass both expecting them to merge.
- `practiceArea` and `location` accept comma-separated values; every combination becomes a search URL (e.g. `"ny,tx"` × `"divorce,family"` yields four URLs). Sanitize the strings to `[a-z0-9-]` before calling.
- `maxResults` caps billable results and defaults to 100 if unset. Free accounts are hard-capped at **10 attorneys per run** regardless of `maxResults`.
- Avvo is Cloudflare-protected: for runs beyond a few dozen attorneys, enable Apify Proxy with a US residential group. The actor auto-detects challenge pages (4xx status or challenge markers), rotates sticky proxy sessions, and retries with exponential backoff (3 attempts without proxy, 5 with).
- Blocked/failed pages produce no dataset rows and are **not charged** — only actually-pushed results are billed.
- The public phone number is the primary contact field; the actor does not return emails (Avvo publishes none).

**Billing.** Pay-per-event: $0.001 per dataset result (attorney), $0.00005 per actor start. No free events; free accounts preview up to 10 attorneys per run.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Avvo Inc. or its parent company Internet Brands**. It reads only publicly available Avvo directory pages and the JSON-LD structured data embedded in them — the same content any visitor sees. It does not log in, does not bypass the partner-only `api.avvo.com` access model, and does not solve CAPTCHAs beyond rotating public proxy connections.

You are responsible for your own compliance with Avvo's Terms of Service and all applicable laws when using this data. Output includes professional contact details (names, firm names, phone numbers, addresses, ratings) — do not use phone numbers or other personal data for unsolicited commercial outreach in violation of applicable law (e.g. CAN-SPAM, the TCPA, or GDPR/CCPA where they apply). This information is provided for informational purposes only and is not legal advice.

# Actor input Schema

## `practiceArea` (type: `string`):

Practice-area slug to scrape, e.g. `personal-injury`, `divorce`, `criminal-defense`, `estate-planning`. Combined with the state code to build the Avvo search URL.

## `location` (type: `string`):

Two-letter US state code, e.g. `ny`, `ca`, `tx`. Combined with the practice area to build the Avvo search URL.

## `startUrls` (type: `array`):

Optional. Custom Avvo search URLs to start from. When provided, `practiceArea` and `location` are ignored.

## `maxResults` (type: `integer`):

Maximum number of attorneys to scrape.

## `proxy` (type: `object`):

Select proxies to be used by your crawler. Recommended: enable Apify Proxy with a US residential group — Avvo is Cloudflare-protected and datacenter IPs may be challenged.

## Actor input object example

```json
{
  "practiceArea": "personal-injury",
  "location": "ny",
  "startUrls": [],
  "maxResults": 100,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "practiceArea": "personal-injury",
    "location": "ny",
    "startUrls": [],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/avvo-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 = {
    "practiceArea": "personal-injury",
    "location": "ny",
    "startUrls": [],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/avvo-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 '{
  "practiceArea": "personal-injury",
  "location": "ny",
  "startUrls": [],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/avvo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/avvo-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/1hRxgFm88UdtBDJ4R/builds/qBiHzOmdBcB6Ij4iM/openapi.json