Avvo Data API: Extract Structured JSON in 2026

This guide covers extracting publicly accessible data. Always review a site's robots.txt and Terms of Service before scraping.

TL;DR

Use AlterLab's Extract API to get structured JSON from Avvo pages. Define a schema for fields like name and description, POST the URL and schema to /v1/extract, and receive validated typed output—no HTML parsing required. This approach handles anti-bot measures automatically and scales for data pipelines.

Why use Avvo data?

Avvo hosts one of the largest public directories of legal professionals. Engineering teams extract this data for:

• Training NLP models on domain-specific professional bios
• Building competitive intelligence feeds for legal tech platforms
• Enriching CRM systems with verified attorney contact details Unlike social media profiles, Avvo data focuses on professional credentials, making it valuable for B2B applications requiring verified professional information.

What data can you extract?

Avvo's public lawyer profiles contain these consistently available fields:

• name: Full attorney name (e.g., "Jane Smith")
• description: Professional bio snippet (1-2 sentences)
• category: Practice area (e.g., "Family Law", "Personal Injury")
• url: Direct profile URL on avvo.com
• contact: Phone number or contact form link (when publicly displayed) These fields appear in structured sections of profile pages, making them ideal for schema-based extraction. AlterLab's Extract API returns them as typed JSON matching your defined schema—eliminating regex fragility.

The extraction approach

Direct HTTP requests to Avvo face significant hurdles:

• JavaScript-dependent content rendering
• Rotating anti-bot challenges (Cloudflare Turnstile)
• Frequent HTML structure changes breaking CSS selectors
• IP-based rate limiting on repeated requests Building and maintaining a custom scraper requires constant updates to handle these layers. A data API like AlterLab abstracts this complexity: it manages headless browsers, proxy rotation, and challenge solving while delivering clean structured output. You focus on defining what data you need, not how to retrieve it.

Quick start with AlterLab Extract API

Begin by installing the AlterLab Python client. See the getting started guide for setup details.

Here's a complete example extracting structured data from an Avvo lawyer profile:

from alterlab import AlterLabSync

client = AlterLabSync("YOUR_API_KEY")

schema = {
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "The attorney's full name"
    },
    "description": {
      "type": "string",
      "description": "Professional bio summary"
    },
    "category": {
      "type": "string",
      "description": "Primary practice area"
    },
    "url": {
      "type": "string",
      "description": "Canonical Avvo profile URL"
    },
    "contact": {
      "type": "string",
      "description": "Publicly listed phone number"
    }
  }
}

result = client.scrape(
    url="https://www.avvo.com/attorneys/jane-smith-12345",
    extraction_schema=schema,
)
print(result["filtered_content"])

Line highlighting explanation: Lines 5-12 define the JSON schema specifying exactly which fields to extract and their types. The AlterLab client handles the API call, anti-bot evasion, and schema validation.

Equivalent cURL request:

curl -X POST https://api.alterlab.io/v1/extract \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.avvo.com/attorneys/jane-smith-12345",
    "schema": {
      "properties": {
        "name": {"type": "string"},
        "description": {"type": "string"},
        "category": {"type": "string"}
      }
    }
  }'

This returns a JSON object containing only the requested fields with proper types—no additional parsing needed.

Define your schema

The Extract API uses JSON Schema to validate and structure output. Key benefits:

• Type safety: Ensures name is always a string, never null or object
• Field selection: Only requested properties appear in output
• Default values: Add "default": "N/A" for missing fields
• Nested objects: Extract structured sub-data (e.g., address components)

For Avvo profiles, a robust schema might include:

{
  "type": "object",
  "properties": {
    "name": {"type": "string"},
    "description": {"type": "string", "maxLength": 500},
    "category": {"type": "string", "enum": ["Family Law", "Criminal Defense", "Personal Injury"]},
    "url": {"type": "string", "format": "uri"},
    "contact": {"type": ["string", "null"]}
  },
  "required": ["name", "url"]
}

AlterLab validates extracted data against this schema before returning it. If a field doesn't match (e.g., category contains unexpected text), the API returns a validation error—preventing malformed data from entering your pipeline.

Handle pagination and scale

For bulk extraction of Avvo directories (e.g., all lawyers in a city):

1. Discover listing pages: Use search URLs like https://www.avvo.com/lawyers/new_york_ny/all
2. Extract profile links: First pass gets url fields from search results
3. Batch profile requests: Process 50-100 profiles concurrently using async jobs
4. Respect rate limits: AlterLab automatically adjusts request timing based on response headers

Example async pattern with Python:

from alterlab import AlterLab
import asyncio

async def extract_profile(client, profile_url):
    schema = {"properties": {"name": {"type": "string"}, "category": {"type": "string"}}}
    return await client.scrape(url=profile_url, extraction_schema=schema)

async def main():
    client = AlterLab("YOUR_API_KEY")
    
    # Get list of profile URLs from search results (simplified)
    search_result = client.scrape(
        url="https://www.avvo.com/lawyers/los_angeles_ca/all",
        extraction_schema={"properties": {"results": {"type": "array", "items": {"type": "string"}}}}
    )
    profile_urls = search_result["filtered_content"]["results"][:100]  # Limit for demo
    
    # Process concurrently with rate limit awareness
    tasks = [extract_profile(client, url) for url in profile_urls]
    results = await asyncio.gather(*tasks)
    
    for i, res in enumerate(results):
        print(f"Profile {i+1}: {res.data}")

asyncio.run(main())

This approach processes 100 profiles in parallel while AlterLab manages concurrency limits and retry logic. For ongoing monitoring, combine with AlterLab's scheduling feature to run extractions nightly.

Key takeaways

• Schema-first design: Define exactly what data you need before making requests
• Zero parsing overhead: Receive validated JSON—no BeautifulSoup or regex required
• Built-in compliance: AlterLab handles robots.txt awareness and rate limiting
• Cost efficiency: Pay only for successful extractions (see pricing)
• Pipeline ready: Output integrates directly into ETL workflows and ML training

Start with a single profile extraction using the Python example above. Scale to thousands of requests per day with automatic infrastructure management—no headless browser maintenance or proxy rotation to worry about. Your data pipeline