Describe a law firm with three kinds of entries: LegalService for the firm, Person for each lawyer, and one more LegalService entry for every physical office. Connect them with stable @id values and the properties employee, worksFor, memberOf, location and parentOrganization.

That structure fits a solo practice and a firm with several offices. It also settles the common question about Attorney: schema.org marks that type as deprecated in favor of LegalService, so a lawyer's page uses Person instead.

Start by listing the firm, each office and each lawyer, and confirm that every one appears on a visible page. Accurate markup describes those pages. It does not promise a rich result, a ranking, a knowledge panel or an AI citation.

Key takeaways

  1. Firm and office typeUse LegalService for the firm and for each physical office, and give every entry its own stable @id.
  2. Lawyers use PersonDescribe each lawyer with Person and connect them to the firm using worksFor, memberOf and the firm's employee property.
  3. Attorney is deprecatedSchema.org marks Attorney as deprecated and calls LegalService more inclusive and less ambiguous, so new markup uses LegalService.
  4. Match the visible pageMarkup must reflect what visitors can see. Leave out invented ratings, case results, awards, certifications and self-controlled review markup.
  5. Google feature scopeGoogle lists LocalBusiness, Organization and ProfilePage as features, not LegalService. LocalBusiness requires name and address for each location.
  6. No guaranteesAccurate markup does not guarantee a rich result, ranking, knowledge panel or AI citation on any provider.

Use LegalService for the firm and for each office

LegalService is the schema.org type for a business that provides legal services, advice and representation, which includes law firms. Schema.org defines it as both an Organization and a LocalBusiness, so one type covers the firm's identity and its local presence.

Attorney is a subtype of LegalService, and schema.org marks it deprecated, calling LegalService more inclusive and less ambiguous. Deprecated is not the same as deleted: the type is still in the vocabulary, but new markup should use LegalService.

Lawyers often reach for Attorney on a profile page because the word matches the job. In schema.org, though, Attorney is a business-service type, so it describes a practice and not an individual. The next section covers the type for the person.

The difference between LegalService and LocalBusiness is one of specificity. Google says to define each physical location as a LocalBusiness subtype and to use the most specific subtype that applies, and LegalService is the most specific one for a law firm. The Schema Nova local business guide covers the shared properties in more detail.

Describe each lawyer with Person

Use Person for an individual lawyer, with one entry for each lawyer who has a profile page. Suitable properties from schema.org Person include:

  • name, url and image
  • jobTitle and description
  • worksFor and memberOf, pointing to the firm
  • knowsAbout and knowsLanguage
  • sameAs, for profile pages that clearly identify the same person
  • telephone and email, only when the page displays them

Link the lawyer to the firm with worksFor or memberOf, and let the firm point back with employee. Fill knowsAbout only with practice areas the profile page states in its own text. A practice area that appears in markup but nowhere on the page is a hidden claim.

A woman in a charcoal blazer holds a printed staff page and points a pen at an open laptop at a conference table in a small law office
Figure 1. Compare each lawyer's visible profile page with the Person entry before publishing it.

The person and author schema guide explains how a Person entry behaves elsewhere on a site, and the entity guide on sameAs covers when an outside profile link is a good fit for a lawyer.

Build the firm and lawyer entries together

The fictional firm below uses example.com and reserved values. It is a connected graph: the firm lists its employee and its offices by @id, and the lawyer points back to the firm. Replace every value with text that appears on the matching page, and keep each @id unchanged once it is published so that other entries can keep pointing to it.

json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "LegalService",
      "@id": "https://example.com/#firm",
      "name": "Harbor & Pine Law",
      "url": "https://example.com/",
      "logo": "https://example.com/images/logo.png",
      "telephone": "+1-555-010-1000",
      "email": "hello@example.com",
      "areaServed": { "@type": "AdministrativeArea", "name": "Example State" },
      "employee": { "@id": "https://example.com/attorneys/maya-chen/#person" },
      "location": [
        { "@id": "https://example.com/offices/river-city/#office" },
        { "@id": "https://example.com/offices/lake-town/#office" }
      ],
      "sameAs": ["https://profiles.example.org/harbor-pine-law"]
    },
    {
      "@type": "Person",
      "@id": "https://example.com/attorneys/maya-chen/#person",
      "name": "Maya Chen",
      "url": "https://example.com/attorneys/maya-chen/",
      "image": "https://example.com/images/maya-chen.jpg",
      "jobTitle": "Managing Attorney",
      "description": "Maya Chen represents clients in business litigation and employment matters.",
      "worksFor": { "@id": "https://example.com/#firm" },
      "memberOf": { "@id": "https://example.com/#firm" },
      "knowsAbout": ["Business litigation", "Employment law"],
      "knowsLanguage": ["en", "es"],
      "sameAs": ["https://profiles.example.org/maya-chen"]
    }
  ]
}

Put JSON-LD in a <script type="application/ld+json"> element on the page that describes the entity. The W3C JSON-LD 1.1 specification defines @context, @type, @id and the graph relationships used here. The firm entry belongs on the home page or an about page, and the lawyer entry belongs on that lawyer's profile page. The JSON-LD graph guide explains how entries in one block refer to each other.

