# Super Lawyers Scraper - Attorney & Law Firm Leads (`scrapesage/superlawyers-scraper`) Actor

Scrape the Super Lawyers attorney directory by practice area & city: top-rated attorneys & law firms with phone, website, address, practice areas, languages, law school, award selection history & lead score. Monitoring mode. No login or API key.

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

## Pricing

from $10.00 / 1,000 attorney 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

## Super Lawyers Scraper — Top-Rated Attorney & Law Firm Leads

Extract **complete Super Lawyers attorney data** — the peer-rated, top-5% legal directory from Thomson Reuters. Get every **attorney's name, firm, phone, website, full address, practice areas, languages, law school**, and the data nobody else ships: the **award selection history** (Super Lawyers vs Rising Stars, years selected, selection period). Optionally turn each attorney into a **ready-to-contact B2B lead** by crawling their own website for **contact emails, phone numbers, and social links**.

No login, no cookies, no API key, no browser — fast server-rendered HTML extraction with automatic block-retry.

### Why this Super Lawyers scraper?

Most legal scrapers either target the Cloudflare-walled directories (and run flaky), or only skim the listing cards and return `null` for the fields that matter. This actor parses both the listing JSON-LD **and** each attorney's full profile, shipping the **richest dataset in the category**:

| Data | Typical scrapers | This actor |
|---|---|---|
| Attorney name, firm, phone, address | ✅ | ✅ |
| Top practice area + **all** practice areas | partial | ✅ |
| **Award type** (Super Lawyers / Rising Stars) | ❌ | ✅ |
| **Years selected + selection period** | ❌ | ✅ |
| Law school + languages spoken | ❌ | ✅ |
| Full attorney bio | ❌ | ✅ |
| Attorney's **own website** (lead wedge) | ❌ | ✅ |
| Cross-directory listings (FindLaw, Justia, …) | ❌ | ✅ |
| Firm details (legal name, price range, geo) | partial | ✅ opt-in |
| Contact **emails** (from their website) | ❌ | ✅ opt-in |
| Lead score (0–100) per attorney | ❌ | ✅ |
| Monitoring mode (only new attorneys) | ❌ | ✅ |

### Use cases

- **Legal lead generation** — top-rated attorneys are premium B2B buyers: they need case-management software, legal marketing, malpractice insurance, expert witnesses, court reporting, e-discovery, co-counsel referrals and staffing. Score them by selection (`selectionType`, `yearsSelected`) and reach them directly (`website`, `contactEmails`).
- **Referral & co-counsel networks** — build a vetted, practice-area-specific roster of *Super Lawyers*- and *Rising Stars*-rated attorneys in any city.
- **Recruiting & lateral hiring** — find peer-rated attorneys by practice area, firm, law school and city.
- **Market intelligence** — analyze the concentration of top-rated attorneys by practice area and metro, firm rankings, and pricing signals (`priceRange`).
- **Competitor & firm monitoring** — schedule recurring runs to capture newly selected attorneys each year with monitoring mode.

### 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 **Super Lawyers Scraper**, enter practice areas and locations (or paste Super Lawyers URLs), and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "search",
    "practiceAreas": ["personal-injury-plaintiff", "criminal-defense"],
    "locations": ["New York, NY", "Los Angeles, CA"],
    "maxResults": 200,
    "includeProfileDetails": true,
    "includeFirms": true,
    "awardFilter": "any",
    "enrichContactEmails": true
}
````

- **practiceAreas** — practice-area slugs as used in Super Lawyers URLs (`personal-injury-plaintiff`, `criminal-defense`, `dui-dwi`, `family-law`, `estate-planning-and-probate`, `business-and-corporate`, `employment-and-labor`, `immigration`, `real-estate`, `bankruptcy`, `medical-malpractice`, `intellectual-property`, …). Common shorthand (`personal-injury`, `divorce`, `dui`, `criminal`) is auto-mapped.
- **locations** — `City, State` strings (`New York, NY`, `Houston, Texas`). A bare state (`California`) scrapes cities from its Super Lawyers state page, capped by `maxCitiesPerState`.
- **startUrls** — direct attorney/firm profile URLs (`profiles.superlawyers.com/…/lawyer/…-UUID.html`) or listing URLs (`attorneys.superlawyers.com/<practice-area>/<state>/<city>/`). Auto-detected and routed.
- **maxResults** *(default 100)* — cap on attorney records.
- **includeProfileDetails** *(default true)* — open each attorney's profile for bio, all practice areas, languages, selection history, law school and their own website.
- **includeFirms** *(default false)* — also output one deduplicated firm record per unique firm.
- **awardFilter** *(default any)* — keep only `super-lawyers` or `rising-stars` selectees.
- **withWebsiteOnly** *(default false)* — only attorneys with a website / email.
- **enrichContactEmails** *(default false)* — crawl the attorney's/firm's own website (home + contact/about, max 3 pages) for emails, phones and socials. Super Lawyers never exposes emails — this is the way to get them.
- **monitorMode** *(default false)* — return only attorneys/firms not seen in previous runs.

