# SocialCrawl API: linkedin endpoints
# Base URL: https://www.socialcrawl.dev
# Auth: x-api-key header
# Full docs: https://www.socialcrawl.dev/docs/linkedin

## GET /v1/linkedin/profile
Get LinkedIn user profile
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile page
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/company
Get LinkedIn company page with its full About tab
Credit cost: 5-8 (metered): 5 credits for the company page. include=about holds 3 more and keeps them only when it fills the company type or tagline the plain call lacked, refunding them otherwise, so a call with include=about is at most 8 credits; when the plain call already carried both, it settles at 5. Company lookups are cached.
Parameters:
- url (required): Full URL of the LinkedIn company page
- include (optional, enum: about): Set to `about` (one token only) to add the page's company type (`author.ext.company_type`, for example "Public Company") and tagline (`author.ext.tagline`) when the plain call returned without them. 3 extra credits, kept only when one of the two comes back; a page that sets neither is refunded. Adds about 7 to 18 seconds when a lookup runs; read `data.hydration` for the credits held and kept and the time.
curl -G "https://www.socialcrawl.dev/v1/linkedin/company" \
  --data-urlencode "url=https://www.linkedin.com/company/microsoft/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/company/by-domain
Look up a LinkedIn company page from its website domain
Credit cost: 5 (advanced)
Parameters:
- domain (required): Company website domain, with or without a scheme. `microsoft.com` and `https://www.microsoft.com/` resolve the same page.
curl -G "https://www.socialcrawl.dev/v1/linkedin/company/by-domain" \
  --data-urlencode "domain=microsoft.com" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/similar
List LinkedIn members similar to a given profile
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile to find similar members for.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/similar" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/search/companies
Search LinkedIn company pages
Credit cost: 10 (premium)
Parameters:
- query (required): Company name or keyword.
- page (optional, integer): 1-based page number. Defaults to 1.
- company_size (optional, enum: 1-10 | 11-50 | 51-200 | 201-500 | 501-1000 | 1001-5000 | 5001-10000 | 10001+): Headcount bucket. One of `1-10`, `11-50`, `51-200`, `201-500`, `501-1000`, `1001-5000`, `5001-10000`, `10001+`.
- has_jobs (optional, boolean): When true, return only companies that currently have open jobs.
- industry_ids (optional, string): Comma-separated industry ids from /v1/linkedin/search/industry.
- geocode (optional, string): Comma-separated location ids from /v1/linkedin/search/location.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/search/companies" \
  --data-urlencode "query=microsoft" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/posted-jobs
List jobs a LinkedIn member has posted
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile whose posted jobs to list.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/posted-jobs" \
  --data-urlencode "url=https://www.linkedin.com/in/jipeng-han/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/job/hiring-team
List the hiring team on a LinkedIn job
Credit cost: 5 (advanced)
Parameters:
- id (optional, string): LinkedIn job ID (from /v1/linkedin/search/jobs or /v1/linkedin/company/jobs).
- url (optional, string): Full URL of the LinkedIn job posting.
- Constraint: one of id, url (at least one required)
curl -G "https://www.socialcrawl.dev/v1/linkedin/job/hiring-team" \
  --data-urlencode "id=4463963538" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/articles
List Pulse articles a LinkedIn member published
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile whose articles to list.
- page (optional, integer): 1-based page number. Defaults to 1.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/articles" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/article
Get a LinkedIn Pulse article
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn Pulse article.
curl -G "https://www.socialcrawl.dev/v1/linkedin/article" \
  --data-urlencode "url=https://www.linkedin.com/pulse/hidden-costs-unreliable-electricity-bill-gates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/article/comments
List comments on a LinkedIn Pulse article
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn Pulse article.
- page (optional, integer): 1-based page number. Defaults to 1.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/article/comments" \
  --data-urlencode "url=https://www.linkedin.com/pulse/2024-corporate-climate-pivot-bill-gates-u89mc/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/article/reactions
List reactors on a LinkedIn Pulse article
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn Pulse article.
- page (optional, integer): 1-based page number. Defaults to 1.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/article/reactions" \
  --data-urlencode "url=https://www.linkedin.com/pulse/2024-corporate-climate-pivot-bill-gates-u89mc/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/search/hashtag
Search LinkedIn posts by hashtag
Credit cost: 10 (premium)
Parameters:
- query (required): Hashtag to search, with or without a leading #.
- sort_by (optional, enum: recent | oldest | relevance): Result ordering: recent, oldest, or relevance.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
curl -G "https://www.socialcrawl.dev/v1/linkedin/search/hashtag" \
  --data-urlencode "query=hiring" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/activity
Get when a LinkedIn member was last active
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/activity" \
  --data-urlencode "url=https://www.linkedin.com/in/adamselipsky/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/company/also-viewed
List company pages people also viewed
Credit cost: 5 (advanced)
Parameters:
- company_id (optional, string): Numeric LinkedIn company id, for example 1441 for Google. It is `author.id` on `/v1/linkedin/company`. Send this or `url`.
- url (optional, string): Full URL of the LinkedIn company page, for example https://www.linkedin.com/company/google/. Send this or `company_id`.
- Constraint: one of company_id, url (at least one required)
curl -G "https://www.socialcrawl.dev/v1/linkedin/company/also-viewed" \
  --data-urlencode "company_id=1441" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/company/employees-count
Get a company's employee count, optionally by location
Credit cost: 5 (advanced)
Parameters:
- company_id (required): LinkedIn numeric company ID (from /v1/linkedin/company).
- geocode (optional, string): Comma-separated location ids from /v1/linkedin/search/location.
curl -G "https://www.socialcrawl.dev/v1/linkedin/company/employees-count" \
  --data-urlencode "company_id=1441" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/interests/schools