html
<script type="application/ld+json">
  { "@context": "https://schema.org", "@graph": [ ... ] }
</script>

Replace the ellipsis with the JSON above. The snippet only shows where the block sits; the real element must contain complete JSON.

Add one LegalService entry for each office

Create a separate LegalService entry for each physical office. Google's Local Business documentation says to define each location as a LocalBusiness type, so one generic office entry that lists every address does not match what Google describes. Each office gets its own @id, its own page URL, its own address and, where it applies, its own telephone number and opening hours.

json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "LegalService",
      "@id": "https://example.com/offices/river-city/#office",
      "name": "Harbor & Pine Law - River City Office",
      "url": "https://example.com/offices/river-city/",
      "parentOrganization": { "@id": "https://example.com/#firm" },
      "branchCode": "RIVER-CITY",
      "telephone": "+1-555-010-1001",
      "address": {
        "@type": "PostalAddress",
        "streetAddress": "100 Example Avenue, Suite 400",
        "addressLocality": "River City",
        "addressRegion": "EX",
        "postalCode": "12345",
        "addressCountry": "US"
      },
      "openingHoursSpecification": {
        "@type": "OpeningHoursSpecification",
        "dayOfWeek": ["https://schema.org/Monday", "https://schema.org/Tuesday", "https://schema.org/Wednesday", "https://schema.org/Thursday", "https://schema.org/Friday"],
        "opens": "09:00",
        "closes": "17:00"
      }
    },
    {
      "@type": "LegalService",
      "@id": "https://example.com/offices/lake-town/#office",
      "name": "Harbor & Pine Law - Lake Town Office",
      "url": "https://example.com/offices/lake-town/",
      "parentOrganization": { "@id": "https://example.com/#firm" },
      "branchCode": "LAKE-TOWN",
      "telephone": "+1-555-010-1002",
      "address": {
        "@type": "PostalAddress",
        "streetAddress": "200 Sample Street, Floor 2",
        "addressLocality": "Lake Town",
        "addressRegion": "EX",
        "postalCode": "12346",
        "addressCountry": "US"
      }
    }
  ]
}

The firm reaches its offices through location, and each office reaches the firm through parentOrganization. Use the exact business name the visitor sees on that office page. Use branchCode only when the firm already has an internal code for the office. The second office here leaves out hours because the example assumes that page does not display them; add openingHoursSpecification only when the page does.

An illustration of two office cards with pin, phone and clock icons, each linked to a markup panel and both linked to one larger firm card
Figure 2. Each office is its own entry, connected to the firm through parentOrganization and location.

Some firms have no public visitor location. In that case, do not invent a street address. Use the organization-level details that apply to the firm, and state the service area in visible page text.

The multiple locations guide goes further into parent and branch patterns. For the address, telephone and hours fields, the Schema Nova local business schema generator can produce JSON-LD to compare with the office entries above.

Add ProfilePage when the page is about one lawyer

If a page is mainly about one lawyer, add a separate ProfilePage object whose mainEntity is that lawyer. Use the same @id for the Person as in the graph, so both blocks describe one entity.

json
{
  "@context": "https://schema.org",
  "@type": "ProfilePage",
  "@id": "https://example.com/attorneys/maya-chen/#profile",
  "url": "https://example.com/attorneys/maya-chen/",
  "mainEntity": {
    "@id": "https://example.com/attorneys/maya-chen/#person",
    "@type": "Person",
    "name": "Maya Chen",
    "url": "https://example.com/attorneys/maya-chen/",
    "jobTitle": "Managing Attorney",
    "worksFor": { "@id": "https://example.com/#firm" }
  }
}

Google's ProfilePage documentation requires mainEntity, and the Person or Organization used there must have a name. It recommends description and image where they apply, and the markup should match the page. A page that lists the whole team is not a profile of one lawyer, so leave ProfilePage for pages with a single subject.

Know what Google supports for law firms

Schema.org vocabulary and Google feature eligibility are separate checks. Schema.org defines the types and properties, and Google decides which ones it currently uses for Search features. The Google structured data introduction draws the same line.

Google's structured-data gallery lists LocalBusiness, Organization and ProfilePage as features, and does not list LegalService or Attorney as separate Search features. A LegalService entry is still valid schema.org markup. Google's feature requirements apply to the physical location through its LocalBusiness documentation, which requires name and address and recommends telephone, url, geo and openingHoursSpecification.

Google's required properties for a firm or office come from its Local Business documentation, because LegalService is a LocalBusiness subtype. LegalService and Attorney have no extra Google requirements of their own.

Google's documentation updates page records that FAQ rich results stopped appearing in Google Search beginning May 7, 2026, and that the FAQ feature documentation was removed in June 2026. FAQPage stays valid schema.org vocabulary, but it is no longer a Google FAQ rich-result opportunity for a law firm. The rich results guide explains the difference between valid markup and a displayed result.

