Threads User Posts Scraper With Creator Contact Leads

Threads Scraper — Extract Posts, Creator Contacts and Bio Data

Threads User Posts Scraper With Creator Contact Leads collects a Threads creator's public posts and enriches every row with an outreach-ready contact block — bio email, phone, website, follower count, full name, and the verified badge. Unlike scraping frameworks that return raw HTML, the Actor returns typed JSON, ready for your CRM, spreadsheet, or outreach pipeline without any parsing. Paste one or more Threads profile URLs or plain @handles, set how many recent posts you want per creator, and rows stream into your dataset live as each profile finishes. This guide documents every input and output field, and how outreach, research, and monitoring teams actually run it.

🧭 What Does Threads User Posts Scraper With Creator Contact Leads Do?

Threads User Posts Scraper With Creator Contact Leads is an Apify Actor that opens a public Threads profile, reads the posts and profile data Threads serves through its own internal GraphQL feed, and returns one row per post — each carrying that creator's contact block. No Threads account, login, or session cookie is required or accepted as input; every field returned is already visible to a logged-out visitor on threads.com.

Core capabilities:

• Scrapes public Threads posts for one or many creators from a bulk list of profile URLs or @handles
• Returns up to 5,000 of the most recent posts per creator, paginating through the feed automatically
• Builds a per-creator contact block — creatorEmail, creatorPhone, creatorWebsite (plus the full lists behind each), mined from the creator's public bio text and bio link fragments
• Adds creatorFollowerCount, creatorIsVerified, creatorFullName, and creatorBio to every row from the same lightweight profile lookup
• Optional contacts-only filter that skips creators whose bio exposes no email, phone, or website, so the output is a clean, contactable lead list
• Falls back through Apify Datacenter, then Residential proxy (three rotated sessions), when Threads blocks a direct request

⚡ Features & Capabilities

The Actor's feature set covers three areas: what it extracts, how it holds up against other Threads scrapers, and where it sits inside the wider Scrapio Threads toolkit.

Core features

• Post extraction — caption, like_count, direct_reply_count, quote_count, repost_count, medias, audio, mentions, tags, code, absolute url, and both a local (taken_at) and UTC ISO-8601 (taken_at_iso) timestamp for every post
• Creator contact block — creatorEmail (+ creatorEmails, every match found), creatorPhone (+ creatorPhones), creatorWebsite (+ creatorWebsites), plus creatorEmailIsBusiness — a corporate-vs-personal-inbox flag based on the domain
• Profile signals on every post row — creatorFollowerCount, creatorIsVerified, creatorFullName, creatorBio, creatorProfilePicUrl, and creatorHasContact (true when any email, phone, or website was found)
• Contacts-only filter — contactsOnly drops any creator with no bio contact entirely, rather than returning their posts with empty contact fields
• Bulk input — profileUrls accepts one creator or thousands per run; plain @handle strings, full profile URLs, and legacy {"url": "..."} objects all normalize the same way
• Honest, regex-based extraction — creatorEmail, creatorPhone, and creatorWebsite return null, never a fabricated value, when nothing is found in the bio
• Proxy escalation — direct connection first, then Apify Datacenter, then Residential with up to three rotated sessions, when Threads returns a blocked or error response

⚠️ Coverage caveat: creatorFollowerCount, creatorIsVerified, creatorFullName, and creatorBio populate on essentially every public profile the lookup succeeds on. creatorEmail, creatorPhone, and creatorWebsite populate only when the creator actually put that information in their own public bio — most creators do not. Expect a real hit rate below 100% on the contact fields, and honest nulls otherwise.

How Threads User Posts Scraper With Creator Contact Leads compares to other Threads scrapers

