Lavery APIlavery.ca ↗
Access Lavery's full lawyer directory via API. List all professionals with pagination or fetch individual profiles with practice areas, bar admissions, and contact details.
What is the Lavery API?
The Lavery API provides access to the complete lawyer and legal professional directory of Lavery, Québec's largest independent law firm, across 2 endpoints. Use list_lawyers to page through all team members returning name, title, offices, and profile slugs, then call get_lawyer_details with a slug to retrieve a full profile including practice areas, bar admission year and jurisdiction, contact details, and languages spoken.
curl -X GET 'https://api.parse.bot/scraper/a3b36e6d-dbd8-4154-a99e-9027f8e0a78f/list_lawyers?page=1' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace lavery-ca-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Lavery law firm team directory — browse and drill into profiles."""
from parse_apis.lavery_ca_api import Lavery, LawyerNotFound
client = Lavery()
# List team members across the firm, capped to 5 total items.
for summary in client.lawyer_summaries.list(limit=5):
print(summary.name, "-", summary.title, "|", ", ".join(summary.offices))
# Drill into the first lawyer's full profile via the summary→detail navigation.
first = client.lawyer_summaries.list(limit=1).first()
if first is not None:
lawyer = first.details()
print(f"\n{lawyer.name} ({lawyer.title})")
print(f" Bar admission: {lawyer.bar_admission}")
print(f" Practices: {', '.join(lawyer.practices)}")
print(f" Languages: {', '.join(lawyer.languages)}")
print(f" Phone: {lawyer.phone} Email: {lawyer.email}")
# Point lookup by slug discovered from the listing above.
if first is not None:
try:
detail = client.lawyers.get(lawyer_slug=first.lawyer_slug)
print(f"\nLooked up: {detail.name}, offices: {', '.join(detail.offices)}")
except LawyerNotFound as e:
print(f"Lawyer not found: {e.message}")
print("\nexercised: lawyer_summaries.list / details / lawyers.get")
Lists lawyers and legal professionals from the Lavery team page with pagination. Returns 16 results per page including name, title, offices, profile URL, and a slug for use with get_lawyer_details. The team page shows all professionals alphabetically.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number for pagination. Each page returns up to 16 lawyers. |
{
"type": "object",
"fields": {
"page": "current page number",
"lawyers": "array of lawyer objects with name, title, offices, profile_url, and lawyer_slug",
"has_next": "whether there is a next page",
"total_pages": "total number of pages available"
},
"sample": {
"page": 1,
"lawyers": [
{
"name": "Jean-Philippe Abraham",
"title": "Senior Associate",
"offices": [
"Québec",
"Trois-Rivieres"
],
"lawyer_slug": "2850-jean-philippe-abraham",
"profile_url": "https://www.lavery.ca/en/lawyers-paralegals-notaries-lavery/2850-jean-philippe-abraham.html?page=1"
},
{
"name": "Asma Amari",
"title": "Student",
"offices": [
"Montréal"
],
"lawyer_slug": "3868-asma-amari",
"profile_url": "https://www.lavery.ca/en/lawyers-paralegals-notaries-lavery/3868-asma-amari.html?page=1"
}
],
"has_next": true,
"total_pages": 4
}
}About the Lavery API
Endpoints and Data Coverage
The API exposes two endpoints. list_lawyers returns a paginated index of Lavery professionals — up to 16 records per page — with each record containing name, title, offices, profile_url, and lawyer_slug. The has_next and total_pages fields allow you to walk the full directory programmatically without guessing how many iterations are needed.
Individual Profile Data
get_lawyer_details accepts a lawyer_slug (e.g. 1686-arianne-arguin) obtained from list_lawyers and returns the full profile object. Fields include email, phone, title (such as Partner, Senior Associate, or Lawyer), offices (array), languages (array), practices (array of practice area names), and bar_admission (jurisdiction and year, e.g. Québec, 2023). This makes it straightforward to filter the team by admission year, office location, or practice area once you have the data in hand.
Pagination and Identifiers
The page parameter on list_lawyers is optional and defaults to the first page. The lawyer_slug field is stable across calls and is the required key for get_lawyer_details. There is no search or filter parameter built into list_lawyers — results are returned alphabetically and filtering must be done client-side after retrieval.
The Lavery API is a managed, monitored endpoint for lavery.ca — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when lavery.ca changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official lavery.ca API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a searchable directory of Lavery lawyers filterable by practice area using the
practicesfield fromget_lawyer_details. - Aggregate bar admission data across the full team to analyze hiring trends by year and jurisdiction.
- Map lawyer distribution across offices using the
officesarray returned by both endpoints. - Enrich a CRM with verified contact details —
emailandphone— for Lavery professionals. - Identify multilingual lawyers for matters requiring specific language capabilities using the
languagesfield. - Monitor team changes over time by periodically pulling
list_lawyersand comparing name and title fields. - Generate a structured dataset of Québec legal professionals segmented by seniority level from the
titlefield.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Lavery offer an official public developer API?+
What does `get_lawyer_details` return beyond what `list_lawyers` shows?+
list_lawyers returns name, title, offices, profile_url, and lawyer_slug. get_lawyer_details adds email, phone, languages, practices (array of practice area names), and bar_admission (jurisdiction and year). The slug from list_lawyers is required to call get_lawyer_details.Can I filter or search lawyers by practice area or office directly in the API?+
list_lawyers returns all professionals alphabetically with no filter or search parameters. Filtering by offices, practices, or other criteria must be done client-side after fetching the data. You can fork this API on Parse and revise it to add a filter parameter endpoint.Does the API cover publications, case results, or biographical text from individual profiles?+
How does pagination work and how many lawyers are in the directory?+
list_lawyers returns up to 16 results. The response includes total_pages and has_next so you can determine exactly how many pages exist. Iterate from page 1 through total_pages to retrieve the full directory.