Keep ratings, results and awards out of the markup

Google's general structured data guidelines say structured data must represent visible page content accurately, and they prohibit fake, misleading, irrelevant or hidden content. For a law firm, that rule covers the claims that legal advertising rules also tend to watch. Do not add:

  • invented ratings or review counts
  • case results the firm cannot substantiate
  • "best lawyer" or "top firm" claims without support
  • board certifications or awards the lawyer has not earned
  • practice areas the page does not state
  • clients, offices or affiliations that do not exist
  • legal outcomes presented as typical or guaranteed

Leave aggregateRating and review markup off testimonials the firm controls. Google's review snippet documentation excludes self-serving reviews for an organization's own LocalBusiness or organization pages. The review schema guide explains where review markup is allowed.

A safe rule is to leave a claim out of the markup when a visitor cannot see it on the page or the firm cannot substantiate it. Because attorney advertising rules differ by jurisdiction, have the firm's responsible attorney review claims, awards, testimonials and result statements against the bar rules that apply before the markup goes live.

Bing reads JSON-LD, so the same firm, lawyer and office markup serves both engines, and some other search services draw on Bing results (Bing structured data documentation). Copilot's public web search may fetch information from Bing, so keep the pages crawlable (Microsoft Copilot web search documentation).

To let ChatGPT search and Perplexity reach the pages, allow OAI-SearchBot and PerplexityBot in robots.txt (OpenAI crawler documentation and Perplexity's crawler guide). Publish visible, accurate, consistently named entities in crawlable HTML and JSON-LD. See whether AI systems use schema markup for the full comparison.

Add the markup on your platform

The route depends on the platform, and an existing SEO plugin, theme or app may already output firm or organization markup. Look at the rendered page first, then decide whether to extend that output or replace it, so the page does not describe the same firm twice with different details.

For WordPress, Shopify, Squarespace, Webflow, HubSpot, Wix and Next.js, add the JSON-LD through the platform's supported custom-code or structured data mechanism, then test the rendered public page and not only the editor. Wix publishes a structured data troubleshooting article covering its JSON-LD syntax constraints and validation advice. The WordPress guide and the guide to adding schema markup walk through the common routes.

Test the markup and keep it current

Run the same page through more than one check, because each one answers a different question. Paste the adapted JSON-LD into the Schema.org Validator for vocabulary, and run the published URL through Google's Rich Results Test for documented feature eligibility. The Schema Nova schema validator can check the JSON syntax first.

Bing Webmaster Tools provides a URL Inspection tool with a Markup card for JSON-LD and other formats. Yandex Webmaster provides a semantic markup validator. Apple provides an App Search API validation tool, described in its web markup documentation.

A passing result means the syntax or the documented requirements are met. It does not guarantee display, ranking, traffic or an AI citation. After publishing, keep names, addresses, telephone numbers, lawyer roles, practice areas and office details current, and update the markup in the same edit as the visible page.

Setup steps for law firm markup

  1. Choose the entitiesList the firm, each office, each lawyer and any profile page, and confirm each one appears as visible content.
  2. Assign types and IDsUse LegalService for the firm and offices, Person for lawyers, and give every entity a stable @id.
  3. Connect entitiesLink them with employee, worksFor, memberOf, location and parentOrganization.
  4. Add JSON-LDPlace a script block on each page that describes the entity, with values copied from the visible text.
  5. Validate and inspectRun the Schema.org Validator, Rich Results Test, and Bing, Yandex or Apple tools on the published URL.
  6. Update with the pageEdit the markup whenever names, addresses, phones, roles, practice areas or office details change.

Questions people ask

Should a law firm use Attorney schema?

No. Schema.org marks Attorney as deprecated and recommends the broader LegalService. Use LegalService for the firm and each office, and Person for each lawyer.

Does LegalService create a Google rich result?

Google's structured-data gallery does not list LegalService or Attorney as separate Search features. The type is still valid schema.org markup, and Google's LocalBusiness requirements of name and address apply to each physical location.

Can a law firm add ratings to its own schema?

Not for testimonials the firm controls. Google's review documentation excludes self-serving reviews on a firm's own LocalBusiness or organization pages, and ratings that visitors cannot see or the firm cannot substantiate should stay out of the markup.

Does structured data guarantee rankings?

No. Google says structured data can improve machine understanding and eligibility for supported displays, but it does not guarantee a rich result, ranking improvement, traffic, AI citation or knowledge panel. Bing says markup does not guarantee a visual result, Yandex says valid markup may still need indexing and moderation, and OpenAI says crawler access does not guarantee placement.

How do I mark up more than one office?

Create one LegalService entry for each physical office, each with its own @id, address and page URL. Connect them to the firm with parentOrganization and the firm's location property.

Quick check

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

Which type should describe the firm in new markup?

Question 2 of 3

A page is mainly about one lawyer. Which pairing fits?

Question 3 of 3

Can the firm add a five-star rating it created itself?

Glossary

Select a term to see its definition.

JSON-LD. A JSON syntax for linked data, placed in a script element on the page.