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, InputNotFound
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 InputNotFound 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 roster, alphabetically by surname, 16 per site page. Three ways to call it: a single page (page, default 1); several pages in one call (pages, a range like '1-4' or a list like '1,3,5', at most 10 pages fetched per call, one site request per page, the rest reported through next_page); or the whole roster in a single request (all=true, about 280 professionals unfiltered). The roster can be narrowed with the same three filters the site's team directory offers — office, profession and practice_area — which combine (AND) and apply in every mode; each accepts either the site's dropdown option code or its exact English option label (case-insensitive). A code is applied in the one request; a label costs one extra request to resolve it against the site's dropdown. The filters actually applied are echoed in filters as code/label pairs. A filter value the site does not recognise is rejected as invalid input (not found) rather than silently returning the unfiltered roster; a recognised combination that matches nobody returns an empty lawyers array. Each lawyer carries name, title, offices, profile_url and the lawyer_slug consumed by get_lawyer_details. pages_fetched lists the site pages actually retrieved (empty in all mode); has_next/next_page describe the continuation the site's own pagination offers after the last fetched page (or the first page left unfetched by the 10-page cap). total_pages is the highest page number the site's pagination linked from the fetched pages; the site only shows a sliding window of about four page numbers, so in page mode it is a lower bound, while in all mode it is the exact number of 16-item pages the (filtered) roster spans. A page past the end of the roster returns an empty lawyers array with has_next false. A page or pages value that is not a positive integer, range or list is rejected as invalid input.
| Param | Type | Description |
|---|---|---|
| all | boolean | When true, returns the entire (filtered) roster in one request and ignores page and pages. |
| page | integer | Single site page number to fetch (1-based). Ignored when pages or all is supplied. |
| pages | string | Several site pages in one call: an inclusive range like '1-4' or a comma-separated list like '1,3,5' (both forms may be mixed). At most 10 pages are fetched per call; the first page left unfetched is returned in next_page. Takes precedence over page. |
| office | string | Office location filter: the site's office dropdown code (see Office) or its label, e.g. 'Sherbrooke'. Omit for all offices. |
| profession | string | Profession filter: the site's profession dropdown code (see Profession) or its label, e.g. 'Notary'. Omit for all professions. |
| practice_area | string | Practice area filter: the site's practice-area dropdown code (two numbers joined by a hyphen, e.g. '2-289') or its exact English label, e.g. 'Construction'. About 80 areas are offered, including patent technical fields; the applied label is echoed in filters.practice_area.label. Omit for all practice areas. |
{
"type": "object",
"fields": {
"page": "first site page number fetched (1 in all mode)",
"filters": "object keyed by the filters applied (office, profession, practice_area), each {code, label} as the site's dropdown shows it; empty object when no filter was given",
"lawyers": "array of lawyer objects with name, title, offices (array of office city names), profile_url, and lawyer_slug",
"has_next": "whether the site offers a further page after the last fetched page (or pages were left unfetched by the 10-page cap)",
"all_pages": "true when the full roster was returned in one call (all=true)",
"next_page": "page number to request next when has_next is true, otherwise null",
"total_pages": "highest page number linked from the fetched pages' pagination (lower bound in page mode; exact in all mode); 0 when the fetched page was past the end or the filters matched nobody",
"pages_fetched": "array of site page numbers actually retrieved in this call; empty in all mode"
},
"sample": {
"data": {
"page": 1,
"filters": {
"office": {
"code": "3",
"label": "Sherbrooke"
}
},
"lawyers": [
{
"name": "Arianne Arguin",
"title": "Lawyer",
"offices": [
"Sherbrooke"
],
"lawyer_slug": "1686-arianne-arguin",
"profile_url": "https://www.lavery.ca/en/lawyers-paralegals-notaries-lavery/1686-arianne-arguin.html?BureauId=3&page=1"
},
{
"name": "Annabelle Barbeau",
"title": "Student",
"offices": [
"Sherbrooke"
],
"lawyer_slug": "3857-annabelle-barbeau",
"profile_url": "https://www.lavery.ca/en/lawyers-paralegals-notaries-lavery/3857-annabelle-barbeau.html?BureauId=3&page=1"
}
],
"has_next": true,
"all_pages": false,
"next_page": 2,
"total_pages": 3,
"pages_fetched": [
1
]
},
"status": "success"
}
}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.