List schools a LinkedIn member follows
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile.
- page (optional, integer): 1-based page number. Defaults to 1.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/interests/schools" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/interests/newsletters
List newsletters a LinkedIn member follows
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile.
- page (optional, integer): 1-based page number. Defaults to 1.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/interests/newsletters" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/interests/top-voices
List Top Voices a LinkedIn member follows
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/interests/top-voices" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/position-skills
List a member's positions with the skills on each role
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/position-skills" \
  --data-urlencode "url=https://www.linkedin.com/in/tedgaubert/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/top-position
Get the company page of a member's top position
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/top-position" \
  --data-urlencode "url=https://www.linkedin.com/in/adamselipsky/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/search/people/by-url
Search LinkedIn people from a search-results URL
Credit cost: 10 (premium)
Parameters:
- url (required): LinkedIn people-search results URL.
curl -G "https://www.socialcrawl.dev/v1/linkedin/search/people/by-url" \
  --data-urlencode "url=https://www.linkedin.com/search/results/people/?keywords=kyc" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/all
Get a member's entire profile, counts included, in one call
Credit cost: 5-50 (metered)
Parameters:
- url (optional, string): Full URL of the LinkedIn profile.
- urls (optional, string): Up to 10 full LinkedIn profile URLs in one call, comma separated. The response becomes `{items, total}` instead of a single profile. Billed 5 credits per profile RETURNED, the same rate as a single call: duplicates are collapsed before the call and profiles that do not resolve are not charged, so a list with repeats or dead handles costs less than its length. A list where nothing resolves is a free 404.
- Constraint: one of url, urls (at least one required)
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/all" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/complete
Get a member's profile, experience, education, skills and recommendations
Credit cost: 10 (premium)
Parameters:
- url (required): Full URL of the LinkedIn profile.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/complete" \
  --data-urlencode "url=https://www.linkedin.com/in/ryanroslansky/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/with-posts
Get a member profile with follower and connection counts and recent posts
Credit cost: 10 (premium)
Parameters:
- url (required): Full URL of the LinkedIn profile.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/with-posts" \
  --data-urlencode "url=https://www.linkedin.com/in/adamselipsky/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/post/with-comments
Get a LinkedIn post together with its comments
Credit cost: 5 (advanced)
Parameters:
- url (required): Activity URL of the LinkedIn post.
curl -G "https://www.socialcrawl.dev/v1/linkedin/post/with-comments" \
  --data-urlencode "url=https://www.linkedin.com/feed/update/urn:li:activity:7501466755261820928" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/post
Get LinkedIn post details
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn post. It has to carry the post's ACTIVITY id, either `https://www.linkedin.com/feed/update/urn:li:activity:<id>` or `https://www.linkedin.com/posts/<slug>-activity-<id>-<code>`. A `urn:li:share:` or `urn:li:ugcPost:` URL names a different id for the same post and is rejected with a 400 before any credits are charged, because it cannot be resolved to the post. Every endpoint that lists posts publishes the activity form as `post.url`, so copy that field rather than rebuilding the URL from `post.id`, which is not always the activity id.
curl -G "https://www.socialcrawl.dev/v1/linkedin/post" \
  --data-urlencode "url=https://www.linkedin.com/feed/update/urn:li:activity:7501466755261820928" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/search/people
Search LinkedIn people
Credit cost: 10-50 (metered): 10 credits for the list. include=profile holds 4 credits per row and keeps only the rows filled from a fresh lookup: at most 50 for the 10-row page, or 10 + 4 x limit when you pass `limit`. Rows served from cache are free, unfilled rows are refunded, and a repeat of a fully joined page within the list's cache window costs 0. The list is cached for 2 minutes and each profile lookup for 15 minutes. With `max_pages`, `max_items` or `max_credits`, each page walked is billed at this price (a cached page is free), and `max_credits` caps the total.
Parameters:
- query (required): Name or display-name keyword to search for (e.g. 'Bill Gates').
- page (optional, integer): Page number for pagination (default 1).
- first_name (optional, string): Filter by first name.
- last_name (optional, string): Filter by last name.
- title (optional, string): Filter by job title or headline.
- current_company (optional, string): Filter by current company, using a numeric company id from /v1/linkedin/company (`author.id`). Comma-separated for multiple.
- past_company (optional, string): Filter by a previously-worked company, using a numeric company id from /v1/linkedin/company (`author.id`).
- school (optional, string): Filter by school, using a school id from /v1/linkedin/search/schools (`id`).
- industry (optional, string): Filter by industry, using an industry id from /v1/linkedin/search/industry (`industry_id`).
- geocode_location (optional, string): Filter by location, using a geocode id from /v1/linkedin/search/location (`geocode`).
- profile_language (optional, string): Filter by profile language (ISO 2-letter code, e.g. 'en').
- service_category (optional, string): Filter by service category, using a numeric service-category id. No endpoint resolves these, so pass one you already hold.
- follower_of (optional, string): Return people who follow a specific member, using the member's URN from /v1/linkedin/profile (`author.ext.urn`). This one is a URN and not a numeric id.
- include (optional, enum: profile): Set to `profile` (one token only) to join every row to the member's profile lookup in this one call: `author.followers` becomes the exact count and `author.ext.followers_approximate` reads false on every row the lookup filled, `author.following` is filled with the member's connection count, and the location, joined date, country, website, cover image and profile flags land where the row lacks them. Holds 4 credits per row and keeps only the rows filled from a fresh lookup; rows already in cache and rows that could not be filled are refunded, so a call costs at most 50 (10 + 4 per row) and the usual bill is lower. Adds about 1 second for 10 rows, up to 3 on a slow second and never more than 8, and nothing when the members are already cached; read `data.hydration` for the rows, the credits held and kept, and the time.
- limit (optional, integer): Take the top N rows of this page (1 to 10). With `include=profile` it caps both the rows joined and the extra credits: `limit=3&include=profile` costs at most 22. The page cursor still advances past the full page of 10, so the rows past your limit are skipped, not carried to the next page. Without `include=profile` the call stays 10 credits.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/search/people" \
  --data-urlencode "query=Bill Gates" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/company/people
