# Super Lawyers Scraper \[From $2.5💰] | Attorney Data | Leads (`ahmed_jasarevic/superlawyers-scraper`) Actor

Extract Super Lawyers attorney data for lead generation, CRM enrichment and legal market research. Get profiles, selections, Rising Stars flags, practice areas, firm data and contact details in structured rows - no official API needed. Runs via API, schedule or webhook.

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

## Pricing

from $2.40 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Super Lawyers Scraper — Attorney, Firm and Rising Stars Data Export

The Super Lawyers scraper turns [superlawyers.com](https://www.superlawyers.com) directory and profile pages into structured rows — up to ~125,000 per run (5,000 directory pages x 25 attorneys), 48 fields per record — for lawyer lead generation, attorney data enrichment and Rising Stars tracking. Server-rendered JSON-LD over plain HTTP: no browser, no login, no official API.

### Main Use Cases — Lawyer Lead Generation, CRM Enrichment and Rising Stars Data

- **Lawyer lead generation** — attorney lead lists by state, city and practice area (including personal injury lawyer leads), with phone, address, website and optionally firm e-mails (`firm_emails`).
- **Attorney data enrichment for CRM pipelines** — join on `profile_id` to add practice areas, selection history, law school, bio and socials.
- **Rising Stars lists, every selection cycle** — `is_rising_star`, `selection_years` and `selections` answer "who made the Rising Stars list?" from data, not press releases.
- **Law firm competitor analysis and legal market research** — `groupBy: "firm"` emits one deduplicated row per firm with attorney count, unioned practice areas, awards and contact block.
- **Super Lawyers data export to CSV, Sheets or Excel** — flat one-row-per-attorney output plus three ready-made views.
- **Directory search at scale** — all 50 states + DC and 140 practice slugs, or paste profile URLs directly.

### How the Super Lawyers Scraper Works

CheerioCrawler only — no Playwright, no headless Chrome. It reads three public sources: directory listing pages, whose embedded `application/ld+json` carries one `Attorney` object per lawyer (25 per page); profile pages, which add biography, practice lists, social links and server-rendered selection-year blocks; and the XML sitemap index, which enumerates every leaf listing. Records de-duplicate on the profile UUID, rows stream as soon as final, and an optional firm-website pass adds published e-mails.

### Does Super Lawyers Have an API? (And How to Export Its Data)

No — probed and ruled out:

- `api.superlawyers.com/v1/*` is the profiles application and answers `401`/`400`.
- `?format=json`, `ajax=1` and `/api/*` on the directory host all serve plain HTML.
- The [Cludo](https://www.cludo.com) search backend returns clean JSON, but its index holds only editorial content — **no attorney profiles**.

supergood.ai's API Report Card grades Super Lawyers an **F**. What the site *does* publish is its **XML sitemap index** and **server-rendered schema.org JSON-LD** — exactly what this actor consumes. Export path: run the actor → read the dataset → CSV, JSON or Excel.

### Scrape the Super Lawyers Directory Without a Browser

**Listing pages** (`attorneys.superlawyers.com/<practice>/<state>/<city>/?page=N`) carry one `Attorney` JSON-LD node per lawyer, 25 per page, `<link rel="next">` pagination, total in the meta description. **Profile pages** (`profiles.superlawyers.com/<state>/<city>/lawyer/<slug>/<uuid>.html`) carry `@graph` JSON-LD (`description`, `knowsAbout`, `sameAs`, `worksFor`) plus server-rendered blocks (`#selection_years li`, `#pa_areas`, `#law_school`, `#licensed_since`, `FLDataLayer`); ranked focus areas and bar activity moved behind JavaScript, so those fields come back **empty rather than wrong**. **Sitemap** (`gsm/attorneys-sitemap-index.xml.gz`) holds 138 shards enumerating every leaf URL — `CA-9-geo-pa-city.xml.gz` alone lists California's 80,512 city URLs, `pa.xml.gz` all 140 practice slugs.

#### How the crawl navigates

Hub pages contain zero attorneys — `/<state>/`, `/<practice>/`, `/<practice>/<state>/`, `/<state>/<city>/` are pure navigation, so a crawler that synthesises them parses nothing. Cheapest complete entry point per filter:

| Filter | Entry point | Why |
|---|---|---|
| `practice` + `state` + `city` | the leaf URL directly | nothing to walk |
| `practice` + `state` | `/<practice>/<state>/` hub → children | one 108 KB request lists all 680 leaves (sitemap: 9 shards / 8.6 MB) |
| `state` + `city` | `/<state>/<city>/` hub → children | all 138 practice leaves in one request |
| `state` only | **sitemap state shards → leaves** | hub walk omits 38 of 736 cities |
| `practice` only | **sitemap `geo-pa.xml.gz` → hubs** | practice hub stops at 61 cities |
| nothing | `/<state>/` for all 51 jurisdictions | — |

Seeds, hub children and sitemap shards are stride-sampled (broad filters stay representative) and bounded by `maxRequestsPerCrawl`.

#### Cloudflare: TLS fingerprinting, retries and proxies

SuperLawyers is not behind a JavaScript challenge — it is a **TLS/JA3 fingerprint block**: `curl` with a browser `User-Agent` gets 200 while Node's `fetch` (identical headers) gets 403. Crawlee's `got-scraping` impersonation clears it and the retry lands the page — `maxRequestRetries` (3) is a correctness requirement (typical run: 403 → 200). If every request is rejected, enable the proxy input with a residential group; the summary prints `throttled (403/429/503)` counts and the last status. Fast bursts earn 429 for the whole IP — keep `requestDelaySecs` at 0.5, raise it (up to 10) on 429s.

#### Slugs must match the site

Twenty previously hard-coded practice slugs (`tax-law`, `real-estate-law`, `mergers-acquisitions`, `appeals`, …) and `district-of-columbia` **do not exist** on SuperLawyers: HTTP 404, empty page, zero rows with no error. Slug tables are verified against `pa.xml.gz` and `npm test` fails if either table drifts.

#### Maximum rows: enrichment is what costs requests

| `enrichProfiles` | Requests for 1,000 rows | Rows per request |
|---|---|---|
| `true` (default) | ~1,040 | ~1 |
| `false` | ~40 | 25 |

A listing page yields 25 attorneys in one request; each profile page is one more request and only *enriches* rows already counted — so `enrichProfiles: false` with `maxRequestsPerCrawl: 5000` reaches **~125,000 rows** (5,000 listing pages x 25), the practical ceiling.

#### Runtime, safety rails and zero-row diagnosis

CheerioCrawler is roughly **4x cheaper and faster** than browser runs. Memory defaults to 2048 MB (min 512, max 4096; a 256 MB run OOM-killed), concurrency 4, 60 s timeouts, desktop headers. `maxRequestsPerCrawl`, `maxPagesPerListing` and `maxItems` stop runs from running away; free accounts are capped at 10 output rows, paying accounts run uncapped. Records merge on the profile UUID (reachable from several practice areas → emitted once, richest values); rows stream, so a stopped run still flushes what it collected.

**Zero rows?** Read the summary log: `throttled (403/429/503)` > 0 → Cloudflare is rejecting the IP (re-run with a residential proxy); `last HTTP status: 404` → a slug does not exist (use `washington-dc`, `tax`, `real-estate`); `hub(s) with no children` → re-run with `"debugHtml": true` and open an issue.

### Input Parameters

All 16 fields optional — empty input crawls 51 jurisdictions x 15 default practice areas, bounded by `maxRequestsPerCrawl`.

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | string\[] | No | `[]` | Directory listing or profile URLs; overrides state/practice filters. |
| `profileUrls` | string\[] | No | `[]` | Profile URLs scraped directly, bypassing the directory crawl. |
| `states` | string\[] | No | `[]` (prefill `CA`) | 2-letter codes, all 50 states + DC. Empty = every state. |
| `practiceAreas` | string\[] | No | `[]` | Slugs as the site serves them (140 in `pa.xml.gz`), e.g. `employment-and-labor`, `family-law`. Unknown slugs 404 with zero rows (misspellings auto-mapped). Empty = 15 major areas. |
| `city` | string | No | `""` | City URL slug, e.g. `los-angeles`. |
| `enrichProfiles` | boolean | No | `true` | Visit each profile page for bio, focus areas, selection years, socials, firm data. **+1 request per attorney** — off = maximum volume. |
| `findFirmEmails` | boolean | No | `false` | Also crawl each firm's website (home + contact pages) for published e-mails. ~3 requests per firm. |
| `groupBy` | `attorney` | `firm` | No | `attorney` | Row shape. Firm mode groups on the firm UUID and forces enrichment on. |
| `includeAttorneys` | boolean | No | `true` | Firm mode: nest attorneys in the firm record. |
| `maxItems` | int 0–10,000 | No | `0` | Max rows; `0` = unlimited (then `maxRequestsPerCrawl` is the ceiling). Free users capped at 10. |
| `maxPagesPerListing` | int 1–50 | No | `3` | Max directory pages per listing (25 attorneys each). |
| `maxRequestsPerCrawl` | int 1–5,000 | No | `2000` | Hard HTTP-request ceiling — the runaway-crawl safety rail. |
| `requestDelaySecs` | num 0–10 | No | `0.5` | Minimum gap between requests; raise on HTTP 429. |
| `listingsInKeyStore` | boolean | No | `true` | Write each fetched directory page to the key-value store. |
| `debugHtml` | boolean | No | `false` | Save raw responses to the key-value store; logs a head excerpt. |
| `proxy` | object | No | off (`useApifyProxy: false`) | Apify Proxy input — only needed if every request is rejected. |

### Output Fields

Default (`groupBy: "attorney"`): **one flat row per attorney**, streamed as soon as the record is final — CSV/Sheets and CRM ready. `groupBy: "firm"`: one row per firm grouped on the firm UUID with `attorney_count`, unioned `practice_areas`/`selection_years`/`awards`, the firm contact block, `emails` and (unless `includeAttorneys: false`) a nested `attorneys` array; unidentified firms fall back to one row per attorney. All 48 fields:

- **Identity & recognition** — `name`, `additional_name`, `job_title`, `tagline`, `photo_url`, `award`, `awards` (firm-mode union), `selection_years`, `selections`, `is_rising_star`.
- **Practice, credentials & bio** — `practice_areas` (`knowsAbout` + listing practice), `focus_areas` (ranked percentages; only when server-rendered), `practice_area_url`, `licensed_since`, `law_school`, `law_school_url`, `bar_activity` (only where server-rendered), `bio`.
- **Contact & location** — `phone`, `website`, `street_address`, `city`, `state`, `zip`, `latitude`, `longitude` (listing JSON-LD `geo`).
- **Firm** — `firm_id` (stable UUID), `firm_name`, `firm_legal_name`, `firm_profile_url`, `firm_website`, `firm_phone`, `firm_emails` (from `findFirmEmails`), `emails` (firm-mode contacts), `firm_id_source` (`firm_id` = UUID, `firm_name` = name-match, `none` = unidentified), `attorney_count`.
- **Social & cross-profile** — `linkedin_url`, `facebook_url`, `twitter_url`, `instagram_url`, `other_profile_urls` (from `sameAs`).
- **Provenance** — `profile_url`, `profile_id` (dedup key), `listing_url`, `source`, `profile_enriched`, `profile_fetch_ok`, `scraped_at`.

**Ready-made views:** **Attorney Overview** (`name`, `firm_name`, `city`, `state`, `practice_areas`, `award`, `selection_years`, `profile_url`), **Contact Details** (`name`, `phone`, `street_address`, `city`, `state`, `zip`, `website`, `firm_website`, `firm_emails`, `linkedin_url`), **Full Attorney Profile** (`name`, `law_school`, `bar_activity`, `focus_areas`, `bio`, `photo_url`, `firm_name`, `firm_id`) — spreadsheet-ready column sets for CSV export.

**Listing index (key-value store):** one entry per directory page under `LISTINGS` (API or `Actor.getValue('LISTINGS')`; off via `"listingsInKeyStore": false`) — e.g. `{"url": "https://attorneys.superlawyers.com/family-law/california/los-angeles/", "isHub": false, "page": 2, "attorneys": 25, "httpStatus": 200, "bytes": 281766, "fetchedAt": "2026-10-04T13:54:52.408Z"}`.

### Example Input And Output

Family-law attorneys in Houston, enriched, 50 rows:

```json
{
  "states": ["TX"],
  "practiceAreas": ["family-law"],
  "city": "houston",
  "enrichProfiles": true,
  "maxItems": 50
}
```

Realistic output row (default attorney shape):

```json
{
  "name": "Jane A. Doe",
  "profile_url": "https://profiles.superlawyers.com/texas/houston/lawyer/jane-a-doe/3b1f2c9d-7a4e-4c2b-9f8d-1e6a5b0c4d72.html",
  "profile_id": "3b1f2c9d-7a4e-4c2b-9f8d-1e6a5b0c4d72",
  "award": "Selected to Super Lawyers",
  "selection_years": ["2023", "2024", "2025"],
  "is_rising_star": false,
  "practice_areas": ["Family Law"],
  "city": "Houston",
  "phone": "+1 713-555-0142",
  "firm_name": "Example Law PLLC",
  "scraped_at": "2026-10-04T13:54:52.408Z"
}
```

### Run the Super Lawyers Scraper From the Apify API, Console or Schedule

- **Apify API** — `POST /v2/acts/ahmed_jasarevic~superlawyers-scraper/runs`, poll, then read dataset items (`run-sync-get-dataset-items` for small jobs).
- **Webhooks** — push new rows into your CRM or warehouse on run-success.
- **Zapier / Make** — available as an Apify integration for no-code sheet appends.
- **Console + schedule** — save the input as an Actor task and run it on a weekly or monthly cron (e.g. `0 6 * * 1`): selections publish annually, so recurring runs keep `selection_years` fresh and feed Store recommendation signals.

### Integrations & Automation

Native Apify integrations only. **Apify API**: start runs, fetch dataset items (`run-sync-get-dataset-items` for small jobs). **Webhooks**: `ACTOR.SUCCEEDED` POSTs new attorney rows into your CRM, Google Sheets or a warehouse. **Zapier / Make**: native Apify modules for no-code appends. **Schedules**: selections publish once a year, so a **quarterly enrichment run** (cron `0 6 * * 1`) plus a fresh run right after each annual selection cycle keeps `selection_years` and `is_rising_star` current for recurring lead-list refreshes.

### Related Actors

- [ahmed_jasarevic/avvo-scraper](https://apify.com/ahmed_jasarevic/avvo-scraper) — attorney leads from the Avvo directory.
- [ahmed_jasarevic/lawyers-justia-scraper](https://apify.com/ahmed_jasarevic/lawyers-justia-scraper) — lawyer profiles from Justia.
- [ahmed_jasarevic/lawyers-findlaw-scraper](https://apify.com/ahmed_jasarevic/lawyers-findlaw-scraper) — FindLaw attorney and firm leads.
- [jungle_synthesizer/superlawyers-scraper](https://apify.com/jungle_synthesizer/superlawyers-scraper) — the most-used competing Super Lawyers scraper.
- [scrapersdelight/superlawyers-attorney-scraper](https://apify.com/scrapersdelight/superlawyers-attorney-scraper) — rival Super Lawyers scraper with selection filters.

### FAQ

#### Does Super Lawyers have a public API or bulk export?

No. `api.superlawyers.com/v1/*` answers `401`/`400`, `?format=json` / `ajax=1` / `/api/*` serve plain HTML, and the Cludo index holds only editorial content; supergood.ai grades Super Lawyers an **F**. Bulk export: run this actor, then export the dataset to CSV/JSON/Excel.

#### Why use this actor instead of the official API?

Because there is no official API — the alternatives are manual browsing on profiles.superlawyers.com or list-vendor data. This actor automates those public pages, de-duplicates on the profile UUID, streams rows during the run, and costs roughly 4x less than browser scraping.

#### What are the alternatives to this actor and to Super Lawyers?

Other US lawyer directories with dedicated Store actors: **Avvo**, **Justia**, **FindLaw** and **Martindale-Hubbell** (first three linked under Related Actors). Comparisons like `martindale-hubbell vs super lawyers vs justia` also surface the big-four ranking brands — Chambers, The Legal 500, Best Lawyers, Super Lawyers — and Avita Group's "Top 9 Best Legal Directories" (Feb 2026) puts Super Lawyers at DA 78. Rival Super Lawyers actors: jungle_synthesizer, scrapersdelight, scrapesage, chimerical_quicklime.

#### How do I scrape Super Lawyers directory data without getting blocked?

Super Lawyers blocks by TLS/JA3 fingerprint, not a JavaScript challenge. The actor impersonates real browsers (`got-scraping`), retries up to 3 times (403 → 200) and throttles itself with `requestDelaySecs`. If every request is rejected, enable the proxy with a residential group; the summary prints `throttled (403/429/503)` counts.

#### What's the best way to get a list of top lawyers for lead generation?

Filter by `states` + `city` + `practiceAreas`, then pick your trade-off: `enrichProfiles: false` gives up to ~125,000 listing rows at 25 attorneys per request; enriched mode adds bio, focus areas, selection years, socials and firm data. `groupBy: "firm"` + `findFirmEmails: true` gives firm-level contact data.

#### Super Lawyers vs Avvo — which is better for finding a lawyer?

Super Lawyers is a peer-selection list — the top 5% of U.S. attorneys by practice area and state, plus Rising Stars — making it the source for award-based segmentation; Avvo is a separate directory best captured with its own scraper (linked above).

#### Who won the Rising Stars list in 2025/2026?

Every selection cycle floods the SERP with law-firm press releases. This actor answers from the source: `is_rising_star`, `selection_years` and `selections` per attorney, filterable by state, city and practice area — re-run each cycle and join on `profile_id` to diff over time.

### SEO Keywords

superlawyers scraper, super lawyers scraper, super lawyers api, super lawyers data export, scrape super lawyers directory data, super lawyers rising stars list, rising stars list 2026, find super lawyers directory search, export super lawyers data to csv, lawyer lead generation, attorney email list building data, personal injury lawyer leads, law firm competitor analysis, legal market research attorney data, attorney data enrichment crm, super lawyers vs avvo, avvo alternatives, martindale-hubbell vs super lawyers vs justia, most accurate legal directory, lawyer ranking sites comparison, super lawyers scraper apify, law firm email finder, super lawyers directory crawl, superlawyers profile data

### For AI Agents & LLM Apps

Purpose: extract structured attorney and law-firm records (48 fields) from the public Super Lawyers directory — by state, city and practice area — for lead lists, CRM enrichment and selection data.

Minimal input (all 16 inputs optional):

```json
{"states": ["CA"], "maxItems": 25}
```

Firm-shape variant (forces `enrichProfiles` on):

```json
{"groupBy": "firm", "states": ["TX"], "maxItems": 20}
```

Key output fields (full 48 in Output Fields): `name`, `profile_url`, `profile_id` (dedup key), `award`, `selection_years`, `is_rising_star`, `practice_areas`, `focus_areas`, `city`, `state`, `phone`, `law_school`, `bio`, `firm_id`, `firm_name`, `firm_emails`, `emails`, `awards`, `attorney_count`, `listing_url`, `scraped_at`. Views: `attorney_overview`, `contact_details`, `full_profile`. Key-value: `LISTINGS` (page index, on by default).

Behavior notes for agents:

- Empty input = 51 jurisdictions x 15 default practice areas, 3 pages per listing, 2,000-request ceiling; `startUrls` / `profileUrls` override `states`, `practiceAreas` and `city`.
- `enrichProfiles` defaults `true` (~1 request, ~1 row, per attorney); `false` gives 25 rows per request and unlocks the ~125,000-row ceiling at `maxRequestsPerCrawl: 5000`.
- `groupBy: "firm"` silently turns `enrichProfiles` on; `findFirmEmails: true` adds ~3 billed requests per firm website.
- Unknown slugs return HTTP 404 and produce **zero rows with no error** (misspellings auto-mapped) — check `last HTTP status` in the summary log.
- Rows stream (an aborted run still flushes rows); records dedupe on `profile_id`. `focus_areas` / `bar_activity` may be empty when JavaScript-served — absence, not error.
- Free accounts are capped at 10 output rows; `maxItems: 0` = unlimited but `maxRequestsPerCrawl` (max 5,000) is the real ceiling. On `429` raise `requestDelaySecs` (max 10); on all-`403` enable `proxy`.

Billing: pay-per-event — `result` $0.0025 per result + `Actor Start` $0.00005 per start.

### Legal & Compliance Disclaimer

- Independent tool — **not affiliated with, endorsed by, sponsored by or connected to** Super Lawyers or its owner, Thomson Reuters.
- Reads only **public, marketing-facing** directory and profile pages on `attorneys.superlawyers.com` / `profiles.superlawyers.com` via plain HTTP (no browser automation, no login) — plus, only when `findFirmEmails` is on, public law-firm pages for e-mails those firms publish themselves.
- The user is solely responsible for compliance with Super Lawyers' terms of service and robots.txt, and with applicable data-protection law (GDPR, CCPA/CPRA).
- Output may include personal contact data (phones, addresses, e-mails, social profiles) and must **not** be used for unsolicited commercial outreach in violation of applicable law (CAN-SPAM, GDPR/PECR, CCPA).

# Actor input Schema

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

Optional. Explicit directory listing URLs (https://attorneys.superlawyers.com/<practice>/<state>/<city>/) or attorney profile URLs (https://profiles.superlawyers.com/<state>/<city>/lawyer/<slug>/<uuid>.html). When set, these override the state / practice-area filters.

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

Optional. Specific profiles.superlawyers.com attorney profile URLs to scrape directly, bypassing the directory crawl.

## `states` (type: `array`):

Filter by U.S. state (2-letter code). Supports all 50 states + DC: AL=Alabama, AK=Alaska, AZ=Arizona, AR=Arkansas, CA=California, CO=Colorado, CT=Connecticut, DE=Delaware, DC=District of Columbia, FL=Florida, GA=Georgia, HI=Hawaii, ID=Idaho, IL=Illinois, IN=Indiana, IA=Iowa, KS=Kansas, KY=Kentucky, LA=Louisiana, ME=Maine, MD=Maryland, MA=Massachusetts, MI=Michigan, MN=Minnesota, MS=Mississippi, MO=Missouri, MT=Montana, NE=Nebraska, NV=Nevada, NH=New Hampshire, NJ=New Jersey, NM=New Mexico, NY=New York, NC=North Carolina, ND=North Dakota, OH=Ohio, OK=Oklahoma, OR=Oregon, PA=Pennsylvania, RI=Rhode Island, SC=South Carolina, SD=South Dakota, TN=Tennessee, TX=Texas, UT=Utah, VT=Vermont, VA=Virginia, WA=Washington, WV=West Virginia, WI=Wisconsin, WY=Wyoming. Leave empty to crawl every state.

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

Filter by practice-area slug, exactly as SuperLawyers serves it (see /gsm/pa.xml.gz for all 140). Correct slugs include: employment-and-labor, personal-injury-plaintiff, business-litigation, family-law, divorce, criminal-defense, immigration, bankruptcy, medical-malpractice, intellectual-property, civil-rights, mergers-and-acquisitions, dui-dwi, workers-compensation, real-estate, estate-planning-and-probate, tax, health-care, securities-and-corporate-finance, class-action-and-mass-torts, products-liability, construction-litigation, environmental, appellate, alternative-dispute-resolution, white-collar-crimes, drug-and-alcohol-violations, landlord-and-tenant, patents, trademarks, business-and-corporate. Common misspellings (tax-law, real-estate-law, mergers-acquisitions, product-liability, appeals, ...) are accepted and mapped to the real slug; anything else that does not exist on the site returns HTTP 404 and yields no rows. Leave empty to crawl a default set of 15 major areas.

## `city` (type: `string`):

Filter by city using the SuperLawyers URL slug, e.g. los-angeles or new-york. Combine with States for precise targeting.

## `enrichProfiles` (type: `boolean`):

Visit each attorney profile page to add biography, practice and focus areas, selection years, bar activity, social links, firm website and firm ID. Recommended — listing pages only carry contact + firm data.

## `findFirmEmails` (type: `boolean`):

Additionally crawl each law firm's own website (homepage + contact pages) and extract published contact e-mail addresses. Adds extra requests per firm.

## `groupBy` (type: `string`):

'attorney' = one row per attorney. 'firm' = one row per law firm, grouped on SuperLawyers' own firm UUID, with a nested attorneys array. Firm output requires profile enrichment and turns it on automatically.

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

With firm output, nest each firm's attorneys inside its record. Turn off for smaller records when only firm-level fields are needed.

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

Maximum number of output rows (attorneys, or firms in firm mode). 0 = unlimited (the request ceiling is `maxRequestsPerCrawl`). Capped for free users.

## `maxPagesPerListing` (type: `integer`):

Maximum directory result pages to follow per practice/state/city listing (via <link rel="next">). Each page yields up to 25 attorneys.

## `maxRequestsPerCrawl` (type: `integer`):

Hard ceiling on HTTP requests for this run. A safety rail that prevents runaway crawls.

## `debugHtml` (type: `boolean`):

Save each raw HTML response to the key-value store and log a short excerpt. Useful for diagnosing Cloudflare interstitials; leave off for normal runs.

## `requestDelaySecs` (type: `number`):

Minimum gap between two requests to the site. SuperLawyers answers a fast burst with HTTP 429 for the whole IP; raise this if requests start failing with 429.

## `listingsInKeyStore` (type: `boolean`):

Write every directory page the crawl fetched (URL, page number, attorney count, HTTP status, bytes) to the key-value store under the key `LISTINGS`. Read it separately from the attorney dataset.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [],
  "profileUrls": [],
  "states": [
    "CA"
  ],
  "practiceAreas": [],
  "city": "",
  "enrichProfiles": true,
  "findFirmEmails": false,
  "groupBy": "attorney",
  "includeAttorneys": true,
  "maxItems": 100,
  "maxPagesPerListing": 3,
  "maxRequestsPerCrawl": 2000,
  "debugHtml": false,
  "requestDelaySecs": 0.5,
  "listingsInKeyStore": true,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [],
    "profileUrls": [],
    "states": [
        "CA"
    ],
    "practiceAreas": [],
    "city": "",
    "groupBy": "attorney",
    "maxItems": 100,
    "maxPagesPerListing": 3,
    "maxRequestsPerCrawl": 2000,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "startUrls": [],
    "profileUrls": [],
    "states": ["CA"],
    "practiceAreas": [],
    "city": "",
    "groupBy": "attorney",
    "maxItems": 100,
    "maxPagesPerListing": 3,
    "maxRequestsPerCrawl": 2000,
    "proxy": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [],
  "profileUrls": [],
  "states": [
    "CA"
  ],
  "practiceAreas": [],
  "city": "",
  "groupBy": "attorney",
  "maxItems": 100,
  "maxPagesPerListing": 3,
  "maxRequestsPerCrawl": 2000,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/superlawyers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/superlawyers-scraper"
        }
    }
}
```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Qnbdtqiw5YFDneOHR/builds/6oepxtH4C619JbIaC/openapi.json