# FindLaw Scraper — Lawyers, Law Firms & Leads (`scrapesage/findlaw-scraper`) Actor

Scrape FindLaw's lawyer directory by practice area & location: law firms and attorneys with contact email, phone, fax, website, full address, practice areas, honors, reviews and a lead score. Monitoring mode. No login, no API key, no browser.

- **URL**: https://apify.com/scrapesage/findlaw-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 law firm scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## FindLaw Scraper — Lawyers, Law Firms & Leads (Emails, Phones & Reviews)

Extract **complete data from the [FindLaw](https://lawyers.findlaw.com) lawyer directory** — search **law firms and attorneys by practice area and location** and get a ready-to-use **B2B lead** for every one: firm name, **direct contact email**, phone, fax, website, full office addresses, practice areas, honors/education, client reviews and a **lead score**.

No login, no cookies, no API key, no browser — fast, reliable extraction across all 50 states and thousands of US cities.

### Why this FindLaw scraper?

Generic "paste-a-URL" crawlers grab a few visible fields and miss the data that actually matters for outreach. This actor reads FindLaw's public listing and profile pages directly and ships the **richest legal dataset in the category** — including the firm's **direct contact email**, which it recovers straight from the page (no website crawl or CAPTCHA needed).

| Data | Generic crawlers | This actor |
|---|---|---|
| Firm / attorney name, profile URL | ✅ | ✅ |
| **Direct contact email** | ❌ | ✅ when published |
| Phone + **fax** | partial | ✅ |
| Firm **website** | ❌ | ✅ when listed |
| All **office locations** (full address + geo) | ❌ | ✅ |
| Practice areas | ❌ | ✅ |
| Honors / education, firm overview, previous names | ❌ | ✅ |
| Client **reviews** (rating, text, aspects) | ❌ | ✅ |
| Free-consultation, Super Lawyers, years of experience | ❌ | ✅ when shown |
| **Lead score** (0–100) | ❌ | ✅ |
| Monitoring (only new listings) | ❌ | ✅ |

### Use cases

- **Legal lead generation** — build targeted lists of law firms and attorneys by practice area and city, complete with email, phone and website, and feed your CRM or outreach sequence.
- **Legal services & SaaS sales** — sell case-management software, intake tools, marketing or e-discovery to firms; filter by size, practice area, free-consultation and review volume.
- **Market & competitive research** — map the legal landscape of any city: who practices what, who's top-rated, who's a Super Lawyers selectee.
- **Recruiting & referrals** — find attorneys by specialty and location with firm and contact details.
- **Directory & data enrichment** — enrich an existing firm list with addresses, practice areas, ratings and contacts.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **FindLaw Scraper**, choose **Search**, add one or more **practice areas** (e.g. `personal-injury-plaintiff`) and **locations** (e.g. `Los Angeles, CA`).
3. Click **Start** and watch firm leads stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML or RSS — or pull results via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "search",
    "practiceAreas": ["personal-injury-plaintiff", "criminal-law"],
    "locations": ["Los Angeles, CA", "Houston, Texas"],
    "includeProfileDetails": true,
    "includeReviews": false,
    "maxResults": 200
}
````

- **mode** — `search` (build a list from practice areas × locations) or `startUrls` (scrape specific FindLaw profile/listing URLs).
- **practiceAreas** — practice-area slugs as they appear in FindLaw URLs, e.g. `personal-injury-plaintiff`, `criminal-law`, `dui-dwi`, `divorce`, `family-law`, `bankruptcy-law`, `estate-planning`, `business-commercial-law`, `employment-law-employee`, `immigration-naturalization-law`, `real-estate-law`, `medical-malpractice`.
- **locations** — `"City, State"` (e.g. `Los Angeles, CA`, `Miami, FL`). A bare state (`California`) scrapes the cities listed on its FindLaw state page, capped by **maxCitiesPerState**.
- **startUrls** — FindLaw profile URLs (`…/state/city/name-ID/`) or listing URLs (`…/practice-area/state/city/`); auto-detected.
- **includeProfileDetails** *(default true)* — open each firm's profile for the decoded contact email, fax, all offices, practice areas, overview, honors and attorney roster.
- **includeReviews** *(default false)* / **maxReviewsPerFirm** — output client reviews as their own records.
- **includeAttorneys** *(default false)* — also output individual attorneys listed on each search page.
- **enrichContactEmails** *(default false)* — additionally crawl each firm's own website for more emails/phones/socials.
- **monitorMode** *(default false)* / **monitorStoreName** — emit only records not seen in previous runs.
- **maxResults / maxConcurrency / proxyConfiguration** — caps, parallelism and proxy.

### Output