List people at a LinkedIn company
Credit cost: 10-50 (metered): 10 credits for the list. include=profile holds 4 credits per row and keeps only the rows filled from a fresh lookup: at most 50 for the 10-row page, or 10 + 4 x limit when you pass `limit`. Rows served from cache are free, unfilled rows are refunded, and a repeat of a fully joined page within the list's cache window costs 0. The list is cached for 15 minutes and each profile lookup for 15 minutes. With `max_pages`, `max_items` or `max_credits`, each page walked is billed at this price (a cached page is free), and `max_credits` caps the total.
Parameters:
- company_id (required): LinkedIn numeric company ID (from /v1/linkedin/company).
- page (optional, integer): Page number for pagination (default 1).
- include (optional, enum: profile): Set to `profile` (one token only) to join every row to the member's profile lookup in this one call: `author.followers` becomes the exact count and `author.ext.followers_approximate` reads false on every row the lookup filled, `author.following` is filled with the member's connection count, and the location, joined date, country, website, cover image and profile flags land where the row lacks them. Holds 4 credits per row and keeps only the rows filled from a fresh lookup; rows already in cache and rows that could not be filled are refunded, so a call costs at most 50 (10 + 4 per row) and the usual bill is lower. Adds about 1 second for 10 rows, up to 3 on a slow second and never more than 8, and nothing when the members are already cached; read `data.hydration` for the rows, the credits held and kept, and the time.
- limit (optional, integer): Take the top N rows of this page (1 to 10). With `include=profile` it caps both the rows joined and the extra credits: `limit=3&include=profile` costs at most 22. The page cursor still advances past the full page of 10, so the rows past your limit are skipped, not carried to the next page. Without `include=profile` the call stays 10 credits.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/company/people" \
  --data-urlencode "company_id=1035" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/post/comments
Get LinkedIn post comments
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn post. It has to carry the post's ACTIVITY id, either `https://www.linkedin.com/feed/update/urn:li:activity:<id>` or `https://www.linkedin.com/posts/<slug>-activity-<id>-<code>`. A `urn:li:share:` or `urn:li:ugcPost:` URL names a different id for the same post and is rejected with a 400 before any credits are charged, because it cannot be resolved to the post. Every endpoint that lists posts publishes the activity form as `post.url`, so copy that field rather than rebuilding the URL from `post.id`, which is not always the activity id.
- page (optional, integer): Page number for pagination (default 1).
- post_type (optional, enum: activity | ugc): Upstream post type: 'activity' (default) or 'ugc'.
- sort_order (optional, enum: recent | relevance): Comment ordering: 'relevance' or 'recent'.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off the page, and the page that reaches one ends the walk: `next_cursor` is not returned and `pagination.stopped_at` is `since`. Sending it sets the newest-first sort shown in this endpoint's sort parameter (any other sort value is a free 400). The page still costs what a page costs, so you pay for the pages you walk and no more. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/post/comments" \
  --data-urlencode "url=https://www.linkedin.com/feed/update/urn:li:activity:7244804629786419202" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/posts
List a LinkedIn member's posts
Credit cost: 5-200 (metered): 5 credits for a call with no `limit`, or `limit` at 50 or below. Above 50 the call is metered at 2 credits per post RETURNED: it holds `limit x 2` up front (the 100 maximum holds 200) and refunds down to the posts that actually came back, never below 5, so a member with 60 posts settles at 120 credits however high `limit` was set
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- limit (optional, integer): How many posts to return in the one call, 1 to 100. Defaults to the upstream's 20. 100 is the provider's hard ceiling. Up to 50 the call is a flat 5 credits; above 50 it is metered at 2 credits per post returned (holds `limit x 2`, never below 5). Ask for the depth you need up front - there is no second page to fetch.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/posts" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/reactions
List posts a LinkedIn member reacted to
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/reactions" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/post/reposts
List reposts of a LinkedIn post
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn post. It has to carry the post's ACTIVITY id, either `https://www.linkedin.com/feed/update/urn:li:activity:<id>` or `https://www.linkedin.com/posts/<slug>-activity-<id>-<code>`. A `urn:li:share:` or `urn:li:ugcPost:` URL names a different id for the same post and is rejected with a 400 before any credits are charged, because it cannot be resolved to the post. Every endpoint that lists posts publishes the activity form as `post.url`, so copy that field rather than rebuilding the URL from `post.id`, which is not always the activity id.
- cursor (optional, string): LinkedIn cursor.
- page (optional, integer): 1-based page number. Defaults to 1.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/post/reposts" \
  --data-urlencode "url=https://www.linkedin.com/feed/update/urn:li:activity:7501466755261820928" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/group/posts
List posts in a LinkedIn group
Credit cost: 5 (advanced)
Parameters:
- group_id (required): LinkedIn numeric group ID.
- page (optional, integer): 1-based page number. Defaults to 1.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/group/posts" \
  --data-urlencode "group_id=62438" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/company/affiliated-pages
