LinkedIn Reactions

Run as an Apify Actor. Scrape every reaction on any LinkedIn post.

Quickstart (Apify API)

# Trigger the actor with the Apify API
curl -X POST "https://api.apify.com/v2/acts/atomus~linkedin-reactions-scraper-pro/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ }'

What it does

Get every reaction on a LinkedIn post with the full profile of whoever reacted. Page through up to ~1,200 reactions per post (LinkedIn's public list cap). Optional filters tag entries via matches_filters but never reduce the page count. 1 credit per page (100 reactions).

Endpoint

POST https://api.atomusapi.dev/v1/linkedin-reactions/extract

Authentication

Send your API key as a Bearer token in the Authorization header. Keys are scoped to a single tenant.

Authorization: Bearer atm_live_xxxxxxxxxxxxxx — or X-RapidAPI-Proxy-Secret: <secret> when calling through the RapidAPI gateway

Idempotency

Send Idempotency-Key: <uuid> to make a request safely retryable. Atomus stores the response for 24h and replays it on retries with the same key.

Input

Output

Example request

curl -X POST "https://api.atomusapi.dev/v1/linkedin-reactions/extract" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7404946870776868864/"
  }'

// Atomus Bearer auth. Pass cursor on subsequent calls to paginate.
async function* extractAllReactions(postUrl) {
  let cursor;
  do {
    const res = await fetch(
      "https://api.atomusapi.dev/v1/linkedin-reactions/extract",
      {
        method: "POST",
        headers: {
          "Authorization": "Bearer YOUR_API_KEY",
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ postUrl, cursor }),
      }
    );

    if (!res.ok) {
      const { error } = await res.json();
      throw new Error(`${error.code}: ${error.message}`);
    }

    const { data } = await res.json();
    for (const r of data.reactions) yield r;
    cursor = data.pagination.cursor;
  } while (cursor);
}

for await (const r of extractAllReactions(
  "https://www.linkedin.com/feed/update/urn:li:activity:7404946870776868864/"
)) {
  if (r.matches_filters) console.log(r.reactor.name, "—", r.reactor.headline);
}

import requests

# Atomus Bearer auth. Pass cursor on subsequent calls to paginate.
def extract_all_reactions(post_url, api_key):
    cursor = None
    while True:
        res = requests.post(
            "https://api.atomusapi.dev/v1/linkedin-reactions/extract",
            headers={
                "Authorization": f"Bearer {api_key}",
                "Content-Type": "application/json",
            },
            json={"postUrl": post_url, "cursor": cursor},
            timeout=60,
        )
        if not res.ok:
            err = res.json()["error"]
            raise RuntimeError(f"{err['code']}: {err['message']}")
        data = res.json()["data"]
        for r in data["reactions"]:
            yield r
        cursor = data["pagination"]["cursor"]
        if not cursor:
            break

for r in extract_all_reactions(
    "https://www.linkedin.com/feed/update/urn:li:activity:7404946870776868864/",
    "YOUR_API_KEY",
):
    if r["matches_filters"]:
        print(r["reactor"]["name"], "—", r["reactor"]["headline"])

# RapidAPI gateway auth. Use this when calling the API through your
# RapidAPI subscription instead of an Atomus account. RapidAPI bills
# the consumer at the gateway; the response reports mode="rapidapi"
# and credits_used=0.
curl -X POST "https://api.atomusapi.dev/v1/linkedin-reactions/extract" \
  -H "X-RapidAPI-Proxy-Secret: YOUR_RAPIDAPI_PROXY_SECRET" \
  -H "Content-Type: application/json" \
  -d '{
    "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7404946870776868864/"
  }'

# Metadata-only mode. Returns just the post's total reaction count
# without extracting individual reactors. RapidAPI: 1 reaction unit;
# Atomus: 1 credit. Useful as a cheap pre-check before committing to
# a full scrape — e.g. compare against a previous total to decide
# whether new reactions arrived since last run.
curl -X POST "https://api.atomusapi.dev/v1/linkedin-reactions/extract" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7404946870776868864/",
    "metadataOnly": true
  }'

Errors & limits

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Human-readable explanation.",
    "retryable": true,
    "request_id": "req_01HXXX..."
  }
}

• unauthenticated HTTP 401 : Missing or malformed Authorization header. (do not retry)
• invalid_api_key HTTP 401 : API key is not recognized or has been revoked. (do not retry)
• insufficient_credits HTTP 402 : Atomus tenant credit balance is below 1. Not raised for requests authenticated via the RapidAPI gateway (those are billed by RapidAPI). (do not retry)
• invalid_input HTTP 400 : Request body is not valid JSON, or the cursor is malformed (must be the opaque token returned by a prior call). (do not retry)
• validation_failed HTTP 422 : postUrl is missing, longer than 500 chars, or the upstream API rejected it as not a valid public LinkedIn post. (do not retry)
• rate_limit_exceeded HTTP 429 : Sustained request rate exceeded the tenant limit. (retryable)
• upstream_error HTTP 502 : Upstream provider returned a non-success response. (retryable)
• upstream_timeout HTTP 504 : Upstream provider did not respond within the time budget. (retryable)
• internal_error HTTP 500 : Unexpected server error. (retryable)

Rate limits

5 requests/second per account (shared across all API keys on the same account). Each request fetches one upstream page (up to 100 reactors). Bursts above the limit return 429 rate_limit_exceeded; back off using the response headers. The per-second window is enforced server-side; the per-minute, per-hour, per-day, per-week, and per-month rows are sustained-throughput derivations.

• x-ratelimit-limit: max requests per second for the account (shared across all keys)
• x-ratelimit-remaining: requests remaining in the current window
• x-ratelimit-reset: unix epoch (seconds) when the window resets

Billing

• $0.005 per reactor returned ($5 per 1,000) — billed as 1 Atomus credit per page (100 reactors) = $0.50 per page

Atomus mode (live): one credit reserved per call, settled at one credit on success regardless of how many reactions LinkedIn returned (filters tag entries via matches_filters but never reduce the page count). Errors before any upstream call refund the reservation. RapidAPI mode (X-RapidAPI-Proxy-Secret): RapidAPI bills the consumer at the gateway via the X-RapidAPI-Billing response header (Reactions quota object, $0.005 each); Atomus does not deduct credits and reports credits_used=0 with credits_remaining=null in the response meta.

Use the RapidAPI gateway. Per-reaction billing handled at the gateway, no Atomus account needed.

Quickstart (RapidAPI gateway)

# RapidAPI gateway authentication
curl -X POST "https://api.atomusapi.dev/v1/linkedin-reactions/extract" \
  -H "X-RapidAPI-Key: YOUR_RAPIDAPI_KEY" \
  -H "X-RapidAPI-Host: api.atomusapi.dev" \
  -H "Content-Type: application/json" \
  -d '{ }'