SQL language and profile schema

This is the complete filter reference for SQL search. Put these predicates in sql_filter. The optional query parameter ranks the results; omit it for a filters-only search.

The SQL schema is mostly a subset of the returned profile schema. Only fields usable in SQL are listed here, including fields that support presence checks. Some filter-only helpers are also available. Other fields may appear in returned profiles without being available for filtering.

Profile-shaped SQL schema

One indexed document represents one person. SQL exposes grouped experiences like the returned Pearch profile: experiences[] contains company_info and company_roles[]. Company attributes belong to the company group; titles, dates, durations, and role locations belong to company_roles.

{
  "summary": "Backend engineer",
  "inferred_languages": [{"language": "English"}],
  "experiences": [{
    "company_info": {"domain": "stripe.com", "num_employees": 1000},
    "company_roles": [{"title": "Engineer", "start_date": "2022-01-01", "end_date": null}]
  }]
}

📘

Profile shape, indexed values

Field names and nesting follow the response where possible. SQL still operates on indexed values, not the formatted response JSON. summary maps to indexed summary text and inferred_languages to indexed inferred languages. Dates use the documented SQL types. Contact values remain unavailable. A response-only field absent from these tables cannot be filtered.

Company metadata in the current index is copied onto role records. A company-and-role predicate tests the metadata copy attached to that matching role. When those copies disagree, the company metadata displayed in the response can come from a different role. This interface does not normalize conflicting company snapshots or guarantee equality with filtering the final formatted JSON.

Supported SQL

Use a restricted BigQuery-style predicate, not an arbitrary query. A complete top-level SELECT, ORDER BY, joins to external tables, or SQL writes are not accepted. SELECT is permitted inside the supported EXISTS and aggregate forms shown here.

Use single-quoted SQL strings, numeric literals for numbers, and TRUE/FALSE for booleans. Escape apostrophes by doubling them: first_name = 'O''Brien'. Use IS NULL and IS NOT NULL for missing values; field = NULL is not a presence test.

Provide one SQL condition in sql_filter. Combine conditions with AND, OR, and parentheses. Unsupported fields and constructs return HTTP 400.

Names

Use first_name, middle_name, and last_name for name filters. Matching ignores case, trims and collapses whitespace, and removes Latin combining accents. For example, Sánchez matches SANCHEZ, and Straße matches strasse. Non-Latin scripts are preserved. Each condition matches the complete name component; a middle name can contain several words. These rules also apply to IN and SEARCH. Returned names retain their original spelling.

Find people named José Sánchez or José De Cózar using name filters without accents:

first_name = 'Jose'
AND last_name IN ('Sanchez', 'De Cozar')

Use IS NULL for a missing name; blank name filter values are rejected.

Record presence

Top-level record arrays support IS NOT NULL to require at least one record with searchable data and IS NULL to require none.

Find people with at least one certification:

certifications IS NOT NULL

For certifications, a title or issuer is sufficient; a record containing only a certificate URL is not searchable. To constrain a specific certification, use EXISTS with conditions on its supported fields.

SEARCH: text versus exact values

On fields marked Field text SEARCH, SEARCH matches terms, with stemming unless disabled in the table. Tokenized fields do not support exact = comparisons. On exact fields, including canonical string arrays, SEARCH matches whole indexed values. Canonical labels are not automatically resolved from arbitrary text.

Find backend engineers or developers with Python or Go skills and at least one skill listed on their profile:

SEARCH(title, 'backend AND (engineer OR developer)')
AND SEARCH(canonical_skills, 'Python OR Go')
AND skills IS NOT NULL

Use AND, OR, and parentheses inside a SEARCH string. To negate a search, write SQL NOT SEARCH(...); do not put SQL conditions in the search string. Quoting a multiword term groups it, but tokenized search does not promise positional phrase matching. Use an exact canonical field when a whole-value match matters. Do not assume LIKE, wildcards, regular expressions, or arbitrary SQL functions are supported.

Some tokenized fields contribute to the document-wide _text index without having a field-specific text index. Those are marked Document text only. Field-specific SEARCH on summary, skills, an education's major, or a company's technologies is unsupported. Use query, a corresponding canonical field, or document-wide text search:

Find people whose profile text mentions both Python and distributed systems:

SEARCH(_text, 'Python AND distributed systems')

_text is a synthetic document-wide text field, not a returned profile property. A match can come from any contributing field, including another experience or education record. It does not establish that a term appears in a particular role, course, major, or company. Do not use it as a substitute for a same-record constraint. Presence tests on an indexed tokenized field are still supported.

Keep related conditions in one scope

Find people currently employed at Stripe as engineers:

EXISTS (
  SELECT 1
  FROM UNNEST(experiences) AS c
  CROSS JOIN UNNEST(c.company_roles) AS r
  WHERE r.end_date IS NULL
    AND c.company_info.domain = 'stripe.com'
    AND SEARCH(r.title, 'engineer')
)

r.end_date IS NULL selects roles marked as current. Keeping the company and role conditions in the same EXISTS ensures that the engineering job is at Stripe. Separate EXISTS clauses could match an engineering job at another company and a different job at Stripe. Use the appropriate source alias for each field inside a subquery.

Translation boundaries

Use at most one company_roles alias per company alias, in the same SELECT scope, through CROSS JOIN UNNEST(c.company_roles) AS r. A nested EXISTS or aggregate over an outer company's company_roles, multiple role aliases for that company, and offsets are rejected with HTTP 400. In particular, asking for two different roles at the same company is not supported. Splitting that requirement into independent EXISTS clauses would change its meaning.

Aggregates over company groups, such as COUNT(*) directly over UNNEST(experiences), are rejected because the internal records count roles rather than distinct companies. Aggregate role records explicitly instead. Company-only positive and negative EXISTS filters are supported. NOT EXISTS over a company/role join excludes matching roles anywhere in the profile; it does not express a nested absence of roles within a selected company.

Flat role paths such as e.title after UNNEST(experiences) AS e are rejected. Use r.title after unnesting e.company_roles. Unsupported mappings are never approximated or dropped.

Exclude people who have ever worked at the company with domain example.com:

NOT EXISTS (
  SELECT 1 FROM UNNEST(experiences) AS e
  WHERE e.company_info.domain = 'example.com'
)

Testing one role with e.company_info.domain != 'example.com' does not exclude a matching company elsewhere in the person's history.

Experience durations and company attributes

Find people with five to ten years of combined experience as a software engineer or software developer:

(
  SELECT SUM(r.duration_years)
  FROM UNNEST(experiences) AS c
  CROSS JOIN UNNEST(c.company_roles) AS r
  WHERE SEARCH(r.canonical_title, 'Software Engineer OR Software Developer')
) BETWEEN 5 AND 10

This sums the indexed durations of matching roles. Separate overlapping roles can contribute overlapping time. For overall experience, use total_experience_years. SUM requires a numeric field with scalar evaluation support, such as duration_years; it is not available for every numeric field. Null numeric values do not contribute.

Find people currently working at a SaaS company that is hiring and has 50 to 500 employees:

EXISTS (
  SELECT 1 FROM UNNEST(experiences) AS c
  CROSS JOIN UNNEST(c.company_roles) AS r
  WHERE r.end_date IS NULL
    AND c.company_info.is_saas = TRUE
    AND c.company_info.is_hiring = TRUE
    AND c.company_info.num_employees BETWEEN 50 AND 500
)

Geography

Find people located in California, United States:

location_state_code = 'US-CA'

Use two-letter ISO country codes and country-prefixed subdivision codes for exact country and state filters. A subdivision code such as US-CA already identifies its country.

Named places and distance

Use LOCATION('full place name', 'ISO country code') for a city, state, or named area. For example, LOCATION('Athens, Greece', 'GR') filters for Athens in Greece. Preserve place qualifiers and use an uppercase two-letter country code; use NULL when the country is unspecified.

Find people located on the US West Coast:

LOCATION('West Coast, US', 'US')

Add a positive radius and a unit of 'km' or 'mi' for distance from the named place's center. For example, LOCATION('New York, United States', 'US', 50, 'km') searches within 50 km of New York.

Find people within 25 miles of the resolved center of the US West Coast region:

LOCATION('West Coast, US', 'US', 25, 'mi')