Feature	Threads User Posts Scraper With Creator Contact Leads	apibox/threads-user-posts-scraper	constructive_calm/threads-scraper
Entity coverage	Posts + a per-creator contact block in one row	Posts only (per listing, checked 26 Jul 2026)	Profiles, posts, discussion trees, search, and hashtag feeds (per listing, checked 26 Jul 2026)
Creator bio contact extraction (email/phone/website)	✅ Built in, on by default	❌ Not documented	✅ Documented as a premium paid event (per listing, checked 26 Jul 2026)
Contacts-only clean-list filter	✅ contactsOnly skips creators without a bio contact	❌ Not documented	❌ Not documented
Output format	JSON (Apify dataset)	JSON, XML, CSV, Excel, HTML (per listing, checked 26 Jul 2026)	JSON (Apify dataset)
Login required	❌ No — fully logged-out	Not documented	❌ No — logged-out endpoint (per listing, checked 26 Jul 2026)
Proxy / anti-bot handling	Direct first, auto-escalates to Apify Datacenter then Residential (3 rotated sessions)	Not documented	Not documented as proxy-based (per listing, checked 26 Jul 2026)
Pricing model	Pay-per-event (row_result)	Flat price per month (per Apify Store listing data, checked 26 Jul 2026)	Pay-per-event, with a documented free tier of the first 50 chargeable events per run (per listing, checked 26 Jul 2026)

If your use case is feeding structured data to an LLM, the output format row is the decision-maker — HTML parsing inside an agent loop is a reliability failure mode, not a feature. All three Actors here return (or can return) JSON through the Apify dataset; the real differentiator is that this Actor bundles a bio-mined contact block onto every post row by default, rather than as a separate profile lookup or a paid add-on.

When another tool might suit you better

If you need Threads discussion trees (a post plus every public quote-repost referencing it), keyword search feeds, hashtag feeds, or incremental "new posts since last run" monitoring, constructive_calm/threads-scraper documents all of those modes in one Actor — this Actor is scoped to posts-by-creator plus contact enrichment and does not fetch discussion trees, search, or hashtag results. If you only need raw post history with no contact enrichment at all and want the smallest possible input surface, apibox/threads-user-posts-scraper is a narrower, posts-only alternative.

Threads User Posts Scraper With Creator Contact Leads within the Scrapio data stack

Threads User Posts Scraper With Creator Contact Leads covers per-creator posts and bio-mined contact leads. For overlap analysis across multiple creators' follower bases, use Threads Follower Overlap Finder. For contact-lead extraction on other platforms, see the cross-platform tools listed under Related Scrapers below.

Why do developers and data teams scrape Threads?

🏢 Influencer marketing and partnerships teams

A brand or agency vetting creators for a campaign feeds a shortlist of profileUrls into a single run and gets back each creator's recent posts alongside creatorEmail, creatorPhone, creatorWebsite, creatorFollowerCount, and creatorIsVerified in the same row. Instead of DMing a creator through Threads and waiting on a reply, the team can filter on creatorHasContact and reach out directly through whichever channel the creator listed in their own bio, while like_count and direct_reply_count on recent posts give a quick read on whether the creator's audience is actually engaged before an offer goes out.

📊 AI training data and RAG indexing

caption and creatorBio carry the free-text language creators use about their content and themselves, which is what makes this data useful for AI systems beyond a plain contact list. For RAG enrichment, indexing caption alongside creatorFullName and creatorBio lets an agent answer questions like "what has this creator posted about recently" against live text rather than a stale training snapshot. For training data, like_count, direct_reply_count, quote_count, repost_count, and creatorFollowerCount are the fields with the most consistent numeric structure across every row.

📱 Competitive and market intelligence

Social and growth teams tracking a competitor's creator partnerships or a niche's top voices can re-run the same profileUrls list on a schedule and track creatorFollowerCount and engagement fields (like_count, repost_count, quote_count) over time — a fast-growing follower count or a sudden spike in repost_count on a specific caption topic is a signal worth investigating before it shows up in broader coverage.

🔬 Research and academic use

Researchers studying creator communication patterns or platform engagement dynamics can sample public profiles and analyze caption text, posting cadence from taken_at_iso, and engagement fields across a defined set of creators. Only publicly accessible profile and post data is returned — there is no access to private accounts, direct messages, or any content beyond what a logged-out visitor already sees.

🎥 Product and SaaS development

Teams building a creator-discovery, influencer-CRM, or lead-enrichment product can use this Actor as the backend call behind a "look up this creator" feature — feed in a profileUrls list a user submits, return the contact block and recent posts in the response. Because creatorEmail, creatorPhone, and creatorWebsite return null rather than a guess when nothing is found, a product built on top of this data can honestly represent partial coverage instead of showing a false positive to its own users.