List a company's affiliated/showcase pages
Credit cost: 5 (advanced)
Parameters:
- company_id (required): LinkedIn numeric company ID (from /v1/linkedin/company).
curl -G "https://www.socialcrawl.dev/v1/linkedin/company/affiliated-pages" \
  --data-urlencode "company_id=1035" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/post/comments/replies
List replies to a LinkedIn comment
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn post. It has to carry the post's ACTIVITY id, either `https://www.linkedin.com/feed/update/urn:li:activity:<id>` or `https://www.linkedin.com/posts/<slug>-activity-<id>-<code>`. A `urn:li:share:` or `urn:li:ugcPost:` URL names a different id for the same post and is rejected with a 400 before any credits are charged, because it cannot be resolved to the post. Every endpoint that lists posts publishes the activity form as `post.url`, so copy that field rather than rebuilding the URL from `post.id`, which is not always the activity id.
- comment_id (required): The parent comment's `comment.id` from /v1/linkedin/post/comments, or its `comment.ext.urn` (urn:li:comment:(ugcPost:<post>,<comment>)).
- cursor (optional, string): LinkedIn cursor.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/post/comments/replies" \
  --data-urlencode "url=https://www.linkedin.com/feed/update/urn:li:activity:7501466755261820928" \
  --data-urlencode "comment_id=7501480403283886080" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/experiences
List a member's work experiences
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- page (optional, integer): 1-based page number. Defaults to 1.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/experiences" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/educations
List a member's education history
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- page (optional, integer): 1-based page number. Defaults to 1.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/educations" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/skills
List a member's skills
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- page (optional, integer): 1-based page number. Defaults to 1.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/skills" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/honors
List a member's honors and awards
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- page (optional, integer): 1-based page number. Defaults to 1.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/honors" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/certifications
List a member's licenses and certifications
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- page (optional, integer): 1-based page number. Defaults to 1.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/certifications" \
  --data-urlencode "url=https://www.linkedin.com/in/adamgrant/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/publications
List a member's publications
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- page (optional, integer): 1-based page number. Defaults to 1.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/publications" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/volunteers
List a member's volunteer experiences
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- page (optional, integer): 1-based page number. Defaults to 1.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/volunteers" \
  --data-urlencode "url=https://www.linkedin.com/in/reidhoffman/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/recommendations
List recommendations for a member
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- page (optional, integer): 1-based page number. Defaults to 1.
- type (optional, enum: received | given): Filter by kind. See the allowed values.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/recommendations" \
  --data-urlencode "url=https://www.linkedin.com/in/reidhoffman/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/interests/companies
List companies a member follows
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- page (optional, integer): 1-based page number. Defaults to 1.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/interests/companies" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/interests/groups
List groups a member follows
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- page (optional, integer): 1-based page number. Defaults to 1.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/interests/groups" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/images
List a member's image posts
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/images" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/videos
List a member's video posts
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/videos" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/comments
List a member's comments
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/comments" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/post/reactions
List reactors on a LinkedIn post
Credit cost: 10-50 (metered): 10 credits for the list. include=profile holds 4 credits per row and keeps only the rows filled from a fresh lookup: at most 50 for the 10-row page, or 10 + 4 x limit when you pass `limit`. Rows served from cache are free, unfilled rows are refunded, and a repeat of a fully joined page within the list's cache window costs 0. The list is cached for 5 minutes and each profile lookup for 15 minutes. With `max_pages`, `max_items` or `max_credits`, each page walked is billed at this price (a cached page is free), and `max_credits` caps the total.
Parameters:
- url (required): Full URL of the LinkedIn post. It has to carry the post's ACTIVITY id, either `https://www.linkedin.com/feed/update/urn:li:activity:<id>` or `https://www.linkedin.com/posts/<slug>-activity-<id>-<code>`. A `urn:li:share:` or `urn:li:ugcPost:` URL names a different id for the same post and is rejected with a 400 before any credits are charged, because it cannot be resolved to the post. Every endpoint that lists posts publishes the activity form as `post.url`, so copy that field rather than rebuilding the URL from `post.id`, which is not always the activity id.
- page (optional, integer): 1-based page number. Defaults to 1.
- type (optional, enum: all | like | praise | empathy | appreciation | interest): Filter by kind. See the allowed values.
- include (optional, enum: profile): Set to `profile` (one token only) to join every row to the member's profile lookup in this one call: `author.followers` becomes the exact count and `author.ext.followers_approximate` reads false on every row the lookup filled, `author.following` is filled with the member's connection count, and the location, joined date, country, website, cover image and profile flags land where the row lacks them. Holds 4 credits per row and keeps only the rows filled from a fresh lookup; rows already in cache and rows that could not be filled are refunded, so a call costs at most 50 (10 + 4 per row) and the usual bill is lower. Adds about 1 second for 10 rows, up to 3 on a slow second and never more than 8, and nothing when the members are already cached; read `data.hydration` for the rows, the credits held and kept, and the time.
- limit (optional, integer): Take the top N rows of this page (1 to 10). With `include=profile` it caps both the rows joined and the extra credits: `limit=3&include=profile` costs at most 22. The page cursor still advances past the full page of 10, so the rows past your limit are skipped, not carried to the next page. Without `include=profile` the call stays 10 credits.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/post/reactions" \
  --data-urlencode "url=https://www.linkedin.com/feed/update/urn:li:activity:7501466755261820928" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/company/jobs