By default you get one dense table of **firm leads** — every column applies to every row. Set `includeReviews` for review rows, or `includeAttorneys` for individual attorney rows. Each row is tagged with a `type` (`firm`, `attorney` or `review`); switch between the **Firms / Leads / Reviews** dataset views.

A firm record (`type: "firm"`):

```json
{
    "type": "firm",
    "firmId": "NDg1NTY0NF8x",
    "name": "Law Offices of Michael Jay Berger",
    "isAttorney": false,
    "profileUrl": "https://lawyers.findlaw.com/california/los-angeles/law-offices-of-michael-jay-berger-NDg1NTY0NF8x/",
    "email": "michael.berger@bankruptcypower.com",
    "phone": "+1-310-810-4683",
    "fax": "310-271-9805",
    "website": "https://www.bankruptcypower.com",
    "address": { "street": "515 South Flower Street", "city": "Los Angeles", "region": "CA", "postalCode": "90071", "country": "US" },
    "geo": { "latitude": 34.0514526, "longitude": -118.2566681 },
    "practiceAreas": ["Bankruptcy", "Chapter 11", "Chapter 7", "Chapter 13", "Litigation"],
    "honors": ["Graduated Hastings College of the Law With Honors, Order of the Coif, Law Review"],
    "offices": [{ "name": "Long Beach Office", "phone": "310-810-4683", "address": { "street": "111 West Ocean Blvd. Suite 400", "city": "Long Beach", "region": "CA", "postalCode": "90802" } }],
    "rating": 5.0,
    "reviewCount": 4,
    "offersFreeConsultation": true,
    "searchPracticeArea": "bankruptcy-law",
    "searchCity": "los-angeles",
    "searchState": "california",
    "leadScore": 92,
    "scrapedAt": "2026-06-15T00:00:00.000Z"
}
```

A review record (`type: "review"`) carries `firmName`, `rating`, `author`, `datePublished`, `body`, `aspects` and `positiveNotes`. An attorney record (`type: "attorney"`) carries `name`, `jobTitle`, `firmName`, `phone`, `address` and (for profile URLs) `email` and `practiceAreas`.

#### What to expect (field coverage)

FindLaw is firm-entered data, so some fields are populated only when the firm filled them in. Across multiple practice areas and cities you can typically expect:

| Entity | Always present | Usually present | Present when published |
|---|---|---|---|
| **Firm** | name, profile URL, address | phone ~95%, practice areas ~90%, **email ~70–85%** (profile details on) | website, fax, honors, reviews, free-consultation, Super Lawyers |
| **Attorney** | name, profile URL, job title | firm, phone, address | email, practice areas (on profile URLs) |
| **Review** | rating, date, body | author (often "anonymous") | rated aspects, highlighted notes |

A blank field means the firm didn't publish it — not that scraping failed. Nothing is dropped, so you always get the richest record available.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly to capture new firms and reviews. Combine with **monitoring mode** so each scheduled run returns only what's new.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/findlaw-scraper').call({
    mode: 'search',
    practiceAreas: ['personal-injury-plaintiff'],
    locations: ['Los Angeles, CA'],
    includeProfileDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} legal leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new firm leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored search adds new firms.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find every personal-injury law firm in Los Angeles with an email and phone" and let it run the scraper for you.

### More scrapers from scrapesage

Build a complete **lead-generation & B2B intelligence stack**:

- **[Healthgrades Scraper](https://apify.com/scrapesage/healthgrades-scraper)** — doctors, reviews and provider leads.
- **[Companies House Scraper](https://apify.com/scrapesage/companies-house-scraper)** — UK companies, directors & PSCs.
- **[SEC EDGAR Scraper](https://apify.com/scrapesage/sec-edgar-scraper)** — filings, financials & companies.
- **[USAspending Scraper](https://apify.com/scrapesage/usaspending-scraper)** — federal awards, contractors & leads.
- **[Product Hunt Scraper](https://apify.com/scrapesage/product-hunt-scraper)** — launches, makers & leads.
- **[YouTube Scraper](https://apify.com/scrapesage/youtube-scraper)** — channels, videos & creator leads.
- **[Eventbrite Scraper](https://apify.com/scrapesage/eventbrite-scraper)** — events plus organizer leads.
- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** — job postings as hiring-intent signals.

### Tips

- **Use exact practice-area slugs.** Open any FindLaw category page and copy the slug from the URL — e.g. `lawyers.findlaw.com/personal-injury-plaintiff/california/los-angeles/` → `personal-injury-plaintiff`. (Plain "personal-injury" redirects to a hub and returns nothing.)
- **Direct emails:** keep `includeProfileDetails` on — it's how the actor recovers the firm's contact email. It adds one fast request per firm.
- **State-wide pulls:** pass a bare state (`Texas`) and raise `maxCitiesPerState` to sweep multiple cities in one run.
- **Recurring monitoring:** pair [Schedules](https://docs.apify.com/platform/schedules) with monitoring mode to capture new firms and reviews as they appear.

### FAQ

**How do I scrape a specific city + practice area?** Use Search with the practice-area slug (e.g. `divorce`) and the location (`Miami, FL`). Or paste the FindLaw listing URL into `startUrls`.

**Does it need the FindLaw API or a key?** No. It reads FindLaw's public listing and profile pages — no key, no login, no browser.

**Where does the email come from?** From the firm's own FindLaw profile page (recovered and decoded from the page), when the firm published one. About 70–85% of firms expose it. Turn on `enrichContactEmails` to also pull emails from the firm's website.

**A field is empty — why?** Some firms don't publish a website, fax, email or reviews. Fields are blank only when the firm didn't publish that data — never because the scraper skipped it.

**How do I monitor for new firms?** Turn on monitoring mode and create a [Schedule](https://docs.apify.com/platform/schedules). Each run returns only firms/reviews not seen before. Monitoring mode works alongside Schedules — it does not conflict with them.

**Is scraping FindLaw legal?** This actor collects publicly available business directory data only. You're responsible for using it in compliance with applicable laws (e.g. CAN-SPAM/GDPR for outreach) and FindLaw's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `mode` (type: `string`):

Search builds a lawyer list from practice areas × locations. Start URLs scrapes specific FindLaw profile or listing URLs you paste in.

## `practiceAreas` (type: `array`):

Practice-area slugs as used in FindLaw URLs, e.g. personal-injury-plaintiff, criminal-law, dui-dwi, divorce, family-law, bankruptcy-law, estate-planning, employment-law-employee, immigration-naturalization-law, real-estate-law, medical-malpractice. One per row. (Search mode.)

## `locations` (type: `array`):

Cities/states to search, as "City, State" — e.g. "Los Angeles, CA", "Houston, Texas", "Miami, FL". A bare state ("California") scrapes cities listed on its FindLaw state page, capped by Max cities per state. One per row. (Search mode.)

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

FindLaw URLs to scrape directly: firm/attorney profile URLs (…/state/city/name-ID/) or listing URLs (…/practice-area/state/city/). Auto-detected and routed. One per row. (Start URLs mode.)

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

Cap on firm/attorney records across the whole run. Listings are paginated automatically until this cap or the result set is exhausted.

## `maxCitiesPerState` (type: `integer`):

When a location is a bare state (no city), how many cities from that state's FindLaw page to scrape. Set 0 to skip bare-state locations. Ignored when a city is given.

## `includeProfileDetails` (type: `boolean`):

Open each firm's profile page for the full record: the decoded contact email, fax, all office locations, practice areas, firm overview, honors/education, previous names and the attorney roster. One extra request per firm. Turn off for a faster, listing-only run.

## `includeReviews` (type: `boolean`):

Also output client review records (type `review`) from each firm's profile: rating, author, date, full text, rated aspects and highlighted notes. In monitoring mode only NEW reviews are returned.

## `maxReviewsPerFirm` (type: `integer`):

How many reviews to output per firm when 'Include client reviews' is on.

## `includeAttorneys` (type: `boolean`):

Also output individual attorney records (type `attorney`) listed on each search page — name, job title, firm, phone and address — alongside the firm records.

## `enrichContactEmails` (type: `boolean`):

Opt-in extra lead enrichment: crawl each firm's own website (home + contact/about) for additional emails, phone numbers and social links. Only runs for firms that list a website. FindLaw already supplies a direct contact email when profile details are on.

## `monitorMode` (type: `boolean`):

Remember what was already returned and emit ONLY records not seen in previous runs (new firms/attorneys, and new reviews per firm). Pairs with Apify Schedules to track new listings over time.

## `monitorStoreName` (type: `string`):

Named key-value store that holds the 'already seen' ids for monitoring mode. Use a different name per tracked target/search to keep their histories separate.

## `maxConcurrency` (type: `integer`):

Maximum parallel requests. Lower it for very large runs if you see transient blocks; raise it for speed.

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

Proxy settings. FindLaw works through the default Apify datacenter proxy (blocked requests retry automatically on a fresh IP). Switch to Residential for the most consistent results on very large runs.

## Actor input object example

```json
{
  "mode": "search",
  "practiceAreas": [
    "personal-injury-plaintiff"
  ],
  "locations": [
    "Los Angeles, CA"
  ],
  "maxResults": 100,
  "maxCitiesPerState": 10,
  "includeProfileDetails": true,
  "includeReviews": false,
  "maxReviewsPerFirm": 20,
  "includeAttorneys": false,
  "enrichContactEmails": false,
  "monitorMode": false,
  "monitorStoreName": "findlaw-monitor",
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped records in the default dataset. Firm/attorney rows carry full profile data, contact leads and a lead score; review rows carry their own rating and text.

# 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 = {
    "practiceAreas": [
        "personal-injury-plaintiff"
    ],
    "locations": [
        "Los Angeles, CA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/findlaw-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 = {
    "practiceAreas": ["personal-injury-plaintiff"],
    "locations": ["Los Angeles, CA"],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/findlaw-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "practiceAreas": [
    "personal-injury-plaintiff"
  ],
  "locations": [
    "Los Angeles, CA"
  ]
}' |
apify call scrapesage/findlaw-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/findlaw-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FindLaw Scraper — Lawyers, Law Firms & Leads",
        "description": "Scrape FindLaw's lawyer directory by practice area & location: law firms and attorneys with contact email, phone, fax, website, full address, practice areas, honors, reviews and a lead score. Monitoring mode. No login, no API key, no browser.",
        "version": "0.1",
        "x-build-id": "Lo3AVUNvnQuh3UG6h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~findlaw-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-findlaw-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapesage~findlaw-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-findlaw-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapesage~findlaw-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-findlaw-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "search",
                            "startUrls"
                        ],
                        "type": "string",
                        "description": "Search builds a lawyer list from practice areas × locations. Start URLs scrapes specific FindLaw profile or listing URLs you paste in.",
                        "default": "search"
                    },
                    "practiceAreas": {
                        "title": "Practice areas",
                        "type": "array",
                        "description": "Practice-area slugs as used in FindLaw URLs, e.g. personal-injury-plaintiff, criminal-law, dui-dwi, divorce, family-law, bankruptcy-law, estate-planning, employment-law-employee, immigration-naturalization-law, real-estate-law, medical-malpractice. One per row. (Search mode.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities/states to search, as \"City, State\" — e.g. \"Los Angeles, CA\", \"Houston, Texas\", \"Miami, FL\". A bare state (\"California\") scrapes cities listed on its FindLaw state page, capped by Max cities per state. One per row. (Search mode.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (FindLaw profile or listing URLs)",
                        "type": "array",
                        "description": "FindLaw URLs to scrape directly: firm/attorney profile URLs (…/state/city/name-ID/) or listing URLs (…/practice-area/state/city/). Auto-detected and routed. One per row. (Start URLs mode.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results (firms/attorneys)",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Cap on firm/attorney records across the whole run. Listings are paginated automatically until this cap or the result set is exhausted.",
                        "default": 100
                    },
                    "maxCitiesPerState": {
                        "title": "Max cities per state (for bare-state locations)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "When a location is a bare state (no city), how many cities from that state's FindLaw page to scrape. Set 0 to skip bare-state locations. Ignored when a city is given.",
                        "default": 10
                    },
                    "includeProfileDetails": {
                        "title": "Include full firm profiles (email, offices, practice areas)",
                        "type": "boolean",
                        "description": "Open each firm's profile page for the full record: the decoded contact email, fax, all office locations, practice areas, firm overview, honors/education, previous names and the attorney roster. One extra request per firm. Turn off for a faster, listing-only run.",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include client reviews",
                        "type": "boolean",
                        "description": "Also output client review records (type `review`) from each firm's profile: rating, author, date, full text, rated aspects and highlighted notes. In monitoring mode only NEW reviews are returned.",
                        "default": false
                    },
                    "maxReviewsPerFirm": {
                        "title": "Max reviews per firm",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many reviews to output per firm when 'Include client reviews' is on.",
                        "default": 20
                    },
                    "includeAttorneys": {
                        "title": "Include individual attorneys from listings",
                        "type": "boolean",
                        "description": "Also output individual attorney records (type `attorney`) listed on each search page — name, job title, firm, phone and address — alongside the firm records.",
                        "default": false
                    },
                    "enrichContactEmails": {
                        "title": "Enrich contacts from the firm's website",
                        "type": "boolean",
                        "description": "Opt-in extra lead enrichment: crawl each firm's own website (home + contact/about) for additional emails, phone numbers and social links. Only runs for firms that list a website. FindLaw already supplies a direct contact email when profile details are on.",
                        "default": false
                    },
                    "monitorMode": {
                        "title": "Monitoring mode — only new records",
                        "type": "boolean",
                        "description": "Remember what was already returned and emit ONLY records not seen in previous runs (new firms/attorneys, and new reviews per firm). Pairs with Apify Schedules to track new listings over time.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Named key-value store that holds the 'already seen' ids for monitoring mode. Use a different name per tracked target/search to keep their histories separate.",
                        "default": "findlaw-monitor"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum parallel requests. Lower it for very large runs if you see transient blocks; raise it for speed.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. FindLaw works through the default Apify datacenter proxy (blocked requests retry automatically on a fresh IP). Switch to Residential for the most consistent results on very large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