Combine place predicates with AND, OR, and NOT, alongside other profile conditions. Each place keeps its own country and radius. LOCATION applies to the person's location and belongs at the profile level, outside subqueries. Unknown places return HTTP 400.

Time zones

Use location_timezone = 'label' or location_timezone IN ('label', ...) for these supported time zones:

• Eastern Time (US and Canada)
• Central Time (US and Canada)
• Mountain Time (US and Canada)
• Pacific Time (US and Canada)
• Atlantic Time (Canada)
• Newfoundland Time
• Alaska Time
• Hawaii Time
• India Standard Time
• China Standard Time
• Japan Standard Time
• Korea Standard Time
• Singapore Time

Find people in either Pacific Time (US and Canada) or India Standard Time:

location_timezone IN ('Pacific Time (US and Canada)', 'India Standard Time')

AND, OR, and NOT can combine time-zone conditions. Unsupported labels or operations return HTTP 400.

Coordinates and regions

You can also filter numeric coordinates or use SEARCH(location_regions, 'Europe OR APAC') to match either indexed region label.

Find people inside the rectangle bounded by latitudes 37.0–38.5 and longitudes -123.0–-121.0:

location_coordinates.lat BETWEEN 37.0 AND 38.5
AND location_coordinates.lng BETWEEN -123.0 AND -121.0

Coordinate bounds define a rectangular area. Use the four-argument LOCATION form for a distance radius.

Advanced scalar expressions

The restricted dialect also supports CAST and SAFE_CAST to INT64, FLOAT64, STRING, BOOL, and TIMESTAMP. Casts of constants are evaluated before index lookup. Casts of field values require scalar-expression support on the field. CAST fails on invalid values; SAFE_CAST produces a null value, which does not satisfy a comparison.

Supported correlated MIN/SUM, field-to-field comparisons, IFNULL/COALESCE, DATE_ADD/DATE_SUB, TIMESTAMP_ADD/TIMESTAMP_SUB, EXTRACT(YEAR FROM ...), and numeric subtraction require scalar-expression support on every field read during that evaluation.

Find people whose job ended on or after their employer went public:

EXISTS (
  SELECT 1 FROM UNNEST(experiences) AS c
  CROSS JOIN UNNEST(c.company_roles) AS r
  WHERE r.end_date >= c.company_info.ipo_date
)

The tables distinguish scalar-capable fields from fields that only support ordinary indexed lookups. Unsupported expressions are rejected; SQL is not executed against arbitrary profile JSON.

Complete field reference

Reference date: 2026-10-30. Every field supported by the endpoint's public SQL schema is listed below. Fields are optional; an absent value does not establish a negative fact about a person.

Read the tables

• string[] denotes an array of scalar strings. Use SEARCH(field, 'value') for membership or alternatives.
• Exact value means whole-value equality, IN, or exact-value SEARCH. Field text SEARCH means term matching on this field; exact = comparisons are unsupported for tokenized fields.
• Document text only means the field contributes to SEARCH(_text, ...), but field-specific SEARCH(field, ...) and exact comparisons are unsupported. Indexed presence tests remain available.
• Numeric range, Date/time range, and Boolean support compatible comparisons and presence tests.
• Presence only supports IS NULL and IS NOT NULL. Scalar aggregate only means a value can be read by supported scalar aggregate evaluation, not used as a direct indexed range predicate.
• Scalar expressions marks fields with the index's scalar postfilter capability, required for supported field-to-field comparisons, casts, date arithmetic, and aggregates. It does not make arbitrary SQL functions available.
• Filter-only fields can be used in filters but need not appear in returned profiles. Other fields can still be renamed, grouped, omitted, or redacted by the response formatter.
• Typed timestamp fields accept DATE '2025-01-01' or TIMESTAMP '2025-01-01T00:00:00Z'. A field typed number remains numeric even when its name contains date or timestamp; do not assume the types are interchangeable.

Profile fields

alternativeSlugs records

Each row belongs to one alternativeSlugs element. Apply related conditions inside the same EXISTS scope.

Find people whose LinkedIn profile is also known by the alias example-slug:

EXISTS (SELECT 1 FROM UNNEST(alternativeSlugs) AS s WHERE s.element = 'example-slug')

activities records

Each row belongs to one activities element. Apply related conditions inside the same EXISTS scope.