List a company's job postings
Credit cost: 10 (premium)
Parameters:
- company_id (required): LinkedIn numeric company ID (from /v1/linkedin/company).
- page (optional, integer): 1-based page number. Defaults to 1.
- date_posted (optional, enum: anytime | past_24_hours | past_week | past_month): How recently the job was listed. One of `anytime`, `past_24_hours`, `past_week`, `past_month`. Note the job lanes use `past_24_hours` while /v1/linkedin/search/posts uses `past_24h`; they are different upstream vocabularies and are not interchangeable.
- experience_level (optional, enum: internship | entry_level | associate | mid_senior | director | executive): Required seniority for the role.
- job_type (optional, enum: full_time | part_time | contract | temporary | volunteer | internship | other): Contract type for the role.
- remote (optional, enum: onsite | remote | hybrid): Workplace type: onsite, remote, or hybrid.
- easy_apply (optional, boolean): When true, return only jobs that support LinkedIn Easy Apply.
- sort_by (optional, enum: recent | relevant): Result ordering.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
Worth sending:
- date_posted=anytime: Only posts from this time window.
curl -G "https://www.socialcrawl.dev/v1/linkedin/company/jobs" \
  --data-urlencode "company_id=1035" \
  --data-urlencode "date_posted=anytime" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/search/jobs
Search LinkedIn jobs
Credit cost: 10 (premium)
Parameters:
- query (required): Search keyword.
- page (optional, integer): 1-based page number. Defaults to 1.
- date_posted (optional, enum: anytime | past_24_hours | past_week | past_month): How recently the job was listed. One of `anytime`, `past_24_hours`, `past_week`, `past_month`. Note the job lanes use `past_24_hours` while /v1/linkedin/search/posts uses `past_24h`; they are different upstream vocabularies and are not interchangeable.
- experience_level (optional, enum: internship | entry_level | associate | mid_senior | director | executive): Required seniority for the role.
- job_type (optional, enum: full_time | part_time | contract | temporary | volunteer | internship | other): Contract type for the role.
- remote (optional, enum: onsite | remote | hybrid): Workplace type: onsite, remote, or hybrid.
- easy_apply (optional, boolean): When true, return only jobs that support LinkedIn Easy Apply.
- sort_by (optional, enum: recent | relevant): Result ordering.
- company (optional, string): Filter by company, using a numeric company id from /v1/linkedin/company (`author.id`).
- geocode (optional, string): Filter by location, using a geocode id from /v1/linkedin/search/location.
- industry_ids (optional, string): Comma-separated industry ids from /v1/linkedin/search/industry.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
Worth sending:
- date_posted=anytime: Only posts from this time window.
curl -G "https://www.socialcrawl.dev/v1/linkedin/search/jobs" \
  --data-urlencode "query=marketing" \
  --data-urlencode "date_posted=anytime" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/search/location
Resolve a location to a LinkedIn geocode id
Credit cost: 1 (standard)
Parameters:
- query (required): Search keyword.
curl -G "https://www.socialcrawl.dev/v1/linkedin/search/location" \
  --data-urlencode "query=London" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/search/schools
Search LinkedIn schools
Credit cost: 1 (standard)
Parameters:
- query (required): Search keyword.
- page (optional, integer): 1-based page number. Defaults to 1.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/search/schools" \
  --data-urlencode "query=Stanford" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/search/industry
Resolve an industry name to a LinkedIn industry id
Credit cost: 1 (standard)
Parameters:
- query (required): Search keyword.
curl -G "https://www.socialcrawl.dev/v1/linkedin/search/industry" \
  --data-urlencode "query=Software" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/about
Get a member's account freshness signals (NOT the profile About section)
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
- urn (optional, string): The member's opaque LinkedIn URN, as returned in `author.ext.urn` by /v1/linkedin/profile. Optional, and a pure optimisation: pass it ALONGSIDE `url` (which stays required) and this call skips the internal handle lookup, so it answers faster and consumes half the upstream rate-limit budget. Verified on the deployed API 05/09/2026. To address a member by URN alone, send the URN-form profile URL as `url`, for example https://www.linkedin.com/in/ACoAAA8BYqEBCGLg_vT_ca6mMEqkpp9nVffJ3hc: it resolves to the same member as the public address (verified 20/10/2026 on profile/posts and profile/comments) and holds only ASCII, which helps when the public address carries an emoji or other symbol.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/about" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/contact
Get a member's public contact info
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/contact" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/stats
Get a member's follower + connection counts
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn profile, company, or post.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/stats" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/company/job-count
Get a company's open job count
Credit cost: 5 (advanced)
Parameters:
- company_id (required): LinkedIn numeric company ID (from /v1/linkedin/company).
curl -G "https://www.socialcrawl.dev/v1/linkedin/company/job-count" \
  --data-urlencode "company_id=1035" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/company/insights
Get aggregate insights about a company's members
Credit cost: 5 (advanced)
Parameters:
- company_id (required): LinkedIn numeric company ID (from /v1/linkedin/company).
curl -G "https://www.socialcrawl.dev/v1/linkedin/company/insights" \
  --data-urlencode "company_id=1035" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/group
Get LinkedIn group details
Credit cost: 5 (advanced)
Parameters:
- group_id (required): LinkedIn numeric group ID.
curl -G "https://www.socialcrawl.dev/v1/linkedin/group" \
  --data-urlencode "group_id=62438" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/job
Get LinkedIn job details
Credit cost: 5 (advanced)
Parameters:
- id (required): LinkedIn job ID.
- include_skills (optional, boolean): When true, include the job's required skills in `job.ext.skills`.
curl -G "https://www.socialcrawl.dev/v1/linkedin/job" \
  --data-urlencode "id=4462185352" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/company/posts