### Output

One record per attorney (`type: "attorney"`), plus optional firm records (`type: "firm"`):

```json
{
    "type": "attorney",
    "attorneyId": "0eaed0e2-c530-4c26-b68c-ba672c8a2fcd",
    "name": "David A. Bonilla",
    "jobTitle": "Attorney at Law",
    "profileUrl": "https://profiles.superlawyers.com/new-york/new-york/lawyer/david-a-bonilla/0eaed0e2-c530-4c26-b68c-ba672c8a2fcd.html",
    "selectionType": "Rising Stars",
    "awards": ["Selected to Rising Stars"],
    "selections": [
        { "award": "Rising Stars", "yearsSelected": 5, "selectionPeriod": "2021 - 2025" }
    ],
    "topPracticeArea": "Personal Injury - General",
    "practiceAreas": ["Personal Injury - General"],
    "languages": ["English"],
    "bio": "David A. Bonilla serves as a partner at EEP Law, in New York, New York…",
    "lawSchool": "Yeshiva University Benjamin N. Cardozo School of Law",
    "headshotUrl": "https://cdn.superlawyers.com/image/upload/.../david-a--bonilla.png",
    "phone": "212-532-1116",
    "website": "http://eeplaw.com",
    "crossListings": ["https://lawyers.findlaw.com/new-york/new-york/5383517_1/"],
    "firmId": "b22f700c-9882-4304-b5a9-ed24d7757028",
    "firmName": "EEP Law",
    "firmPhone": "+1-2125321116",
    "firmPriceRange": "Varies based on case specifics",
    "firmAddress": { "street": "80 Pine Street 38th Floor", "city": "New York", "region": "NY", "postalCode": "10005", "country": "US" },
    "firmGeo": { "latitude": 40.70577, "longitude": -74.00697 },
    "placementTier": "organic",
    "contactEmails": ["info@eeplaw.com"],
    "searchPracticeArea": "personal-injury-plaintiff",
    "searchCity": "new-york",
    "searchState": "new-york",
    "leadScore": 78,
    "scrapedAt": "2026-06-23T12:00:00.000Z"
}
```

### 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 weekly/monthly to capture newly selected attorneys; pair with monitoring mode for a clean only-new feed.
- **[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/superlawyers-scraper').call({
    practiceAreas: ['personal-injury-plaintiff'],
    locations: ['Los Angeles, CA'],
    maxResults: 200,
    includeFirms: true,
    enrichContactEmails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} attorneys & firm 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 attorney leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored search finds new attorneys.