Find people whose LinkedIn activity mentions machine learning on or after January 1, 2025:

EXISTS (SELECT 1 FROM UNNEST(activities) AS a WHERE SEARCH(a.title, 'machine learning') AND a.activity_timestamp >= DATE '2025-01-01')

recommendations records

Each row belongs to one recommendations element. Apply related conditions inside the same EXISTS scope.

Find people with a recommendation mentioning technical leadership:

EXISTS (SELECT 1 FROM UNNEST(recommendations) AS r WHERE SEARCH(r.recommendation, 'technical leadership'))

certifications records

Each row belongs to one certifications element. Apply related conditions inside the same EXISTS scope.

Find people with an AWS certification from Amazon:

EXISTS (SELECT 1 FROM UNNEST(certifications) AS c WHERE SEARCH(c.title, 'AWS') AND SEARCH(c.issuer, 'Amazon'))

courses records

Each row belongs to one courses element. Apply related conditions inside the same EXISTS scope.

Find people who list at least one course by name:

EXISTS (SELECT 1 FROM UNNEST(courses) AS c WHERE c.title IS NOT NULL)

educations records

Each row belongs to one educations element. Apply related conditions inside the same EXISTS scope.

Find people with a bachelor's, master's, or doctoral degree from Stanford:

EXISTS (SELECT 1 FROM UNNEST(educations) AS edu WHERE SEARCH(edu.degree, 'bachelor OR master OR doctor') AND SEARCH(edu.campus, 'Stanford'))

experiences records

Each row belongs to one experiences element. Apply related conditions inside the same EXISTS scope.

This is the company-group scope. Access company attributes through c.company_info; join c.company_roles AS r using UNNEST for role fields. Role location_info belongs to the role rather than the company group. Use r.end_date IS NULL for current employment.

Find people with experience at a company with at least 100 employees:

EXISTS (SELECT 1 FROM UNNEST(experiences) AS c WHERE c.company_info.num_employees >= 100)

experiences.company_info.funding_rounds records

Each row belongs to one experiences.company_info.funding_rounds element. Apply related conditions inside the same EXISTS scope.

Find people currently working at a company that raised a Series A round in 2024 or later:

EXISTS (SELECT 1 FROM UNNEST(experiences) AS c CROSS JOIN UNNEST(c.company_roles) AS r CROSS JOIN UNNEST(c.company_info.funding_rounds) AS fr WHERE r.end_date IS NULL AND fr.round_name = 'Series A' AND fr.date >= DATE '2024-01-01')

experiences.company_roles records

Each row belongs to one experiences.company_roles element. Apply related conditions inside the same EXISTS scope.

Find people currently working as engineers:

EXISTS (SELECT 1 FROM UNNEST(experiences) AS c CROSS JOIN UNNEST(c.company_roles) AS r WHERE r.end_date IS NULL AND SEARCH(r.title, 'engineer'))

languages records

Each row belongs to one languages element. Apply related conditions inside the same EXISTS scope.

Find people who explicitly list English as a language:

EXISTS (SELECT 1 FROM UNNEST(languages) AS l WHERE l.language = 'English')

memberships records

Each row belongs to one memberships element. Apply related conditions inside the same EXISTS scope.

Find people who list at least one membership by name:

EXISTS (SELECT 1 FROM UNNEST(memberships) AS m WHERE m.name IS NOT NULL)

patents records

Each row belongs to one patents element. Apply related conditions inside the same EXISTS scope.

Find people with a patent about neural networks:

EXISTS (SELECT 1 FROM UNNEST(patents) AS p WHERE SEARCH(p.title, 'neural network'))

publications records

Each row belongs to one publications element. Apply related conditions inside the same EXISTS scope.

Find people with a publication about distributed systems:

EXISTS (SELECT 1 FROM UNNEST(publications) AS p WHERE SEARCH(p.title, 'distributed systems'))

inferred_languages records

Each row belongs to one inferred_languages element. Apply related conditions inside the same EXISTS scope.

These languages are inferred; use languages when you require explicitly listed language evidence.

Find people inferred to speak English:

EXISTS (SELECT 1 FROM UNNEST(inferred_languages) AS l WHERE l.language = 'English')