List LinkedIn company posts
Credit cost: 5 (advanced)
Parameters:
- company_id (required): LinkedIn numeric company ID (from /v1/linkedin/company).
- page (optional, integer): Page number for pagination (default 1).
- sort_by (optional, enum: top | recent): Post ordering: 'top' or 'recent'.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off the page, and the page that reaches one ends the walk: `next_cursor` is not returned and `pagination.stopped_at` is `since`. Sending it sets the newest-first sort shown in this endpoint's sort parameter (any other sort value is a free 400). The page still costs what a page costs, so you pay for the pages you walk and no more. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/company/posts" \
  --data-urlencode "company_id=1035" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/ad
Get LinkedIn ad details
Credit cost: 5 (advanced)
Parameters:
- url (required): Full URL of the LinkedIn ad
curl -G "https://www.socialcrawl.dev/v1/linkedin/ad" \
  --data-urlencode "url=https://www.linkedin.com/ad-library/detail/1515437353" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/ads/search
Search LinkedIn ads
Credit cost: 5 (advanced)
Parameters:
- company (optional, string): The company name to search for. 'Microsoft' for example
- keyword (optional, string): The keyword to search for
- companyId (optional, string): The company id to search for
- countries (optional, string): Comma separated list of countries. Example: US,CA,MX
- startDate (optional, string): Start date to search for. Format: YYYY-MM-DD
- endDate (optional, string): End date to search for. Format: YYYY-MM-DD
- paginationToken (optional, string): Pagination token to paginate through results
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
- Constraint: one of company, keyword, companyId (at least one required)
curl -G "https://www.socialcrawl.dev/v1/linkedin/ads/search" \
  --data-urlencode "company=microsoft" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/posts/archive
Walk a LinkedIn member's COMPLETE post history, 100 posts a page, with exact publish times and share counts the other lanes cannot return. Metered: 5 credits per post returned, so try the cheaper /v1/linkedin/profile/posts first
Credit cost: 5-500 (metered): 5 credits per post RETURNED. The call holds `limit x 5` up front - the default limit of 20 holds 100 and the 100 maximum holds 500 - and refunds down to the posts that actually came back, so a member with 12 posts settles at 60 credits however high `limit` was set. This is the most expensive read on the platform per row: check whether /v1/linkedin/profile/posts (5 credits up to 50 posts, 2 a post above that) already covers the window you need before walking the archive With `max_pages`, `max_items` or `max_credits`, each page walked is billed at this price (a cached page is free), and `max_credits` caps the total.
Parameters:
- url (required): The member's LinkedIn profile URL, for example https://www.linkedin.com/in/williamhgates/.
- limit (optional, integer): How many posts to return, 1 to 100 (default 20). Pass 100 to walk the full archive: only a full page returns a `next_cursor`. You are charged 5 credits for each post actually returned, not for the limit you asked for.
- pagination_token (optional, string): The `next_cursor` from the previous page. Omit it for the newest posts.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/posts/archive" \
  --data-urlencode "url=https://www.linkedin.com/in/williamhgates/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/search/posts