🍚 Input Parameters

All input types below are read directly from .actor/actor.json. None are required — the Actor logs an error and exits if profileUrls is empty.

Parameter	Required	Type	Description	Example Value
profileUrls	No	array	The Threads creators to collect from. Paste profile links (threads.com / threads.net) or plain @handles — one per line, bulk lists welcome.	["https://www.threads.com/@zuck", "thedad"]
postsPerCreator	No	integer	How many recent posts to save for each creator. Minimum 1, maximum 5000, default 10. Lower is faster, higher goes deeper into history.	10
extractCreatorContacts	No	boolean	Add a per-creator contact block to every post row — bio email, phone, website, follower count, full name, and verified badge. Default true. One extra lightweight profile lookup per creator. Turn off to return posts only.	true
contactsOnly	No	boolean	When on, skip creators whose public bio has no email, phone, or website, so the output is a clean contactable-lead list. Default false. Enabling this turns on contact extraction automatically, even if extractCreatorContacts is off.	false
proxyConfiguration	No	object	Optional. The Actor talks to Threads directly first and auto-escalates to Apify Datacenter, then Residential, if traffic is blocked. Expand only to force a specific proxy group, country, or session. Leaving useApifyProxy: false is the recommended default.	{"useApifyProxy": false}

The base Actor's legacy key names are still accepted underneath the newer ones: urls is read if profileUrls is absent, and maxPostsPerProfile is read if postsPerCreator is absent. ⚠️ One source-level quirk: if postsPerCreator is missing from the input entirely (not just left at its schema default — genuinely absent from the JSON, which happens if the Actor is invoked programmatically without schema validation applying the default), the code's own fallback value is 20, not the schema's documented default of 10. Runs started from the Apify Console or a standard API call that leaves the field untouched will always see 10, since Apify applies the schema default before the Actor runs.

Example input