- **[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. You can 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 Super Lawyers personal-injury attorneys in Chicago and list their firm websites and contacts" and let it run this scraper for you.

### More scrapers from scrapesage

Build a complete **professional lead-gen stack** — pair top-rated attorneys with adjacent verticals:

- **[FindLaw Scraper](https://apify.com/scrapesage/findlaw-scraper)** — the broader FindLaw lawyer & law-firm directory with contact emails.
- **[TaxBuzz Scraper](https://apify.com/scrapesage/taxbuzz-scraper)** — tax preparers, CPAs & accounting professional leads.
- **[Financial Advisor & Broker Scraper](https://apify.com/scrapesage/financial-advisor-scraper)** — FINRA / SEC advisors, brokers & firms.
- **[Insurance Agent Scraper](https://apify.com/scrapesage/insurance-agent-scraper)** — State Farm & Farmers agent leads.
- **[Healthgrades Scraper](https://apify.com/scrapesage/healthgrades-scraper)** — doctors, ratings & provider leads.
- **[WebMD Scraper](https://apify.com/scrapesage/webmd-scraper)** — doctors, reviews, insurance & provider leads.
- **[US Professional License Scraper](https://apify.com/scrapesage/us-professional-license-scraper)** — licensed professionals across states.
- **[Google Maps Scraper](https://apify.com/scrapesage/google-maps-scraper)** — local business leads, emails & reviews.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — emails, phones & socials from any website.

### Tips

- **Practice-area slugs**: use the exact slug from a Super Lawyers listing URL (e.g. `personal-injury-plaintiff`, not `personal-injury`). The actor auto-maps the most common shorthand, but custom areas should match the URL.
- **Deep inventory**: large metros have 50+ pages per practice area. Raise `maxResults` to pull more; combine with `awardFilter: "super-lawyers"` for only the top tier.
- **State-wide runs**: pass a bare state (`Texas`) and set `maxCitiesPerState` to fan out across its cities.
- **Cost control**: profile detail and email enrichment only run when needed; enrichment fires only for attorneys that actually list a website.
- **Proxies**: keep the default **US Residential** proxy. Super Lawyers serves clean pages over residential IPs but Cloudflare-challenges datacenter IPs; blocked requests retry automatically on a fresh IP.

### FAQ

**How do I scrape attorneys for a specific city and practice area?** Put the practice-area slug in `practiceAreas` and the city in `locations` as `City, ST` (e.g. `"New York, NY"`). Both are required in search mode — Super Lawyers only lists attorneys on practice-area + city pages.

**What's the difference between Super Lawyers and Rising Stars?** *Super Lawyers* is the top 5% of attorneys in a state (peer-nominated, independently researched). *Rising Stars* is the top 2.5% who are 40 or under or have practiced 10 years or less. Use `awardFilter` to keep only one.

**Where do the emails come from?** Never from Super Lawyers (they don't publish emails). With `enrichContactEmails` on, the actor visits the attorney's or firm's own public website and extracts publicly listed contact emails — the same thing a human visitor would see.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor newly selected attorneys?** Turn on `monitorMode` and create a [Schedule](https://docs.apify.com/platform/schedules). Each run returns only attorneys not seen before, so you get a clean only-new feed.

**Is scraping Super Lawyers legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (GDPR/CCPA for personal data) and the site's terms.

**A field is null — why?** Some attorneys genuinely don't publish a bio, a website, or multiple practice areas. Fields are `null` only when the data doesn't exist, not because the scraper skipped them.

### 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 an attorney list from practice areas × locations. Start URLs scrapes specific Super Lawyers profile or listing URLs you paste in.

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

Practice-area slugs as used in Super Lawyers URLs, e.g. personal-injury-plaintiff, criminal-defense, dui-dwi, family-law, estate-planning-and-probate, business-and-corporate, employment-and-labor, immigration, real-estate, bankruptcy, medical-malpractice, intellectual-property. Common shorthand (personal-injury, divorce, dui, criminal) is auto-mapped. One per row. (Search mode.)

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

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

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

Super Lawyers URLs to scrape directly: attorney/firm profile URLs (profiles.superlawyers.com/…/lawyer/…-UUID.html or …/lawfirm/…-UUID.html) or listing URLs (attorneys.superlawyers.com/<practice-area>/<state>/<city>/). Auto-detected and routed. One per row. (Start URLs mode.)

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

Cap on attorney records across the whole run. Listings are paginated automatically until this cap or the result set is exhausted. (Firm records are emitted as a bonus and do not count against this cap.)

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

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

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

Open each attorney's profile page for the full record: bio, all practice areas, languages, the selection history (award type, years selected, selection period), law school, the firm with geo, and the attorney's own website (the lead wedge). One extra request per attorney. Turn off for a faster, listing-only run.

## `includeFirms` (type: `boolean`):

Output one deduplicated law firm record (type `firm`) per unique firm seen — name, legal name, phone, price range, full address, geo and profile URL — alongside the attorney records.

## `awardFilter` (type: `string`):

Keep only attorneys with a given Super Lawyers selection. "Super Lawyers" = the top 5% peer-rated; "Rising Stars" = top 2.5% under 40 / practicing ≤10 years.

## `withWebsiteOnly` (type: `boolean`):

Output only attorneys that have an own website (or, with enrichment on, a contact email). Useful for building a directly-contactable lead list.

## `deduplicateAttorneys` (type: `boolean`):

Skip an attorney already emitted earlier in the same run (common when one lawyer appears under several practice areas or cities).

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

Opt-in extra lead enrichment: crawl each attorney's/firm's own website (home + contact/about, max 3 pages) for emails, phone numbers and social links. Only runs for records that list a website. Super Lawyers does not publish emails — this is the way to get them.

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

Remember what was already returned and emit ONLY records not seen in previous runs (new attorneys, and new firms). Pairs with Apify Schedules to track new attorney selections 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. Super Lawyers serves clean pages over US residential IPs but Cloudflare-challenges datacenter IPs, so US Residential is the default and recommended setting. Blocked requests retry automatically on a fresh IP.

## Actor input object example

```json
{
  "mode": "search",
  "practiceAreas": [
    "personal-injury-plaintiff"
  ],
  "locations": [
    "New York, NY"
  ],
  "maxResults": 100,
  "maxCitiesPerState": 10,
  "includeProfileDetails": true,
  "includeFirms": false,
  "awardFilter": "any",
  "withWebsiteOnly": false,
  "deduplicateAttorneys": true,
  "enrichContactEmails": false,
  "monitorMode": false,
  "monitorStoreName": "superlawyers-scraper-monitor",
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "countryCode": "US"
  }
}
```

# Actor output Schema

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

All scraped records in the default dataset. Attorney rows carry full profile data, the award selection history, contact leads and a lead score; firm rows carry firm-level details.

# 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": [
        "New York, NY"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/superlawyers-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": ["New York, NY"],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/superlawyers-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": [
    "New York, NY"
  ]
}' |
apify call scrapesage/superlawyers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Super Lawyers Scraper - Attorney & Law Firm Leads",
        "description": "Scrape the Super Lawyers attorney directory by practice area & city: top-rated attorneys & law firms with phone, website, address, practice areas, languages, law school, award selection history & lead score. Monitoring mode. No login or API key.",
        "version": "0.1",
        "x-build-id": "jpwCTPgoYLMAsToEK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~superlawyers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-superlawyers-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~superlawyers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-superlawyers-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~superlawyers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-superlawyers-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 an attorney list from practice areas × locations. Start URLs scrapes specific Super Lawyers profile or listing URLs you paste in.",
                        "default": "search"
                    },
                    "practiceAreas": {
                        "title": "Practice areas",
                        "type": "array",
                        "description": "Practice-area slugs as used in Super Lawyers URLs, e.g. personal-injury-plaintiff, criminal-defense, dui-dwi, family-law, estate-planning-and-probate, business-and-corporate, employment-and-labor, immigration, real-estate, bankruptcy, medical-malpractice, intellectual-property. Common shorthand (personal-injury, divorce, dui, criminal) is auto-mapped. One per row. (Search mode.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities/states to search, as \"City, State\" — e.g. \"New York, NY\", \"Houston, Texas\", \"Miami, FL\". A bare state (\"California\") scrapes cities listed on its Super Lawyers state page, capped by Max cities per state. One per row. (Search mode.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (Super Lawyers profile or listing URLs)",
                        "type": "array",
                        "description": "Super Lawyers URLs to scrape directly: attorney/firm profile URLs (profiles.superlawyers.com/…/lawyer/…-UUID.html or …/lawfirm/…-UUID.html) or listing URLs (attorneys.superlawyers.com/<practice-area>/<state>/<city>/). Auto-detected and routed. One per row. (Start URLs mode.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results (attorneys)",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Cap on attorney records across the whole run. Listings are paginated automatically until this cap or the result set is exhausted. (Firm records are emitted as a bonus and do not count against this cap.)",
                        "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 Super Lawyers page to scrape. Set 0 to skip bare-state locations. Ignored when a city is given.",
                        "default": 10
                    },
                    "includeProfileDetails": {
                        "title": "Include full attorney profiles (bio, practice areas, awards)",
                        "type": "boolean",
                        "description": "Open each attorney's profile page for the full record: bio, all practice areas, languages, the selection history (award type, years selected, selection period), law school, the firm with geo, and the attorney's own website (the lead wedge). One extra request per attorney. Turn off for a faster, listing-only run.",
                        "default": true
                    },
                    "includeFirms": {
                        "title": "Also output law firm records",
                        "type": "boolean",
                        "description": "Output one deduplicated law firm record (type `firm`) per unique firm seen — name, legal name, phone, price range, full address, geo and profile URL — alongside the attorney records.",
                        "default": false
                    },
                    "awardFilter": {
                        "title": "Award filter",
                        "enum": [
                            "any",
                            "super-lawyers",
                            "rising-stars"
                        ],
                        "type": "string",
                        "description": "Keep only attorneys with a given Super Lawyers selection. \"Super Lawyers\" = the top 5% peer-rated; \"Rising Stars\" = top 2.5% under 40 / practicing ≤10 years.",
                        "default": "any"
                    },
                    "withWebsiteOnly": {
                        "title": "Only attorneys with a website",
                        "type": "boolean",
                        "description": "Output only attorneys that have an own website (or, with enrichment on, a contact email). Useful for building a directly-contactable lead list.",
                        "default": false
                    },
                    "deduplicateAttorneys": {
                        "title": "Deduplicate attorneys across searches",
                        "type": "boolean",
                        "description": "Skip an attorney already emitted earlier in the same run (common when one lawyer appears under several practice areas or cities).",
                        "default": true
                    },
                    "enrichContactEmails": {
                        "title": "Enrich contacts from the attorney's website",
                        "type": "boolean",
                        "description": "Opt-in extra lead enrichment: crawl each attorney's/firm's own website (home + contact/about, max 3 pages) for emails, phone numbers and social links. Only runs for records that list a website. Super Lawyers does not publish emails — this is the way to get them.",
                        "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 attorneys, and new firms). Pairs with Apify Schedules to track new attorney selections 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": "superlawyers-scraper-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. Super Lawyers serves clean pages over US residential IPs but Cloudflare-challenges datacenter IPs, so US Residential is the default and recommended setting. Blocked requests retry automatically on a fresh IP.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "countryCode": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