Search public LinkedIn posts by keyword
Credit cost: 1-56 (metered): 5 credits per page. Relevance against your query (by default, or with relevance=) is free. Adding relevant_to= holds 8 extra credits and refunds down to 1 credit per started 25 rows that were newly judged: rows already judged for the same topic are free, a page where nothing could be judged refunds the whole extra, and a cached page is free. The default labels (sponsored, intent, niche) are free. label=mention, quality, ai_style, ai_written, injection, or label=intent with offer=, holds 8 extra credits and refunds down to 1 credit per started 25 posts that were newly judged: posts already labelled are free, a page where nothing could be judged refunds the whole extra, and a cached page is free. With `max_pages`, `max_items` or `max_credits`, each page walked is billed at this price (a cached page is free), and `max_credits` caps the total.
Parameters:
- page (optional, integer): 1-based page number of Google results. Defaults to 1.
- sort_by (optional, enum: date_posted | relevance): Result ordering: `relevance` (default) or `date_posted`. On a subject-only call (`from_member` or `from_company` with no `query`) the results are ordered by date and `relevance` is rejected, because there is no query for them to be relevant to.
- date_posted (optional, enum: past_24h | past_week | past_month): Date filter based on Google-indexed results. One of `past_24h`, `past_week`, `past_month` (underscores, not hyphens). Note the JOB lanes use `past_24_hours` for the same concept; the two vocabularies are not interchangeable.
- content_type (optional, enum: videos | photos | jobs | live_videos | documents | collaborative_articles): Narrow to one kind of post.
- from_company (optional, string): Filter to posts from a company, by numeric LinkedIn company id (for example `1035`). A company slug or URL is rejected; read the id from `author.id` on /v1/linkedin/company.
- from_member (optional, string): Filter to posts from one member, by their LinkedIn member urn — the bare `ACoAA…` value published as `author.ext.urn` by /v1/linkedin/profile. A profile URL, a public slug (`williamhgates`) or a `urn:li:fsd_profile:`-prefixed value is rejected, because the source cannot use any of them. Pass this on its own, with no `query`, to walk one member's back catalogue.
- query (optional, string): Keyword or phrase to search for. Optional when `from_member` or `from_company` is set: omit it to get that subject's posts unfiltered, and note that supplying a real content word narrows the results to posts matching it.
- limit (optional, integer): Return up to this many posts in one call, 1 to 200. The call reads as many pages as it needs, removes duplicates, and is charged 1 credit for every 5 posts returned (200 posts = 40 credits). Repeating the identical call inside the 2-minute cache window is free. Requires `query`. Cannot be combined with `page` or `cursor`: the result always starts at the top and `pagination.next_cursor` is null. `pagination.has_more` says whether more posts were available when the call stopped, and `walk.stopped` says why it stopped (`limit`, `exhausted`, `deadline` or `sources_unavailable`).
- relevance (optional, enum: score | filter): Optional. Without this param every row already carries computed.relevance against your query, free ({ p, sense, depth, spam }: is this row about what your query means, or a different thing that shares its words?), and nothing is dropped or reordered. score asks for it explicitly and waits for every row; filter also drops the rows that are not about your query, and lists their ids in data.relevance.dropped_ids. Your query is the topic; nothing to configure. A row that could not be judged is never dropped and carries relevance: null. Pagination is unchanged, so a filtered page can hold fewer rows. Free with your query as the topic; with relevant_to it adds 1 credit per started 25 newly judged rows (rows already judged for the same topic are free, and so is a cached page).
- relevance_threshold (optional, string): Optional, only with relevance. The probability (0 to 1) a row must reach to be kept by relevance=filter. Default 0.5. Lower keeps more rows, higher keeps fewer.
- relevant_to (optional, string): Optional, only with relevance. Up to 200 characters describing what you mean, used as the topic instead of the query. Use it when the query is ambiguous, for example query=cleopatra with relevant_to=Cleopatra, the IGT slot game.
- judgments (optional, enum: on | off): Optional, on (the default) or off. By default every row gains free SocialCrawl judgments (computed.labels, and computed.relevance on search endpoints), reported in data.labels (mode default) and data.relevance (origin default), each with a status (complete, partial or skipped) and pending: the rows still being judged when the page was sent, which carry null now and are filled on your next call or cached read. Default judgments never add credits, never change an existing field, and never drop or reorder a row. off returns the page exactly as before, with none of those keys. label=none does the same.
- dry_run (optional, enum: 1): Optional. When 1, return a cost preview for this labelled or relevance-filtered request without fetching the page or judging any row. data.estimate reports rows_expected, rows_cached, label_credits_min, label_credits_max and base_credits. 0 credits charged.
- fit (optional, enum: goal): Optional. When goal, keep the rows and fields needed for the goal you pass in goal= (plus any that are uncertain, and the first and last), and replace the rest with a stub. data.held_back lists the held ids and a recall id that re-reads the full page from cache at no extra charge. Without this param the page is unchanged.
- goal (optional, string): Required by fit=goal. What you are trying to do, in your own words, up to 300 characters.
- fit_tokens (optional, integer): Optional, only with fit=goal. Soft cap on how much of the page to keep, in tokens. Uncertain blocks and the first and last block are kept even if they exceed it.
- label (optional, string): Optional CSV of SocialCrawl labels to add to every post. Without this param every page already carries sponsored, intent and niche, free; label= adds the labels you name to them (the defaults keep running). sponsored, intent and niche are free when asked for too; mention, quality, ai_style, intent with offer=, and injection add 1 credit per started 25 newly judged posts. judgments=off (or label=none) turns the default labels off. sponsored: is the post a paid or gifted promotion (p, 0 to 1), did it carry a disclosure marker such as #ad or 광고 (disclosed), is it likely paid with no marker (undisclosed), and which of the accounts it mentions does it promote (brand, or null). These are signals to review, never a finding. mention (needs brand=): is the post about that brand rather than something that shares its name (about_brand, 0 to 1), how it feels about the brand on five levels (sentiment_level 0 to 4 and sentiment_score 0 to 1, null when the post is not about the brand), is it sarcastic, which aspect it talks about (taste_or_quality, price_or_value, availability_or_delivery, health_or_safety, advertising_or_campaign, customer_service, none), and did the author buy or use it (first_hand). intent: what the author is mainly doing (label: asking_for_recommendation, comparing_options, switching_away, complaining, promoting, news_or_discussion, other, or null when unsure, with confidence), whether they read as a potential buyer rather than a seller (buyer, seller), how pressing the need is (urgency, 0 to 3), and, when you pass offer=, whether your offer would plausibly help them (fits_offer). niche: which of the 33 niches of the published taxonomy sc-niche-v1 the caption belongs to, or personal_no_niche, or other (label, confidence, taxonomy), with label null when the caption is too thin to tell or the pick is unsure. It reads the caption only, not the video. quality: how much checkable detail the caption carries (fact_density 0 to 3), whether it mainly asks for likes, replies, shares, follows or tags (engagement_bait, 0 to 1), whether it is written to provoke anger as a way to get engagement (rage_bait, 0 to 1; about the writing, never the side taken), whether it only repeats someone else's news or view (secondhand, 0 to 1), and what the post is mainly doing (post_aim: inform, opinion, sell, entertain, provoke, other). exclude=engagement_bait drops posts whose engagement_bait is 0.8 or higher. ai_style: writing patterns common in AI-generated text, judged on the text alone. It does not say who wrote the post, and a person who writes in this style is flagged too. Six patterns are judged, each a probability (0 to 1): binary_contrast ("This is not X. It's Y."), faux_insight ("Here's what nobody tells you" and throat-clearing openers), colon_reveal ("The best part: it learns."), profound_kicker (ends on an aphorism or mic-drop line), puffery ("marks a pivotal moment", "highlighting the importance of") and rhetorical_setup ("What if I told you", a question the post answers itself, "Not a X. Not a Y. A Z."). Four are counted in the text: slop_words (words and phrases such as delve, leverage, robust, game changer, at the end of the day), em_dashes, emoji_bullets (lines that start with an emoji or a symbol bullet) and one_line_paragraphs (paragraphs that are one short line). pattern_count is how many patterns are present (a judged pattern at 0.8 or higher, slop_words 1 or more, em_dashes 2 or more, emoji_bullets 2 or more, one_line_paragraphs 5 or more) and markers lists their names, comma-separated. A post with less than about eight words of text is only counted, with every judged pattern 0. The judged patterns read the first 400 and the last 150 characters of a long post, and the counts read the whole post. exclude=ai_style drops posts with 2 or more patterns. ai_written: how likely the post was written by an AI model, from SocialCrawl's own text classifier, reading the opening of the post (about 1,000 characters): p (0 to 1, calibrated), level (likely (p 0.95 or higher), possible (p 0.71 or higher) or unlikely) and model (the model name; a new name means a new scale). A post under 8 words is too short to read: p null, level too_short. It is a probability, not proof: a person can be flagged and an AI-written post can pass, and the shorter the post the less certain it is. exclude=ai_written drops likely posts. injection flags text that addresses an AI system and tries to direct it (flagged, p); it never drops or rewrites a row. A post that could not be judged carries labels: null. Posts already labelled for anyone are free, and so is a cached page. data.labels reports what was judged and billed.
- exclude (optional, string): Optional CSV (engagement_bait, ai_style, ai_written). engagement_bait, only with label=quality, drops posts whose engagement_bait probability is 0.8 or higher. ai_style, only with label=ai_style, drops posts that show 2 or more of its writing patterns (pattern_count 2 or higher). ai_written, only with label=ai_written, drops posts whose level is likely (p 0.95 or higher), or whose p reaches your ai_written_threshold; a post too short to read is never dropped. Dropped posts are listed in data.labels.dropped_ids. A post that could not be judged is never dropped.
- ai_written_threshold (optional, string): Optional, only with label=ai_written and exclude=ai_written. The p (0 to 1) at which exclude=ai_written drops a post. Default 0.95 (level likely). 0.71 also drops possible posts: more AI posts go, and more posts by people with them.
- brand (optional, string): Required by label=mention, ignored otherwise. The brand or product the posts are judged against, up to 300 characters, for example brand=Buldak. Without it label=mention is skipped with the warning label_mention_needs_brand and is not billed.
- brand_description (optional, string): Optional, with label=mention. One plain sentence saying what the brand is, for example brand_description=Samyang's spicy instant noodle brand. Use it when the name is also an ordinary word or another company's name.
- offer (optional, string): Optional, with label=intent. One or two plain sentences saying what you sell, up to 300 characters, for example offer=A web design agency that builds websites for small businesses. Adds fits_offer to every post; without it fits_offer is null.
- label_evidence (optional, enum: 1): Optional, only with label=. When 1, every labelled row also carries computed.labels_evidence.<preset> = { quote, sentence_index }: the sentence in the row that most clearly shows the label, copied verbatim. Absent or null when no single sentence shows it.
- since (optional, string): Only rows published on or after this date: YYYY-MM-DD (midnight UTC) or an ISO 8601 timestamp. Rows older than it are left off each page. This list is not in date order, so the walk does not stop at the date: keep following `next_cursor`, and each page costs what a page costs even when every row on it is filtered out. A row with no date is kept. `published_after`, `start_date`, `from_date`, `publish_time` (`yesterday`, `this-week`, `this-month`, `last-3-months`, `last-6-months`) and `max_age_days` are accepted and applied as `since`.
- until (optional, string): Only rows published on or before this date: YYYY-MM-DD (that whole UTC day is included) or an ISO 8601 timestamp. Newer rows are left off each page and the walk does not stop, so older pages follow. A row with no date is kept. `published_before`, `end_date` and `to_date` are accepted and applied as `until`.
- max_pages (optional, integer): 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped.
- max_items (optional, integer): 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue.
- max_credits (optional, integer): 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price.
- Constraint: one of query, from_member, from_company (at least one required)
Worth sending:
- label=sponsored: Marks each post that is paid or sponsored, at no extra credits; intent and niche are free too.
- relevance=filter: Drops rows that are not about your query, at no extra credits; relevance=score keeps them and adds a score.
- date_posted=past_week: Only posts from this time window.
curl -G "https://www.socialcrawl.dev/v1/linkedin/search/posts" \
  --data-urlencode "query=ai agents" \
  --data-urlencode "label=sponsored" \
  --data-urlencode "relevance=filter" \
  --data-urlencode "date_posted=past_week" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/post/transcript
