Threads reactions API

Parameters from the 2026-10-25 specification snapshot; response rows checked against live responses on 2026-11-21

Quick answer

POST /threads/reactions/task with a post URL starts an asynchronous task that collects the reactions to that post. Poll GET /threads/reactions/task/{task_id}: while the task runs it reports the status and counters, and once it is DONE the response has a task object with the post's view_count, like_count and share_count, a data list of reactions (each with its type, for example LIKE, and the reacting account) and pagination, with up to 1000 rows per page. Add mask_author=true to the poll request to remove author identity fields from the response. Data is collected by web crawlers from content publicly published on Threads.

What teams use it for

  • Measure how a post performed: views, likes and shares from one task.
  • Compare reaction volume across a set of posts found by keyword search.
  • Collect reaction data with author fields masked when you only need counts and types.

Endpoints

Base URL: https://api.infominer.io/api/v2. Send your API key in the auth-header request header.

MethodPathWhat it does
POST /threads/reactions/task Creates a reactions collection task from a post URL; rerun defaults to true.
GET /threads/reactions/task/{task_id} Polls a reactions task; on success it returns the reactions list with pagination.

Request parameters

POST /threads/reactions/task

ParameterInTypeRequiredDefault / allowedDescription
post_url body string Yes Threads post URL whose reactions you want.
mask_author body boolean No false Set to true to remove author identity fields from this response. Send it on each GET poll to mask the returned rows.
rerun body boolean No true Defaults to true: sending the same post_url again starts a fresh task.

GET /threads/reactions/task/{task_id}

ParameterInTypeRequiredDefault / allowedDescription
task_id path string Yes Task ID returned when the task was created.
mask_author query boolean No false Set to true to remove author identity fields from this response. Send it on each GET poll to mask the returned rows.
page query integer No Page number, starting at 1.
per_page query integer No max 1000 Reactions per page, max 1000.

Response fields

DataFieldsEndpoint
Reactions task: status, post_id, view_count, like_count, share_count, total, completed; data: id, post_id, type, author, author_id, updated_at; pagination: page, per_page, total_count, total_pages, has_next, has_prev; error_message GET /threads/reactions/task/{task_id}

Code examples

curl: create the task

curl -X POST https://api.infominer.io/api/v2/threads/reactions/task \
  -H "auth-header: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"post_url": "https://www.threads.com/@sample_user_1/post/00000000001", "mask_author": false}'

curl: poll the task by ID

curl "https://api.infominer.io/api/v2/threads/reactions/task/$TASK_ID?page=1&per_page=1000" \
  -H "auth-header: YOUR_API_KEY"

Python (requests): create, poll, read

import time
import requests

BASE_URL = "https://api.infominer.io/api/v2"
HEADERS = {"auth-header": "YOUR_API_KEY"}

# 1. Create the task
resp = requests.post(
    f"{BASE_URL}/threads/reactions/task",
    headers=HEADERS,
    json={
        "post_url": "https://www.threads.com/@sample_user_1/post/00000000001",
        "mask_author": False,
    },
    timeout=30,
)
resp.raise_for_status()
task = resp.json()

# 2. Poll until the task leaves INIT / RUNNING
for _ in range(120):
    resp = requests.get(
        f"{BASE_URL}/threads/reactions/task/{task['id']}",
        headers=HEADERS,
        params={
            "page": 1,
            "per_page": 1000,
        },
        timeout=30,
    )
    resp.raise_for_status()
    result = resp.json()
    status = result.get("status") or result.get("task", {}).get("status")
    if status not in ("INIT", "RUNNING"):
        break
    time.sleep(15)
else:
    raise SystemExit("task still running; poll it again later")

if status == "FAILED":
    raise SystemExit("task failed")
if status != "DONE":
    print("task ended with status", status, "- results may be incomplete")

# 3. Read the records (use page / per_page to fetch further pages)
if result.get("error_message"):
    raise SystemExit(result["error_message"])
for row in result.get("data", []):
    print(row.get("type"), row.get("author"))

Sample response

Illustrative data written by hand: accounts are sample_user_n and IDs are obviously fake. Field names follow live API responses checked on 2026-11-21; the sample shows a subset of the fields.

Poll response once the task is DONE (illustrative data)

{
  "task": {
    "id": "00000000-0000-4000-8000-000000000001",
    "status": "DONE",
    "post_url": "https://www.threads.com/@sample_user_1/post/00000000001",
    "post_id": "0000000000000000001",
    "view_count": 1250,
    "like_count": 2,
    "share_count": 1,
    "total": 2,
    "completed": 2,
    "partial": false,
    "timed_out": false,
    "failed_articles": 0,
    "failed_pages": 0
  },
  "data": [
    {
      "id": "00000000-0000-4000-8000-000000000007",
      "post_id": "0000000000000000001",
      "type": "LIKE",
      "author": "sample_user_3",
      "author_id": "0000000003",
      "updated_at": 1781143200
    },
    {
      "id": "00000000-0000-4000-8000-000000000008",
      "post_id": "0000000000000000001",
      "type": "LIKE",
      "author": "sample_user_4",
      "author_id": "0000000004",
      "updated_at": 1781143200
    }
  ],
  "pagination": {
    "page": 1,
    "per_page": 1000,
    "total_count": 2,
    "total_pages": 1,
    "has_next": false,
    "has_prev": false
  }
}

Limits and notes

  • per_page is capped at 1000.
  • post_id on a reactions response is the numeric Threads post ID, not the URL code that search and timeline rows return as post_id; join on post_url.
  • rerun defaults to true, so sending the same post_url again starts a fresh task.
  • If the task succeeded but the list could not be fetched, the response carries error_message.
  • Volume per post and refresh frequency are confirmed per project scope.
Collection: web crawlers collect content publicly published on each platform. Whether this suits your use depends on the purpose and jurisdiction and is for the buyer's legal team to assess; we can provide a description of sources and collection methods.

More Threads API pages

Request a trial

In the request form below, mention Threads and tell us the keywords or accounts, whether you need replies and reactions, and whether author fields should be masked. We confirm the scope and reply with the arrangements for the trial and API key.

Fill in the form to request a trial. We confirm the scope and reply with trial and integration arrangements.

Fill in the request form

FAQ

Which counts does the reactions task return?
The task object reports view_count, like_count and share_count for the post, and pagination.total_count gives the number of reaction rows.
How do I page through the reactions?
Use page and per_page on the GET request. per_page can go up to 1000, and pagination reports has_next and total_pages.
Can I leave the reacting accounts out?
Yes. Add mask_author=true to each GET poll request to remove author identity fields from that response.
How is the data collected? Is this the official Threads API?
By web crawlers, from content publicly published on Threads. LargitData is not affiliated with Meta or Threads, and this is not Meta's Threads API. Whether this suits your use depends on the purpose and jurisdiction and is for your legal team to assess; we can provide a description of sources and collection methods.