{
  "profileUrls": ["https://www.threads.com/@zuck", "thedad"],
  "postsPerCreator": 10,
  "extractCreatorContacts": true,
  "contactsOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

Supported URL types and input formats

profileUrls accepts three input shapes, all normalized to a lowercase Threads username by the same function:

1. Full profile URL on either domain — https://www.threads.com/@zuck or https://www.threads.net/@zuck — the @handle is extracted with a regex matching either host.
2. @handle prefix — @zuck has the leading @ stripped.
3. Plain username — zuck is used as-is, lowercased and trimmed of any leading/trailing slash.

{"url": "..."} objects inside the array are also accepted, matching the base Actor's convention — the url key is read and normalized the same way as a plain string. An empty or unresolvable entry is skipped with a logged warning rather than sent as a request.

📦 Output Format

Every result is typed, normalized JSON with a consistent field set across runs. Export the dataset as JSON, JSONL, CSV, Excel (XLSX), XML, RSS, or HTML directly from the Apify Console, or read it through the Apify API.

Output for the post + creator contact row

Each dataset row is one post, always carrying the full creator contact block alongside it — even when extractCreatorContacts is off, in which case the contact fields are present but null/false rather than omitted.

{
  "username": "thedad",
  "creatorFullName": "The Dad",
  "creatorEmail": "hey@thedad.com",
  "creatorEmails": ["hey@thedad.com"],
  "creatorPhone": null,
  "creatorPhones": null,
  "creatorWebsite": null,
  "creatorWebsites": null,
  "creatorFollowerCount": 128000,
  "creatorIsVerified": true,
  "creatorProfilePicUrl": "https://instagram.fxyz1-1.fna.fbcdn.net/...",
  "creatorBio": "Welcome to the club. 📧 hey@thedad.com",
  "creatorEmailIsBusiness": true,
  "creatorHasContact": true,
  "profile_pic_url": "https://instagram.fxyz1-1.fna.fbcdn.net/...",
  "id": "3220231147841639674_314216",
  "pk": "3220231147841639674",
  "code": "Cywjyrdv9T6",
  "caption": "Good conversation about science, AI, and mixed reality.",
  "caption_is_edited": false,
  "like_count": 1234,
  "direct_reply_count": 56,
  "quote_count": 3,
  "repost_count": 12,
  "like_and_view_counts_disabled": false,
  "audio": null,
  "medias": [{ "type": "image", "url": "https://...", "width": 1080, "height": 1080 }],
  "tags": null,
  "mentions": [{ "username": "hubermanlab", "profile_pic_url": "https://...", "id": "..." }],
  "taken_at": "2026-07-15 18:20:00",
  "taken_at_iso": "2026-07-15T18:20:00Z",
  "url": "https://www.threads.net/@thedad/post/Cywjyrdv9T6",
  "scrapedAt": "2026-07-16T10:00:00Z"
}

This is the full row — all 33 keys the Actor writes. ⚠️ The dataset's default view (Posts + contacts table) surfaces 28 of them; it omits caption_is_edited, like_and_view_counts_disabled, creatorEmails, creatorPhones, and creatorWebsites. Those five fields are still written to every row — switch to the JSON/CSV export or read the dataset through the API if you need them, rather than assuming the console table has every field.

Schema stability and export options

Field names stay stable across runs. The Actor authenticates each request with tokens (doc_id, Relay provider keys, the LSD token, the alias the response is nested under) that it extracts fresh from Threads' own live JavaScript bundle on every run, rather than hardcoding them — so when Meta rotates these internal values, as it does periodically, the Actor keeps working without a code change on your end. Contact fields (creatorEmail, creatorPhone, creatorWebsite and their plural forms) are always present as keys and return null rather than being dropped when nothing is found in the bio. Export the finished dataset as JSON, JSONL, CSV, Excel, XML, RSS, or HTML from the Apify Console, or pull it through the Apify API into your own pipeline.

💡 Threads User Posts Scraper With Creator Contact Leads Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

When a new creator enters your outreach pipeline — a lead submits their handle, a rep flags a profile, or a monitoring tool surfaces one — trigger a single-profile run with profileUrls set to that one handle and postsPerCreator set low (e.g. 5) since you only need the contact block, not deep history. Read creatorEmail, creatorPhone, creatorWebsite, creatorFollowerCount, and creatorIsVerified off the first returned row and write them back to your CRM or lead-scoring table, keyed on username. Because contact fields return null rather than a guess when nothing is found, your enrichment step can safely skip a write instead of polluting the record.

🎯 Strategy 2: Scheduled monitoring and alerting

Run the Actor on a fixed creator watchlist through an Apify Schedule, then diff each run's creatorFollowerCount and creatorHasContact per username against the previous run's dataset. A follower count that jumps sharply, or a creator who newly exposes a bio contact, is worth an alert — both often mean the creator just became a more attractive (or more reachable) partnership target. like_count and repost_count on the newest posts are useful secondary signals for a sudden engagement spike worth investigating.

🎯 Strategy 3: Bulk dataset build

For a research dataset or a full outreach list, paste the entire creator list into profileUrls in one run — bulk input is supported natively, and turning on contactsOnly keeps the output to a clean, contactable subset. Creators are processed one at a time, with a short randomized delay between paginated requests for the same creator; there is no documented concurrency parameter, so a large list takes proportionally longer than a single creator rather than finishing at a fixed rate. Export the finished dataset as CSV directly from the Apify Console once the run completes.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	CRM/lead enrichment on a single new creator	On-demand single-profile run, triggered per lead	JSON row read directly from the API response
Scheduled monitoring	Detecting follower growth or new bio contacts on a watchlist	Recurring Apify Schedule run, diffed against the prior dataset	JSON rows, diffed by username
Bulk dataset build	Research or outreach lists across many creators	One run, bulk profileUrls input, processed sequentially	CSV/JSON export from the Apify Console

🌴 Related Threads Scrapers & Tools

Other Scrapio scrapers for Threads:

Scraper Name	What it extracts
Threads Follower Overlap Finder	Follower overlap analysis across multiple Threads creators

Cross-platform alternatives for the same entity type (contact-lead generation):

Scraper Name	What it extracts
Instagram Phone Lead Validator	Validates and extracts phone-number leads from Instagram profile data
Snapchat Profile Scraper (Email & Phone Leads)	Bio-mined email and phone leads from Snapchat profiles
YouTube Channel Contact Extractor	Contact details mined from YouTube channel about pages
Google News Scraper (Publisher Contact Leads)	Publisher contact leads alongside news article data

How to integrate Threads User Posts Scraper With Creator Contact Leads with your stack

Threads User Posts Scraper With Creator Contact Leads works with any language or tool that can make an HTTP request.

Python

from apify_client import ApifyClient
import csv

client = ApifyClient("<YOUR_APIFY_TOKEN>")

profile_urls = ["https://www.threads.com/@zuck", "thedad"]

run = client.actor("<YOUR_USERNAME>/threads-user-posts-scraper-with-creator-contact-leads").call(run_input={
    "profileUrls": profile_urls,
    "postsPerCreator": 10,
    "extractCreatorContacts": True,
    "contactsOnly": False,
})

rows = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    rows.append({
        "username": item["username"],
        "creatorFullName": item["creatorFullName"],
        "creatorEmail": item["creatorEmail"],
        "creatorPhone": item["creatorPhone"],
        "creatorWebsite": item["creatorWebsite"],
        "creatorFollowerCount": item["creatorFollowerCount"],
        "caption": item["caption"],
        "like_count": item["like_count"],
    })

with open("threads_creator_leads.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('<YOUR_USERNAME>/threads-user-posts-scraper-with-creator-contact-leads').call({
    profileUrls: ['https://www.threads.com/@zuck', 'thedad'],
    postsPerCreator: 10,
    extractCreatorContacts: true,
    contactsOnly: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const row of items) {
    console.log(row.username, row.creatorEmail, row.creatorPhone, row.like_count, row.caption);
}

Async and scheduled pipelines

For large creator lists, start the run through the Apify API and poll the run status or dataset item count instead of waiting on a blocking call. The Actor has no delivery mechanism of its own beyond the dataset, but Apify's platform-level webhooks can still fire on run completion for any Actor. For a recurring lookup — a weekly refresh of a creator watchlist, for example — set up an Apify Schedule against a fixed profileUrls list rather than triggering runs manually.

🎯 Who Needs Threads User Posts Scraper With Creator Contact Leads? (Use Cases & Industries)

🏢 Influencer marketing and partnerships teams

An agency vetting dozens of Threads creators for a campaign runs them all in one bulk request with contactsOnly on, then reaches out directly using creatorEmail or creatorWebsite — turning a manual "DM and hope for a reply" workflow into a direct-contact list ready for outreach the same morning.

📊 Analysts and RAG engineers

A market-research team indexing creator activity for a client-facing tool pulls caption and creatorBio into a vector store alongside creatorFollowerCount, so a chat interface can answer "what has this creator been posting about" against live text instead of a stale scrape done months ago.

📱 Competitive intelligence teams

A brand team tracking a competitor's creator partnerships runs this Actor weekly against a known list of profileUrls and diffs creatorFollowerCount and recent caption topics — a sharp follower jump or a new recurring topic is an early signal the competitor is investing in that creator relationship.

🔬 Researchers

Academic researchers studying creator communication or platform engagement dynamics sample public profiles and compare like_count, direct_reply_count, quote_count, and repost_count against posting cadence (taken_at_iso) across a defined set. Only public profile and post data is returned; there is no access to private accounts or direct messages.

🎥 Lead-gen and CRM tool builders

Teams building a creator-discovery or influencer-CRM product use this Actor as the backend enrichment call behind a "look up this creator" feature, returning the contact block directly in an API response to their own users without hosting any scraping infrastructure themselves.

Is it legal to scrape Threads?

Scraping publicly accessible Threads data is generally permissible. U.S. courts have held that accessing data a site makes available to anyone, logged out, does not by itself violate the Computer Fraud and Abuse Act (hiQ Labs, Inc. v. LinkedIn Corp., 9th Cir., 2019). That precedent concerns public-data access, not Meta's own Terms of Service, which separately restrict automated scraping — violating a platform's ToS is a civil contract matter, not a criminal one, but it is still a real risk to weigh before running this at scale.

The data protection question matters most for this Actor: a creator's full name, bio, and any email, phone number, or website extracted from it are personal data. Threads User Posts Scraper With Creator Contact Leads returns only what is already visible on a public profile to any logged-out visitor — it does not access private accounts, and every contact field returns null rather than a guess when nothing is found. What you do with that data afterward — storage, further processing, or outreach — is your responsibility, and GDPR, CCPA, or your local equivalent will generally apply to any personal data you collect. Consult legal counsel before using this data for commercial outreach.

❓ Frequently asked questions

Does Threads User Posts Scraper With Creator Contact Leads work without a Threads account?

Yes. The Actor makes anonymous, logged-out requests to a creator's public profile page and Threads' GraphQL feed endpoint — no Threads account, password, or session cookie is accepted or required as input. All authentication tokens it needs (app_id, csrf_token, the LSD token, the GraphQL doc_id) are extracted from the public profile page itself on each run.

How does it handle Threads' anti-scraping measures?

Requests go direct to threads.com first. If Threads returns a blocked or error response, the Actor switches to an Apify Datacenter proxy for the rest of the run; if that is also blocked or unavailable, it escalates to Apify Residential and retries up to three times with a fresh rotated session each time. Individual GraphQL requests retry with exponential backoff (capped at 30 seconds without a proxy, 15 seconds during residential retries) before the Actor gives up on that attempt.

Can I run it at scale without getting blocked?

There's no documented uptime or success-rate figure for this Actor. What's implemented is the proxy escalation described above, plus a page size that's automatically reduced from up to 25 posts per request down to 15 once a proxy is in use, and a short randomized pause between paginated requests for the same creator. Once a run escalates to Datacenter or Residential, it stays on that tier for the remainder of the run rather than repeatedly retrying direct.

How fresh is the data it returns?

Live. Every run fetches the creator's current profile and post feed fresh from Threads — nothing is cached or served from a prior run. If a creator has posted, updated their bio, or gained followers since your last run, the new run reflects it.

Which fields work best for AI training and RAG indexing?

For RAG: caption and creatorBio carry the most descriptive natural-language text per row. For training data: like_count, direct_reply_count, quote_count, repost_count, and creatorFollowerCount are the most structurally consistent numeric fields across every row. All fields return as typed strings, integers, booleans, or arrays with fixed defaults — no normalization pass is required before indexing.

Does the Actor store or share the personal data it collects?

No. The Actor writes only to your own Apify dataset for that run; it doesn't retain, share, or reuse the data elsewhere. Because the output includes a creator's name, bio, and — where found — email, phone number, and website, treat it as personal data in your own systems. The Actor returns publicly available information, but the lawful basis for storing and using it is yours to establish.

Does it work with Claude, ChatGPT, and other AI agent tools?

Yes, as a standard HTTP endpoint. There's no MCP server documented specifically for this Actor. The verified integration path is the Apify API — callable by any agent framework that can make an HTTP request, such as LangChain, CrewAI, or a custom tool definition — with every response returned as typed JSON, no parsing required before it enters an LLM context window.

How does it compare to other Threads scrapers?

Checked on the Apify Store on 26 July 2026: apibox/threads-user-posts-scraper is a narrower posts-only scraper with no documented contact or bio enrichment, but its listing documents CSV, XML, Excel, and HTML export alongside JSON. constructive_calm/threads-scraper covers more entity types in one Actor — profiles, discussion trees, search, and hashtag feeds alongside posts — and documents bio contact extraction as a paid add-on event. Neither documents a contacts-only clean-list filter or a proxy-escalation strategy for direct requests. This Actor's difference is scope: posts-by-creator with a bio-mined contact block built in by default, at the cost of not covering discussion trees, search, or hashtag feeds at all.

What happens if a creator's bio has no email, phone, or website?

The post rows are still returned in full; creatorEmail, creatorPhone, and creatorWebsite (and their plural forms) simply come back null, and creatorHasContact is false. If contactsOnly is on, that creator is skipped entirely — no post rows are written for them, and the skip is logged rather than silent.

ℹ️ Disclaimer

Threads User Posts Scraper With Creator Contact Leads extracts only publicly available data from Threads — the same posts and profile bio information any logged-out visitor can see. This tool is intended for lawful use cases only. Users are responsible for complying with Threads' and Meta's Terms of Service and applicable data protection laws, including GDPR and CCPA where they apply, in their jurisdiction.