Get a LinkedIn post video transcript
Credit cost: 10 (premium)
Parameters:
- url (required): Full URL of the LinkedIn post to transcribe.
curl -G "https://www.socialcrawl.dev/v1/linkedin/post/transcript" \
  --data-urlencode "url=https://www.linkedin.com/posts/gemini-35-flash-is-a-step-forward-for-google-ugcPost-7465082215316525056-MHBd/" \
  -H "x-api-key: YOUR_API_KEY"

## GET /v1/linkedin/profile/full
LinkedIn company profile, recent posts, and computed analytics in one call. Company pages only; a member's profile is `/v1/linkedin/profile/all`.
Credit cost: 5 (override; tier standard)
Parameters:
- url (optional, string): Full LinkedIn company profile or page URL. One of the identity params is required.
- posts (optional, integer): How many of the fetched recent posts to return and compute the metrics over (1-100, default 25). One call reads one page, which on LinkedIn company is 10 posts, so a larger value returns that page and a `_warnings` note; pass posts_cursor back as cursor for the next page.
- cursor (optional, string): Pass a prior response's posts_cursor to read the next page of posts. Each call is a separate 5-credit call whose metrics cover that page only.
- include (optional, string): CSV subset of posts,computed (default both). include=computed omits the raw posts[] array from the response to save payload. The metrics are computed from the same fetched posts either way, so they do not change.
- Constraint: one of url (at least one required)
curl -G "https://www.socialcrawl.dev/v1/linkedin/profile/full" \
  --data-urlencode "url=https://www.linkedin.com/company/microsoft" \
  -H "x-api-key: YOUR_API_KEY"