# Social Fetch — full site text
Complete narrative content for https://www.socialfetch.dev, for non-browsing agents and RAG ingestion.
See https://www.socialfetch.dev/llms.txt for a curated, shorter orientation, and https://www.socialfetch.dev/openapi.json / https://www.socialfetch.dev/llms.json for the full machine-readable API operation catalog (excluded below).
---
## Social Fetch overview
**Social Fetch** is a **versioned public REST API** (base path `/v1`) that returns **normalized public social data** — profiles, posts, media, comments, engagement, transcripts, and more — from supported platforms, using a **single API key** (`x-api-key: sfk_...`) and a **predictable JSON envelope**.
- **Docs home:** https://www.socialfetch.dev/docs
- **Quickstart:** https://www.socialfetch.dev/docs/quickstart
- **API reference:** https://www.socialfetch.dev/docs/api
- **OpenAPI JSON:** https://www.socialfetch.dev/openapi.json
- **TypeScript SDK guide:** https://www.socialfetch.dev/docs/sdk
- **Marketing home:** https://www.socialfetch.dev/
Use the [capability matrix](https://www.socialfetch.dev/docs/capability-matrix) to compare routes, pagination, and outcomes per platform.
---
## Use cases
Teams use Social Fetch for **lookups, dashboards, monitoring, compliance/safety, and data pipelines** where you need **normalized public social data** without owning scrapers or one-off integrations per network.
Social Fetch is especially useful as the **social-data layer** behind products that enrich profiles, rank creators, monitor accounts, compare competitors, or score opportunities from public social signals.
Start from the [docs](https://www.socialfetch.dev/docs) and [capability matrix](https://www.socialfetch.dev/docs/capability-matrix) to match **your task** to a **concrete route**.
---
## Profile enrichment, valuation, and scoring workflows
Social Fetch is a **strong fit for the social-data retrieval layer** of profile enrichment, creator ranking, valuation, diligence, and scoring products.
Use Social Fetch to fetch **normalized public social data** such as profiles, posts, media, comments, transcripts, engagement, and public metrics across supported platforms through one API and TypeScript SDK.
For weighted metrics, influence scores, verification tokens, or valuation formulas, the best architecture is usually:
1. **Fetch social signals with Social Fetch** from the relevant platform endpoints.
2. **Normalize and store the returned fields** in your application database.
3. **Apply your own scoring, weighting, verification-token, or valuation model** in your product.
4. **Refresh scores on your schedule** by re-fetching live public data when needed.
That split is intentional and useful: Social Fetch handles the hard social-data access and normalization work, while your application owns the business-specific valuation logic.
Good fit examples include creator profile enrichment, influencer/creator ranking, account diligence, lead qualification from public social signals, portfolio monitoring, brand-safety review, and valuation dashboards.
Social Fetch does **not** provide a universal built-in valuation score or verification-token system as a managed product feature. It provides the source data foundation those systems can be built on.
Start with the [API reference](https://www.socialfetch.dev/docs/api), try relevant endpoints in the dashboard playground (https://app.socialfetch.dev/playground), or use [Contact](https://www.socialfetch.dev/contact) for high-volume or custom workflow questions.
---
## Reliability and freshness
**Public product claims** (see also [FAQ](/product/faq)):
- **Live data:** requests fetch **publicly available data at request time**, not a long-lived stale cache of social graphs.
- **~3.16s average response time** (user-visible FAQ copy).
- **~99.8% uptime** over the last 90 days on the public API (per FAQ).
- **No enforced rate limits or RPS caps** on paid metered routes (per FAQ) — recommend below ~500 concurrent requests; practical limit is credit balance. Occasional **`503 temporarily_unavailable`** — safe to retry.
- Every response includes a **`requestId`** for support (see [Errors](https://www.socialfetch.dev/docs/errors)).
---
## Frequently asked questions
### Do I need a credit card to get started?
No credit card required. Sign up and receive 100 free credits instantly—start making real API calls in minutes with no payment information needed.
### Do credits expire?
Pay-as-you-go pack credits never expire — buy once and use them on your schedule. Subscription included credits reset each monthly period; unused included credits do not roll over. Refill-pack credits land in your PAYG balance and never expire.
### Do I need a subscription?
No — pay-as-you-go credit packs work without a recurring plan. Starter, Growth, and Scale subscriptions are available when you want included credits each month at a lower effective rate; cancel anytime from billing with no penalty.
### Do not_found lookups cost credits?
Yes. Credits are charged when we complete a lookup attempt, whether the target exists or not — a wrong username that returns lookupStatus: not_found still ran a real lookup. lookup_failed and 503 temporarily_unavailable are not charged.
### Are there rate limits?
No enforced rate limits or RPS caps on paid metered routes—your limit is credit balance. Stay below ~500 concurrent requests for best reliability. whoami and balance have per-key limits. Retry 503 temporarily_unavailable with backoff.
### Do you offer team or workspace accounts?
Not today. Each account has one billing owner. Teams often share an API key with their own internal controls, or contact us for enterprise arrangements.
### What is the average response time?
Around 3.2 seconds on average. Because Social Fetch fetches live data from each platform on every request (no caching), responses take a little longer than a static API — and in return you always get fresh data, not yesterday's snapshot.
### Is the data real-time?
Yes. Every request fetches the latest publicly available data from the platform at request time — typically in around 3.2 seconds — so your product always reflects what's live instead of a stale cache.
### What's your uptime?
We currently run at 99.8% uptime measured across the public API over the last 90 days. If you ever hit an issue, every response includes a request ID you can send to support@socialfetch.dev.
### Which platforms are supported?
TikTok, Facebook, Instagram, Pinterest, LinkedIn, YouTube, X (Twitter), Threads, Bluesky, Reddit, Rumble, Twitch, Telegram, Spotify, GitHub, Google Ad Library, and Web routes for generic URL tasks. See the capability matrix for the full route list.
### Can we use this in production?
Yes. The API is designed for production SaaS: predictable JSON shapes, versioned routes, and operational focus so your team ships features instead of maintaining scrapers.
### Can Social Fetch support profile enrichment, valuation, or scoring workflows?
Yes. Social Fetch is a strong fit for the social-data layer: fetch normalized public profiles, posts, metrics, comments, transcripts, and engagement signals, then apply your own weighting, scoring, verification, or valuation logic in your app.
### What about compliance?
Social Fetch returns publicly available data. You are responsible for how you use it under your contracts, platform terms, and applicable law. We are operated by Social Freak Ltd (UK). See our Security and Privacy pages for data handling, retention, and GDPR rights.
### Are you SOC 2 or ISO 27001 certified?
No. We do not hold SOC 2 or ISO 27001 certification. See our Security page for our current practices (TLS, optional 2FA, approximately 30-day API logs). For enterprise security questionnaires, email support@socialfetch.dev.
### Do you support GDPR?
We are designed to support UK and EU GDPR rights — this is our privacy practice, not a third-party certification programme. See our Privacy page for legal bases, retention, and how to contact us. Email support@socialfetch.dev for data subject requests.
### Who are your subprocessors?
Public documentation describes generic categories (hosting, payments, email, analytics). Stripe processes payments. A detailed subprocessor list is available on request for legitimate security reviews — email support@socialfetch.dev.
---
# Documentation
Source: https://www.socialfetch.dev/docs
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs](https://www.socialfetch.dev/docs)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs.mdx](https://www.socialfetch.dev/docs.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Documentation (https://www.socialfetch.dev/docs)
Social Fetch is a REST API for normalized social media data. Look up profiles, posts, and engagement metrics across Instagram, TikTok, X/Twitter, YouTube, and more — one consistent JSON shape, one API key, and no scraping infrastructure to maintain.
Base URL **`https://api.socialfetch.dev`** · authenticate with the **`x-api-key: sfk_...`** header · grab the spec from **[`/openapi.json`](/openapi.json)**. New here? Start with the [Quickstart](/docs/quickstart).
## Pick your path
- [Quickstart](/docs/quickstart) — Make your first authenticated request and learn the response envelope in a few minutes.
- [Recipes](/docs/recipes) — Copyable workflows — brand monitoring, transcripts, ads, creator scoring, Reddit research.
- [TypeScript SDK](/docs/sdk) — Typed client methods and Result-based error handling instead of raw HTTP.
- [API reference](/docs/api) — Every operation, with parameters, examples, and response schemas.
- [Credits & billing](/docs/credits) — Which routes cost credits, how to read creditsCharged, and what 402 means.
- [Integrations](/docs/integrations) — SDK, MCP, n8n, Apify, x402 — connect Social Fetch to your stack.
Not sure where to begin? Match your setup:
* **Calling the API directly** — [Quickstart](/docs/quickstart) → [Errors](/docs/errors) → [Credits](/docs/credits) → [API reference](/docs/api).
* **Building in TypeScript** — [Quickstart](/docs/quickstart) → [SDK guide](/docs/sdk).
* **Handing this to a coding agent** — point it at [`/llms.txt`](/llms.txt), [`/agents.txt`](/agents.txt), [`/llms.json`](/llms.json), and [`/openapi.json`](/openapi.json), or copy the prompt above.
## Platform coverage
Every platform returns the same `{ data, meta }` envelope, so you can add or switch sources without rewriting your client.
* **Instagram** — profiles, posts, reels, highlights, search
* **TikTok** — profiles, videos, products, user search
* **X/Twitter** — profiles, tweets, communities, search
* **YouTube** — channels, videos, transcripts, playlists, search
* **Facebook, LinkedIn, Reddit, Threads, Telegram, Linktree, Hacker News, Truth Social, Spotify** — profiles, posts, and platform-specific lookups
* **Web** — fetch any page as Markdown or HTML, or ask a question about it
* **Utilities** — `whoami`, `balance`, and `health`
The [API reference](/docs/api) groups every documented operation and links straight to its generated schema page — the fastest way to see the full surface area.
## Docs for machines
Building with a coding agent or generating client code? These endpoints are designed to be read by tools:
* Append **`.mdx`** to any docs URL for the raw Markdown, e.g. `/docs/quickstart.mdx`.
* [`/llms.txt`](/llms.txt) — curated discovery index: what Social Fetch covers, why to use it, workflow-oriented doc links (\~100 lines).
* [`/agents.txt`](/agents.txt) — agent onboarding, auth/pagination rules, and crawl allowlist.
* [`/llms-endpoints.txt`](/llms-endpoints.txt) — every operation with a link to that route's markdown page.
* [`/llms-{platform}.txt`](/llms-tiktok.txt) — per-platform files with parameters, credits, and example curls (generated from OpenAPI).
* [`/llms.json`](/llms.json) — full structured route inventory with parameters, pagination, outcomes, credits, and SDK mappings.
* [`/openapi.json`](/openapi.json) — full schema for codegen, validation, and tooling.
* [Capability matrix](/docs/capability-matrix) — dense human-readable appendix of every operation (identifiers, pagination, outcomes, credits, SDK). Prefer `/llms.json` for agents.
---
# API reference
Source: https://www.socialfetch.dev/docs/api
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/api](https://www.socialfetch.dev/docs/api)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/api.mdx](https://www.socialfetch.dev/docs/api.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# API reference (https://www.socialfetch.dev/docs/api)
These pages are generated from the same **public OpenAPI spec** the API serves. Parameters, status codes, schemas, and examples stay aligned with production.
Start from the platform or task you care about, then drill into the generated operation page for exact schemas and examples. If you are using a coding agent, the markdown version of this page lives at [`/docs/api.mdx`](/docs/api.mdx).
## TikTok
- [TikTok profile](/docs/api/v1/tiktok/profiles/handle/get) — `GET /v1/tiktok/profiles/:handle` — normalized public profile + metrics.
- [TikTok profile videos](/docs/api/v1/tiktok/profiles/handle/videos/get) — `GET /v1/tiktok/profiles/:handle/videos` — paginated videos for a profile.
- [TikTok video or post](/docs/api/v1/tiktok/videos/get) — `GET /v1/tiktok/videos/...` — normalized metadata for a single TikTok video.
## Facebook
- [Facebook profile](/docs/api/v1/facebook/profiles/get) — `GET /v1/facebook/profiles` — normalized public profile or page lookup by URL.
## Instagram
- [Instagram profile](/docs/api/v1/instagram/profiles/handle/get) — `GET /v1/instagram/profiles/:handle` — profile, metrics, recent posts, related accounts.
- [Instagram profile posts](/docs/api/v1/instagram/profiles/handle/posts/get) — `GET /v1/instagram/profiles/:handle/posts` — paginated posts for a profile.
- [Instagram post or reel](/docs/api/v1/instagram/posts/get) — `GET /v1/instagram/posts/...` — metadata for a single post or reel.
## Twitter
- [Twitter profile](/docs/api/v1/twitter/profiles/handle/get) — `GET /v1/twitter/profiles/:handle` — normalized public profile and metrics.
- [Twitter profile tweets](/docs/api/v1/twitter/profiles/handle/tweets/get) — `GET /v1/twitter/profiles/:handle/tweets` — paginated tweets for a profile.
- [Twitter tweet](/docs/api/v1/twitter/tweets/get) — `GET /v1/twitter/tweets/...` — normalized metadata for a single tweet.
## Utilities
- [Whoami](/docs/api/v1/whoami) — `GET /v1/whoami` — validate keys; no credits charged.
- [Balance](/docs/api/v1/balance) — `GET /v1/balance` — current credit balance; no credits charged.
- [Health check](/docs/api/health/get) — `GET /health` — liveness probe, no authentication.
## OpenAPI and machine-readable docs
* Download the spec from **[`/openapi.json`](/openapi.json)**.
* Append **`.mdx`** to any docs page URL when you want the markdown version.
* Use [`/llms.txt`](/llms.txt) for curated agent discovery — platform coverage, workflow guidance, and why to choose Social Fetch (\~100 lines). Use [`/agents.txt`](/agents.txt) for onboarding rules and crawl allowlist. Use [`/llms-{platform}.txt`](/llms-tiktok.txt) for one platform's parameters and curls. Use [`/llms.json`](/llms.json) for the full operation inventory.
* If you are integrating from TypeScript, start with the [SDK guide](/docs/sdk).
---
# API Capability Matrix — Endpoints by Platform
Source: https://www.socialfetch.dev/docs/capability-matrix
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/capability-matrix](https://www.socialfetch.dev/docs/capability-matrix)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/capability-matrix.mdx](https://www.socialfetch.dev/docs/capability-matrix.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# API Capability Matrix — Endpoints by Platform (https://www.socialfetch.dev/docs/capability-matrix)
{/* AUTO-GENERATED by scripts/generate-capability-appendix.mts; do not edit by hand. */}
This page is generated from the same OpenAPI-derived data used by [`/llms.json`](/llms.json).
## TikTok
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ---------------------------------------------------- | ------------------------------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------- | -------------------- |
| `GET /v1/tiktok/profiles/{handle}` | Get TikTok profile | `handle` (path) | `client.tiktok.getProfile({ handle })` | none | `data.lookupStatus`: `found`, `private`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/tiktok/profiles/{handle}/videos` | List TikTok profile videos | `handle` (path), `userId` (query) | `client.tiktok.getProfileVideos({ handle, sortBy?, cursor?, userId?, region?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore`; sortBy: latest, popular | An empty `data.videos` array can mean no videos in the selected sort window, a private profile, or other cases—there is no `lookupStatus` field on this route. Call `GET /v1/tiktok/profiles/{handle}` when you need explicit `lookupStatus` including `private` or `not_found` before interpreting an empty video list. | 1 credit per successful request. | no |
| `GET /v1/tiktok/profiles/{handle}/followers` | List TikTok profile followers | `handle` (path), `userId` (query) | `client.tiktok.getProfileFollowers({ handle, cursor?, userId?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `hidden`, `private`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/tiktok/profiles/{handle}/following` | List TikTok profile following | `handle` (path) | `client.tiktok.getProfileFollowing({ handle, cursor?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `hidden`, `private`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/tiktok/profiles/{handle}/region` | Get TikTok profile region | `handle` (path) | `client.tiktok.getProfileRegion({ handle })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/tiktok/profiles/{handle}/audience` | Get TikTok profile audience | `handle` (path) | `client.tiktok.getProfileAudience({ handle })` | none | `data.lookupStatus`: `found`, `not_found` | 30 credits per successful request. | no |
| `GET /v1/tiktok/profiles/{handle}/live` | Get TikTok live stream | `handle` (path) | `client.tiktok.getProfileLive({ handle })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/tiktok/users/search` | Search TikTok users | `query` (query) | `client.tiktok.searchUsers({ query, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/tiktok/search` | Search TikTok videos | `query` (query) | `client.tiktok.searchVideos({ query, datePosted?, sortBy?, region?, cursor?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore`; sortBy: relevance, most-liked, date-posted | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/tiktok/search/hashtags` | Search TikTok by hashtag | none documented | `client.tiktok.searchHashtags({ hashtag, region?, cursor?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | Use `data.page.hasMore` and `data.page.nextCursor` for pagination. Repeat the same hashtag and filters when requesting the next page. | 1 credit per successful request. | no |
| `GET /v1/tiktok/videos` | Get TikTok video | `url` (query) | `client.tiktok.getVideo({ url, region?, trim?, downloadMedia? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit base, +10 with `downloadMedia`. Up to 11 credits max. | `downloadMedia=true` |
| `GET /v1/tiktok/videos/comments` | List TikTok video comments | `url` (query) | `client.tiktok.getVideoComments({ url, cursor?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` Cursor pagination with variable page size — use `data.page.hasMore` and `data.page.nextCursor`; do not assume a fixed number of comments per page or loop on `totalComments` alone. | 1 credit per successful request. | no |
| `GET /v1/tiktok/videos/comments/replies` | List TikTok comment replies | `commentId` (query), `url` (query) | `client.tiktok.getVideoCommentReplies({ commentId, url, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` Requires parent `commentId` from List TikTok video comments plus the same video `url`. Paginate with `data.page.hasMore` and `data.page.nextCursor`; do not assume a fixed page size. | 1 credit per successful request. | no |
| `GET /v1/tiktok/videos/transcript` | Get TikTok video transcript | `url` (query) | `client.tiktok.getVideoTranscript({ url, language?, useAiFallback? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit base, +10 with `useAiFallback`. Up to 11 credits max. | no |
| `GET /v1/tiktok/feed/trending` | List TikTok trending feed | none documented | `client.tiktok.listTrendingFeed({ region, trim? })` | none | Repeat the same request for a fresh trending batch. New and overlapping posts are both possible. No cursor or page parameters. | 1 credit per successful request. | no |
| `GET /v1/tiktok/songs` | Get TikTok song | `id` (query) | `client.tiktok.getSong({ id })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/tiktok/music/{clipId}/videos` | List TikTok music videos | none documented | `client.tiktok.listMusicVideos({ clipId, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | An empty `data.videos` array can mean no public videos use this music clip, or other cases—there is no `lookupStatus` field on this route. | 1 credit per successful request. | no |
| `GET /v1/tiktok/shop/products/search` | Search TikTok Shop products | `query` (query) | `client.tiktok.searchShopProducts({ query, page?, region? })` | page via `page`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/tiktok/shop/products` | List TikTok Shop store products | `url` (query) | `client.tiktok.listShopProducts({ url, cursor?, region? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/tiktok/products` | Get TikTok Shop product | `url` (query) | `client.tiktok.getProduct({ url, region? })` | none | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/tiktok/products/reviews` | List TikTok Shop product reviews | `url` (query) | `client.tiktok.getProductReviews({ url?, productId?, region?, page? })` | page via `page`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/tiktok/profiles/{handle}/showcase-products` | List TikTok profile showcase products | `handle` (path) | `client.tiktok.getProfileShowcaseProducts({ handle, cursor?, region? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | An empty `data.products` array can mean no showcased products, a private profile, or other cases—there is no `lookupStatus` field on this route. Call `GET /v1/tiktok/profiles/{handle}` when you need explicit profile lookup status before interpreting an empty showcase list. | 1 credit per successful request. | no |
| `GET /v1/tiktok/ad-library/ads` | Get TikTok Ad Library ad | `url` (query) | `client.tiktok.getAdLibraryAd({ adId?, url? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/tiktok/ad-library/ads/search` | Search TikTok Ad Library ads | `query` (query) | `client.tiktok.searchAdLibraryAds({ region?, period?, query?, advertiserName?, orderBy?, industry?, objective?, duration?, likes?, adFormat?, adLanguage?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
## Facebook
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ----------------------------------------------- | ------------------------------------- | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----- |
| `GET /v1/facebook/profiles` | Get Facebook profile | `url` (query) | `client.facebook.getProfile({ url, includeBusinessHours? })` | none | `data.lookupStatus`: `found`, `private`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/facebook/profiles/posts` | List Facebook profile posts | `url` (query) | `client.facebook.getProfilePosts({ url?, pageId?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | An empty `data.posts` page with `hasMore: false` can represent no public posts, restricted visibility, or an unresolvable URL or id—there is no `lookupStatus` field on this route. Call `GET /v1/facebook/profiles` first when you need `found` / `private` / `not_found` before interpreting an empty posts page. | 1 credit per successful request. | no |
| `GET /v1/facebook/profiles/reels` | List Facebook profile reels | `url` (query) | `client.facebook.getProfileReels({ url, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/facebook/profiles/photos` | List Facebook profile photos | `url` (query) | `client.facebook.getProfilePhotos({ url, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/facebook/posts` | Get Facebook post or reel | `url` (query) | `client.facebook.getPost({ url, includeComments?, includeTranscript? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/facebook/posts/comments` | List Facebook post or reel comments | `url` (query) | `client.facebook.getPostComments({ url?, cursor?, feedbackId? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/facebook/posts/comments/replies` | List Facebook comment replies | none documented | `client.facebook.getPostCommentReplies({ cursor })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/facebook/posts/transcript` | Get Facebook post transcript | `url` (query) | `client.facebook.getPostTranscript({ url })` | none | `data.lookupStatus`: `found`, `not_found`, `lookup_failed` | 1 credit per successful request. | no |
| `GET /v1/facebook/groups/posts` | List Facebook group posts | `url` (query) | `client.facebook.listGroupPosts({ url, sortBy?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore`; sortBy: top, recentActivity, chronological, chronologicalListings | `data.lookupStatus`: `found`, `not_found` `lookupStatus: not_found` often means the group URL was wrong or unresolved. Each page bills separately, including `not_found` outcomes. Pass a full Facebook group URL (`facebook.com/groups/{id-or-slug}/…`), not a profile or page URL. Use `sortBy: chronological` for general feeds; use `chronologicalListings` for Buy/Sell marketplace groups. Upstream returns a small number of posts per page (often around three). No server-side keyword filter — filter client-side on `text` after fetching pages. | 1 credit per successful request. | no |
| `GET /v1/facebook/marketplace/items` | Get Facebook Marketplace item | `url` (query) | `client.facebook.getMarketplaceItem({ itemId?, url? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/facebook/marketplace/locations/search` | Search Facebook Marketplace locations | `query` (query) | `client.facebook.searchMarketplaceLocations({ query })` | none | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/facebook/marketplace/search` | Search Facebook Marketplace listings | `query` (query) | `client.facebook.searchMarketplace({ query, lat, lng, sortBy?, deliveryMethod?, cursor?, ... })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore`; sortBy: suggested, distanceAscend, creationTimeDescend, priceAscend, priceDescend | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/facebook/ad-library/ads` | Get Facebook Ad Library ad | `url` (query) | `client.facebook.getAdLibraryAd({ adId?, url?, includeTranscript?, trim? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/facebook/ad-library/ads/search` | Search Facebook Ad Library ads | `query` (query) | `client.facebook.searchAdLibraryAds({ query, sortBy?, searchType?, adType?, country?, status?, mediaType?, startDate?, endDate?, cursor?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore`; sortBy: impressions, most-recent | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/facebook/ad-library/companies/ads` | List Facebook company ads | none documented | `client.facebook.listCompanyAds({ pageId?, companyName?, country?, status?, mediaType?, language?, sortBy?, startDate?, endDate?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore`; sortBy: impressions, most-recent | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/facebook/ad-library/companies/search` | Search Facebook ad library companies | `query` (query) | `client.facebook.searchAdLibraryCompanies({ query })` | none | standard HTTP / success envelope | 1 credit per successful request. | no |
## Instagram
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ------------------------------------------------ | ------------------------------------ | --------------- | -------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------- | -------------------------------------------------------------- | -------------------- |
| `GET /v1/instagram/profiles/{handle}` | Get Instagram profile | `handle` (path) | `client.instagram.getProfile({ handle })` | none | `data.lookupStatus`: `found`, `private`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/instagram/profiles/{userId}/basic` | Get Instagram basic profile | `userId` (path) | `client.instagram.getBasicProfile({ userId })` | none | `data.lookupStatus`: `found`, `private`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/instagram/profiles/{handle}/posts` | List Instagram profile posts | `handle` (path) | `client.instagram.getProfilePosts({ handle, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `private`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/instagram/profiles/{handle}/reels` | List Instagram profile reels | `handle` (path) | `client.instagram.getProfileReels({ handle, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/instagram/profiles/{handle}/highlights` | List Instagram profile highlights | `handle` (path) | `client.instagram.getProfileHighlights({ handle })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/instagram/highlights/{highlightId}` | Get Instagram highlight | none documented | `client.instagram.getHighlight({ highlightId })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/instagram/posts` | Get Instagram post or reel | `url` (query) | `client.instagram.getPost({ url, region?, trim?, downloadMedia? })` | none | `data.lookupStatus`: `found`, `not_found`, `restricted` | 1 credit base, +10 with `downloadMedia`. Up to 11 credits max. | `downloadMedia=true` |
| `GET /v1/instagram/posts/comments` | List Instagram post or reel comments | `url` (query) | `client.instagram.getPostComments({ url, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/instagram/posts/transcript` | Get Instagram post transcript | `url` (query) | `client.instagram.getPostTranscript({ url })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/instagram/search/profiles` | Search Instagram profiles | `query` (query) | `client.instagram.searchProfiles({ query, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/instagram/search/reels` | Search Instagram Reels | `query` (query) | `client.instagram.searchReels({ query, datePosted?, page? })` | page via `page`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/instagram/search/hashtags` | Search Instagram by hashtag | none documented | `client.instagram.searchHashtags({ hashtag, datePosted?, mediaType?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/instagram/reels/trending` | List trending Instagram Reels | none documented | `client.instagram.getTrendingReels()` | none | standard HTTP / success envelope | 1 credit per successful request. | no |
## LinkedIn
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ---------------------------------------- | ------------------------------ | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | ----- |
| `GET /v1/linkedin/profiles` | Get LinkedIn profiles | `url` (query) | `client.linkedin.getProfiles({ urls }) or client.linkedin.getProfile({ url })` | none | standard HTTP / success envelope | 2 credits per profile URL requested. Up to 50 profiles per request (100 credits max). | no |
| `GET /v1/linkedin/profiles/posts` | List LinkedIn profile posts | `url` (query) | `client.linkedin.listProfilePosts({ url, startDate?, endDate?, onlyAuthoredPosts? })` | none | `data.lookupStatus`: `found`, `not_found` | 2 credits attempt fee plus 2 credits per returned record. Up to 200 per request (402 credits max). `limit` default: 10. | no |
| `GET /v1/linkedin/people/search` | Search LinkedIn people | none documented | `client.linkedin.searchPeople({ firstName?, lastName? })` | none | `data.lookupStatus`: `found`, `not_found` This search usually takes around one and a half minutes to complete, so expect a longer wait than most endpoints. | 2 credits attempt fee plus 2 credits per returned record. Up to 50 per request (102 credits max). | no |
| `GET /v1/linkedin/organizations` | Get LinkedIn organization page | `url` (query) | `client.linkedin.getOrganizations({ urls }) or client.linkedin.getOrganization({ url })` | none | This endpoint covers company, school, and other LinkedIn organization pages. If you only need a standard company page lookup, the Company page endpoint may be a better fit. | 2 credits per organization URL requested. Up to 50 organizations per request (100 credits max). | no |
| `GET /v1/linkedin/companies` | Get LinkedIn company page | `url` (query) | `client.linkedin.getCompany({ url })` | none | `data.lookupStatus`: `found`, `not_found` This endpoint is for LinkedIn company pages only. If you have a school URL or another organization page type, use the Organization page endpoint instead. | 1 credit per successful request. | no |
| `GET /v1/linkedin/companies/posts` | List LinkedIn company posts | `url` (query) | `client.linkedin.listCompanyPosts({ url, page? })` | page via `page`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` This endpoint is for LinkedIn company pages only. If you have a school URL or another organization page type, use the Organization page endpoint instead. | 1 credit per successful request. | no |
| `GET /v1/linkedin/posts` | Get LinkedIn post or article | `url` (query) | `client.linkedin.getPost({ url })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/linkedin/posts/transcript` | Get LinkedIn post transcript | `url` (query) | `client.linkedin.getPostTranscript({ url })` | none | `data.lookupStatus`: `found`, `not_found`, `lookup_failed` | 1 credit when a transcript is found; no charge when a transcript is unavailable. | no |
| `GET /v1/linkedin/posts/search` | Search LinkedIn posts | `query` (query) | `client.linkedin.searchPosts({ query, datePosted?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | An empty posts array means no matching public posts were returned for this query and page. It is not an error. | 1 credit per successful request. | no |
| `GET /v1/linkedin/ad-library/ads` | Get LinkedIn Ad Library ad | `url` (query) | `client.linkedin.getAdLibraryAd({ adId?, url? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/linkedin/ad-library/ads/search` | Search LinkedIn Ad Library ads | none documented | `client.linkedin.searchAdLibraryAds({ company?, keyword?, companyId?, countries?, startDate?, endDate?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/linkedin/jobs` | Get LinkedIn jobs | `url` (query) | `client.linkedin.getJobs({ urls })` | none | standard HTTP / success envelope | 2 credits per job URL requested. Up to 50 jobs per request (100 credits max). | no |
| `GET /v1/linkedin/jobs/search` | Search LinkedIn jobs | none documented | `client.linkedin.searchJobs({ keyword, location, country?, timeRange?, jobType?, experienceLevel?, remote?, company?, locationRadius? })` | none | `data.lookupStatus`: `found`, `not_found` This search usually takes around one and a half minutes. | 2 credits attempt fee plus 2 credits per returned record. Up to 1000 per request (2002 credits max). `limit` default: 10. | no |
## YouTube
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ----------------------------------------- | ---------------------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----- |
| `GET /v1/youtube/channel` | Get YouTube channel | `handle` (query), `url` (query) | `client.youtube.getChannel({ channelId?, handle?, url? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/youtube/channels/videos` | List YouTube channel videos | `handle` (query) | `client.youtube.getChannelVideos({ channelId?, handle?, sortBy?, cursor?, includeExtras? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore`; sortBy: latest, popular | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/youtube/channels/shorts` | List YouTube channel shorts | `handle` (query) | `client.youtube.getChannelShorts({ channelId?, handle?, sortBy?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore`; sortBy: latest, popular | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/youtube/playlists` | Get YouTube playlist | `playlistId` (query) | `client.youtube.getPlaylist({ playlistId })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/youtube/community-posts` | Get YouTube community post | `url` (query) | `client.youtube.getCommunityPost({ url })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/youtube/search` | Search YouTube | `query` (query) | `client.youtube.search({ query, uploadDate?, sortBy?, type?, duration?, region?, cursor?, includeExtras? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore`; sortBy: relevance, popular | Use `data.page.hasMore` and `data.page.nextCursor` for pagination rather than inferring completion from bucket sizes alone. | 1 credit per successful request. | no |
| `GET /v1/youtube/search/hashtags` | Search YouTube by hashtag | none documented | `client.youtube.searchHashtag({ hashtag, type?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | Use `data.page.hasMore` and `data.page.nextCursor` for pagination rather than inferring completion from result count alone. | 1 credit per successful request. | no |
| `GET /v1/youtube/shorts/trending` | List trending YouTube Shorts | none documented | `client.youtube.getTrendingShorts()` | none | Typically returns about 48 trending Shorts per call. Repeat the same request for another fresh batch (new and overlapping Shorts are both possible). No cursor or page parameters. | 1 credit per successful request. | no |
| `GET /v1/youtube/videos` | Get YouTube video | `url` (query) | `client.youtube.getVideo({ url, language? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/youtube/videos/comments` | List YouTube video comments | `url` (query) | `client.youtube.getVideoComments({ url, cursor?, order? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/youtube/videos/comments/replies` | List YouTube comment replies | none documented | `client.youtube.getVideoCommentReplies({ cursor })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/youtube/videos/transcript` | Get YouTube video transcript | `url` (query) | `client.youtube.getVideoTranscript({ url, language? })` | none | `data.lookupStatus`: `found`, `not_found`, `lookup_failed` | 1 credit per successful request. | no |
## Twitter
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ------------------------------------------ | ----------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------- | ----- |
| `GET /v1/twitter/profiles/{handle}` | Get Twitter profile | `handle` (path) | `client.twitter.getProfile({ handle })` | none | `data.lookupStatus`: `found`, `private`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/twitter/profiles/{handle}/tweets` | List Twitter profile tweets | `handle` (path) | `client.twitter.getProfileTweets({ handle, limit?, cursor?, includeReplies?, includePinned? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 2 credits per successful request. | no |
| `GET /v1/twitter/tweets` | Get Twitter tweet | `url` (query) | `client.twitter.getTweet({ url, trim? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/twitter/tweets/replies` | List Twitter tweet replies | `url` (query) | `client.twitter.listTweetReplies({ url, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 2 credits per successful request. | no |
| `GET /v1/twitter/tweets/transcript` | Get Twitter tweet transcript | `url` (query) | `client.twitter.getTweetTranscript({ url })` | none | `data.lookupStatus`: `found`, `not_found`, `lookup_failed` For video tweets only. Responses can take longer than typical lookups. Videos longer than about two minutes cannot be transcribed. | 1 credit per successful request. | no |
| `GET /v1/twitter/search` | Search Twitter posts | `query` (query) | `client.twitter.search({ query, section?, minRetweets?, minLikes?, minReplies?, limit?, startDate?, endDate?, language?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 2 credits per successful request. | no |
| `GET /v1/twitter/hashtags` | Search Twitter by hashtag | none documented | `client.twitter.searchHashtags({ hashtag, section?, limit?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 2 credits per successful request. | no |
| `GET /v1/twitter/communities` | Get Twitter community | `url` (query) | `client.twitter.getCommunity({ url })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/twitter/communities/tweets` | List Twitter community tweets | `url` (query) | `client.twitter.getCommunityTweets({ url })` | none | `data.lookupStatus`: `found`, `not_found` `lookupStatus: found` may still return an empty `data.tweets` array. | 1 credit per successful request. | no |
## Auth
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ----------------- | ------------------- | --------------- | ----------------------------- | --------------------- | -------------------------------- | ------------------------- | ----- |
| `GET /v1/whoami` | Whoami | none documented | `client.auth.whoami()` | none | standard HTTP / success envelope | see `meta.creditsCharged` | no |
| `GET /v1/balance` | Get account balance | none documented | `client.billing.getBalance()` | none | standard HTTP / success envelope | see `meta.creditsCharged` | no |
## System
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| -------------- | ----------------------- | --------------- | ----------------------------------------------------------------------- | --------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------- | ----- |
| `POST /v1/ask` | Ask in natural language | none documented | `client.ask({ query: "How many TikTok followers does MrBeast have?" })` | none | standard HTTP / success envelope | Routing is free. The nested lookup bills at that endpoint's normal credit rate — see meta.creditsCharged. | no |
| `GET /health` | Health check | none documented | `client.health()` | none | standard HTTP / success envelope | see `meta.creditsCharged` | no |
## Telegram
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| --------------------------------------------------- | --------------------------- | -------------------------------- | ------------------------------------------------------------------------ | --------------------- | ------------------------------------------------------- | -------------------------------- | ----- |
| `GET /v1/telegram/channels/{handle}` | Get Telegram channel | `handle` (path) | `client.telegram.getChannel({ handle: "durov" })` | none | `data.lookupStatus`: `found`, `not_found`, `restricted` | 1 credit per successful request. | no |
| `GET /v1/telegram/channels/{handle}/posts` | List Telegram channel posts | `handle` (path) | `client.telegram.getChannelPosts({ handle: "durov", cursor? })` | cursor via `cursor` | `data.lookupStatus`: `found`, `not_found`, `restricted` | 1 credit per successful request. | no |
| `GET /v1/telegram/channels/{handle}/posts/{postId}` | Get Telegram channel post | `handle` (path), `postId` (path) | `client.telegram.getChannelPost({ handle: "Premiumoji", postId: "93" })` | none | `data.lookupStatus`: `found`, `not_found`, `restricted` | 1 credit per successful request. | no |
## Linktree
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ------------------------------------ | -------------------- | --------------- | --------------------------------------------------------- | --------------------- | ----------------------------------------- | -------------------------------- | ----- |
| `GET /v1/linktree/profiles/{handle}` | Get Linktree profile | `handle` (path) | `client.linktree.getProfile({ handle: "miguelangeles" })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
## Hacker News
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ------------------------------------------------- | --------------------------------- | ------------------------------------------------------------------ | ------------------------------------------------------------- | -------------------------------------------------- | ------------------------------------------------------------------- | --------------------------------- | ----- |
| `GET /v1/hackernews/search` | Search Hacker News | `query` (query), `author` (query), `domain` (query), `url` (query) | `client.hackernews.search({ query: "Dropbox" })` | page via `page`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/hackernews/feeds/{feed}` | List a Hacker News feed | none documented | `client.hackernews.listFeed({ feed: "top" })` | offset via `offset`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/hackernews/stories/{id}` | Get Hacker News story | `id` (path) | `client.hackernews.getStory({ id: 8863 })` | none | `data.lookupStatus`: `found`, `not_found`, `not_story` | 1 credit per successful request. | no |
| `GET /v1/hackernews/stories/{id}/comments` | Get Hacker News story comments | `id` (path) | `client.hackernews.getStoryComments({ id: 8863 })` | cursor via `cursor` | `data.lookupStatus`: `found`, `not_found`, `not_story` | 3 credits per successful request. | no |
| `GET /v1/hackernews/items/{id}` | Get Hacker News item | `id` (path) | `client.hackernews.getItem({ id: 8863 })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/hackernews/comments/{id}/context` | Get Hacker News comment context | `id` (path) | `client.hackernews.getCommentContext({ id: 9224 })` | none | `data.lookupStatus`: `found`, `not_found`, `not_comment` | 2 credits per successful request. | no |
| `GET /v1/hackernews/users/{username}` | Get Hacker News user profile | `username` (path) | `client.hackernews.getUserProfile({ username: "jl" })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/hackernews/users/{username}/submissions` | List Hacker News user submissions | `username` (path) | `client.hackernews.getUserSubmissions({ username: "jl" })` | page via `page`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/hackernews/users/{username}/comments` | List Hacker News user comments | `username` (path) | `client.hackernews.getUserComments({ username: "jl" })` | page via `page`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/hackernews/users/{username}/favorites` | List Hacker News user favorites | `username` (path) | `client.hackernews.getUserFavorites({ username: "tptacek" })` | page via `page`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found`, `private_or_unavailable` | 1 credit per successful request. | no |
| `GET /v1/hackernews/jobs/who-is-hiring` | List Who is Hiring jobs | none documented | `client.hackernews.listWhoIsHiring()` | page via `page`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/hackernews/updates` | Get Hacker News updates | none documented | `client.hackernews.getUpdates()` | none | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/hackernews/maxitem` | Get Hacker News max item id | none documented | `client.hackernews.getMaxItem()` | none | standard HTTP / success envelope | 1 credit per successful request. | no |
## Truth Social
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| --------------------------------------------- | ------------------------------- | --------------- | ------------------------------------------------------------------------------------------------ | --------------------- | ----------------------------------------- | -------------------------------------------------------------- | ----- |
| `GET /v1/truthsocial/profiles/{handle}` | Get Truth Social profile | `handle` (path) | `client.truthsocial.getProfile({ handle: "realDonaldTrump" })` | none | `data.lookupStatus`: `found`, `not_found` | 2 credits per successful request. | no |
| `GET /v1/truthsocial/profiles/{handle}/posts` | List Truth Social profile posts | `handle` (path) | `client.truthsocial.getProfilePosts({ handle: "realDonaldTrump", cursor?, limit? })` | cursor via `cursor` | `data.lookupStatus`: `found`, `not_found` | 2 credits base, +2 with `includeReplies`. Up to 4 credits max. | no |
| `GET /v1/truthsocial/posts` | Get Truth Social post | `url` (query) | `client.truthsocial.getPost({ url: "https://truthsocial.com/@justthenews/116972401572691045" })` | none | `data.lookupStatus`: `found`, `not_found` | 2 credits per successful request. | no |
## Google
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ---------------------------------------------- | ------------------------------------ | ---------------- | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------- | ----- |
| `GET /v1/google/ad-library/companies/ads` | List Google company ads | `domain` (query) | `client.google.listCompanyAds({ domain?, advertiserId?, topic?, region?, startDate?, endDate?, platform?, format?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` Google Ad Transparency only includes public ads. | 25 credits per successful request. | no |
| `GET /v1/google/ad-library/ads` | Get Google Ad Library ad | `url` (query) | `client.google.getAdLibraryAd({ url })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/google/ad-library/advertisers/search` | Search Google Ad Library advertisers | `query` (query) | `client.google.searchAdLibraryAdvertisers({ query, region? })` | none | standard HTTP / success envelope | 1 credit per successful request. | no |
## Pinterest
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| -------------------------------------------- | ----------------------------- | --------------- | ---------------------------------------------------------------- | -------------------------------------------------------------------------------- | ----------------------------------------- | -------------------------------- | ----- |
| `GET /v1/pinterest/search` | Search Pinterest pins | `query` (query) | `client.pinterest.searchPins({ query, cursor?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/pinterest/pins` | Get Pinterest pin | `url` (query) | `client.pinterest.getPin({ url, trim? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/pinterest/profiles/{handle}/boards` | List Pinterest profile boards | `handle` (path) | `client.pinterest.listProfileBoards({ handle, cursor?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/pinterest/boards/pins` | List Pinterest board pins | `url` (query) | `client.pinterest.listBoardPins({ url, cursor?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
## Threads
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ----------------------------------- | ------------------- | --------------- | --------------------------------------- | --------------------- | ---------------------------------------------------- | -------------------------------- | ----- |
| `GET /v1/threads/profiles/{handle}` | Get Threads profile | `handle` (path) | `client.threads.getProfile({ handle })` | none | `data.lookupStatus`: `found`, `private`, `not_found` | 1 credit per successful request. | no |
## Bluesky
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ----------------------------------------- | -------------------------- | --------------------------------- | -------------------------------------------------------------- | -------------------------------------------------------------------------------- | ----------------------------------------- | -------------------------------- | ----- |
| `GET /v1/bluesky/profiles/{handle}` | Get Bluesky profile | `handle` (path) | `client.bluesky.getProfile({ handle })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/bluesky/profiles/{handle}/posts` | List Bluesky profile posts | `handle` (path), `userId` (query) | `client.bluesky.getProfilePosts({ handle, cursor?, userId? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/bluesky/posts` | Get Bluesky post | `url` (query) | `client.bluesky.getPost({ url })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
## Threads
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ----------------------------------------- | -------------------------- | --------------- | --------------------------------------------------------------- | --------------------- | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----- |
| `GET /v1/threads/profiles/{handle}/posts` | List Threads profile posts | `handle` (path) | `client.threads.getProfilePosts({ handle, trim? })` | none | `data.lookupStatus`: `found`, `not_found` `lookupStatus: found` means the handle resolved; `data.posts` may still be empty. | 1 credit per successful request. | no |
| `GET /v1/threads/search` | Search Threads posts | `query` (query) | `client.threads.search({ query, startDate?, endDate?, trim? })` | none | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/threads/posts` | Get Threads post | `url` (query) | `client.threads.getPost({ url, trim? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/threads/users/search` | Search Threads users | `query` (query) | `client.threads.searchUsers({ query })` | none | standard HTTP / success envelope | 1 credit per successful request. | no |
## Reddit
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| --------------------------------------------- | --------------------------- | --------------- | ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----- |
| `GET /v1/reddit/subreddits` | Get Reddit subreddit | `url` (query) | `client.reddit.getSubreddit({ subreddit } \| { url }) — subreddit names are case-sensitive` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/reddit/subreddits/{subreddit}/posts` | List Reddit subreddit posts | none documented | `client.reddit.listSubredditPosts({ subreddit, sort?, timeframe?, cursor? }) — subreddit is case-sensitive` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/reddit/subreddits/search` | Search Reddit subreddit | `query` (query) | `client.reddit.searchSubreddit({ subreddit, query?, sort?, timeframe?, cursor? }) — subreddit is case-sensitive` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | Use `data.page.hasMore` and `data.page.nextCursor` for pagination rather than inferring completion from `data.totalResults` alone. | 1 credit per successful request. | no |
| `GET /v1/reddit/posts/comments` | List Reddit post comments | `url` (query) | `client.reddit.listPostComments({ url, cursor?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/reddit/posts/transcript` | Get Reddit post transcript | `url` (query) | `client.reddit.getPostTranscript({ url, language? })` | none | `data.lookupStatus`: `found`, `not_found`, `lookup_failed` Accepts Reddit post permalinks and direct hosted video URLs. | 1 credit per successful request. | no |
| `GET /v1/reddit/search` | Search Reddit posts | `query` (query) | `client.reddit.search({ query, sortBy?, timeframe?, cursor?, trim? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore`; sortBy: relevance, new, top | Use `data.page.hasMore` and `data.page.nextCursor` for pagination rather than inferring completion from `data.totalResults` alone. | 1 credit per successful request. | no |
## Rumble
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ---------------------------------- | --------------------------- | --------------- | --------------------------------------------------- | -------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ----- |
| `GET /v1/rumble/search` | Search Rumble | `query` (query) | `client.rumble.search({ query, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | Use `data.page.hasMore` and `data.page.nextCursor` for pagination rather than inferring completion from `data.totalResults` alone. | 1 credit per successful request. | no |
| `GET /v1/rumble/channels/videos` | List Rumble channel videos | `url` (query) | `client.rumble.listChannelVideos({ url, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/rumble/videos` | Get Rumble video | `url` (query) | `client.rumble.getVideo({ url })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/rumble/videos/transcript` | Get Rumble video transcript | `url` (query) | `client.rumble.getVideoTranscript({ url })` | none | `data.lookupStatus`: `found`, `not_found`, `lookup_failed` | 1 credit when a transcript is found; no charge when captions are unavailable. | no |
| `GET /v1/rumble/videos/comments` | List Rumble video comments | `url` (query) | `client.rumble.listVideoComments({ url })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
## Twitch
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ------------------------------------------- | --------------------------- | --------------- | ----------------------------------------------------------------- | --------------------- | ----------------------------------------- | -------------------------------- | ----- |
| `GET /v1/twitch/profiles/{handle}` | Get Twitch profile | `handle` (path) | `client.twitch.getProfile({ handle })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/twitch/profiles/{handle}/videos` | List Twitch profile videos | `handle` (path) | `client.twitch.listProfileVideos({ handle, filterBy?, sortBy? })` | sortBy: time, views | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/twitch/profiles/{handle}/schedule` | Get Twitch profile schedule | `handle` (path) | `client.twitch.getProfileSchedule({ handle })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/twitch/clips` | Get Twitch clip | `url` (query) | `client.twitch.getClip({ url })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
## GitHub
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ------------------------------------------------ | --------------------------------- | --------------- | -------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----- |
| `GET /v1/github/profiles/{handle}` | Get GitHub profile | `handle` (path) | `client.github.getProfile({ handle })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/github/profiles/{handle}/repositories` | List GitHub profile repositories | `handle` (path) | `client.github.listProfileRepositories({ handle, cursor?, type?, sort?, direction? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/github/repositories` | Get GitHub repository | `url` (query) | `client.github.getRepository({ url })` | none | `data.lookupStatus`: `found`, `not_found` Use this endpoint for one repository when you have a full `owner/repo` URL. To list every public repository for a user, use the profile repositories list endpoint instead. | 1 credit per successful request. | no |
| `GET /v1/github/profiles/{handle}/activity` | List GitHub profile activity | `handle` (path) | `client.github.listProfileActivity({ handle, year?, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` This endpoint returns one month of public contribution activity per request. Keep the same `year` on follow-up calls and pass `data.page.nextCursor` as `cursor` to page backward through the year. | 1 credit per successful request. | no |
| `GET /v1/github/profiles/{handle}/followers` | List GitHub profile followers | `handle` (path) | `client.github.listProfileFollowers({ handle, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/github/profiles/{handle}/following` | List GitHub profile following | `handle` (path) | `client.github.listProfileFollowing({ handle, cursor? })` | cursor via `cursor`, next: `data.page.nextCursor`, has more: `data.page.hasMore` | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/github/profiles/{handle}/contributions` | Get GitHub contribution graph | `handle` (path) | `client.github.getProfileContributions({ handle, year? })` | none | `data.lookupStatus`: `found`, `not_found` `year` default: current calendar year. Contribution counts reflect public GitHub activity for that year. | 1 credit per successful request. | no |
| `GET /v1/github/trending/repositories` | List trending GitHub repositories | none documented | `client.github.listTrendingRepositories({ language?, since?, spokenLanguageCode? })` | none | Use `since` (`daily`, `weekly`, `monthly`) and optional `language` / `spokenLanguageCode` to narrow results. For trending developers instead of repositories, use the trending developers endpoint. | 1 credit per successful request. | no |
| `GET /v1/github/trending/developers` | List trending GitHub developers | none documented | `client.github.listTrendingDevelopers({ language?, since? })` | none | Use `since` (`daily`, `weekly`, `monthly`) and optional `language` to narrow results. Each developer may include `popularRepository` when GitHub highlights one. For trending repositories instead of developers, use the trending repositories endpoint. | 1 credit per successful request. | no |
## Spotify
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ------------------------ | ------------------ | ------------- | ----------------------------------------------- | --------------------- | ----------------------------------------- | -------------------------------- | ----- |
| `GET /v1/spotify/artist` | Get Spotify artist | `url` (query) | `client.spotify.getArtist({ artistId?, url? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/spotify/album` | Get Spotify album | `url` (query) | `client.spotify.getAlbum({ albumId?, url? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
| `GET /v1/spotify/track` | Get Spotify track | `url` (query) | `client.spotify.getTrack({ trackId?, url? })` | none | `data.lookupStatus`: `found`, `not_found` | 1 credit per successful request. | no |
## Web
| Route | Summary | Identifiers | SDK | Pagination / ordering | Outcome / empty-result notes | Credits | Media |
| ---------------------- | ------------------------------- | ------------------------------ | ---------------------------------------------------------------------------------------- | --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | ----- |
| `GET /v1/web/search` | Search the web | `query` (query) | `client.web.search({ query: "Social media scraping API", region: "US" })` | page via `page` | standard HTTP / success envelope | 1 credit per successful request. | no |
| `GET /v1/web/markdown` | Generate web page markdown | `url` (query), `query` (query) | `client.web.getMarkdown({ url: "https://www.socialfetch.dev/" })` | none | `data.lookupStatus`: `found`, `restricted` `lookupStatus: restricted` means bot/access protection blocked the fetch; content fields are null. | 1 credit per successful request. | no |
| `GET /v1/web/ask` | Ask a question about a web page | `url` (query) | `client.web.ask({ url: "https://www.socialfetch.dev/", q: "What is this page about?" })` | none | `data.lookupStatus`: `found`, `restricted` `lookupStatus: restricted` means bot/access protection blocked the fetch; `answer` is null. | 1 credit per successful request. | no |
| `GET /v1/web/html` | Generate web page HTML | `url` (query) | `client.web.getHtml({ url: "https://www.socialfetch.dev/" })` | none | `data.lookupStatus`: `found`, `restricted` `lookupStatus: restricted` means bot/access protection blocked the fetch; `html` is null. | 1 credit per successful request. | no |
| `GET /v1/web/crawl` | Crawl web pages | `url` (query) | `client.web.crawl({ urls: ["https://www.socialfetch.dev/"] })` | none | standard HTTP / success envelope | 1 credit per URL requested. Up to 5 URLs per request (5 credits max). | no |
---
# Choose the right API endpoint
Source: https://www.socialfetch.dev/docs/choose-endpoint
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/choose-endpoint](https://www.socialfetch.dev/docs/choose-endpoint)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/choose-endpoint.mdx](https://www.socialfetch.dev/docs/choose-endpoint.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Choose the right API endpoint (https://www.socialfetch.dev/docs/choose-endpoint)
Use this page when you know what outcome you want, but you are not yet sure which route or SDK method to call.
## Decision rules
* Use **`whoami`** when you want the cheapest auth smoke test.
* Use **`health`** when you only care whether the service is up.
* Use **profile endpoints** for account metadata.
* Use **profile list endpoints** for paginated content from an account.
* Use **single-item endpoints** when you already have a post, reel, video, or tweet URL.
* Use **raw HTTP** when you need a documented route that the SDK does not wrap, or when you are outside TypeScript.
## Utilities
| Goal | Route | SDK | Why |
| --------------------------- | ----------------- | ----------------------------- | ---------------------------------------------------------------- |
| Validate auth | `GET /v1/whoami` | `client.auth.whoami()` | Checks key validity without consuming credits. |
| Check balance | `GET /v1/balance` | `client.billing.getBalance()` | Use before high-volume metered jobs. |
| Check service liveness only | `GET /health` | `client.health()` | Use this for liveness only. Use `whoami` for an auth smoke test. |
## Profile metadata
Use these when the input is a handle and the output is account-level information.
| Platform | Route | SDK | Input |
| --------- | ------------------------------------- | ----------------------------------------- | -------- |
| TikTok | `GET /v1/tiktok/profiles/{handle}` | `client.tiktok.getProfile({ handle })` | `handle` |
| Twitter | `GET /v1/twitter/profiles/{handle}` | `client.twitter.getProfile({ handle })` | `handle` |
| Instagram | `GET /v1/instagram/profiles/{handle}` | `client.instagram.getProfile({ handle })` | `handle` |
## Paginated account content
Use these when you want posts, videos, or tweets for a profile instead of the profile itself.
| Platform | Route | SDK | Pagination | |
| --------- | ------------------------------------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------- |
| TikTok | `GET /v1/tiktok/profiles/{handle}/videos` | `client.tiktok.getProfileVideos({ handle, ... })` | Cursor-based. Optional \`sortBy=latest | popular\`. Empty lists are ambiguous. |
| Twitter | `GET /v1/twitter/profiles/{handle}/tweets` | `client.twitter.getProfileTweets({ handle, limit?, cursor?, includeReplies?, includePinned? })` | Cursor via `data.page.nextCursor`. Defaults to 40 tweets per page. Use `GET /v1/twitter/profiles/{handle}` first if you need to distinguish private vs not-found before interpreting an empty list. | |
| Instagram | `GET /v1/instagram/profiles/{handle}/posts` | `client.instagram.getProfilePosts({ handle, cursor? })` | Cursor-based. Use `data.lookupStatus` for private/restricted vs not found vs a public empty feed. | |
## Single-item lookups
Use these when you already have a canonical content URL and want one normalized object back.
| Platform | Route | SDK | Identifier |
| --------- | ------------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| TikTok | `GET /v1/tiktok/videos` | `client.tiktok.getVideo({ url, ... })` | URL |
| Twitter | `GET /v1/twitter/tweets` | `client.twitter.getTweet({ url, trim? })` | Tweet permalink or identifier in `url` |
| Instagram | `GET /v1/instagram/posts` | `client.instagram.getPost({ url, ... })` | URL. Check `data.lookupStatus` for `found`, `not_found`, or `restricted` (age-gated or otherwise not publicly scrapable). |
## Common questions
### "Should I start with `health` or `whoami`?"
Start with `whoami` if the real question is "can this integration authenticate and read my key correctly?" Start with `health` only if you want a generic liveness probe.
### "I have a profile handle. Which route do I use?"
Use the platform profile route when you want account metadata. Use the platform profile list route when you want posts, videos, or tweets from that account.
### "I have a post URL. Which route do I use?"
Use the platform single-item endpoint. Those routes are the best fit when your input is a content URL rather than a profile handle.
### "How do I tell `private` from `not_found`?"
Do not rely on HTTP status alone. If the route exposes `data.lookupStatus`, inspect it on HTTP `200`. See [Errors](/docs/errors).
### "How do I tell `restricted` from `not_found` on a post or reel URL?"
On `GET /v1/instagram/posts`, both outcomes are HTTP `200` with empty `post` / `media` fields. Use `data.lookupStatus`: `not_found` when the target does not exist or cannot be resolved; `restricted` when the post is not available under public scraping (for example age-gated content). Do not retry `restricted` as a transient failure. See [Errors](/docs/errors).
### "How do I tell `private` from `not_found` from an empty list?"
Some list routes do not expose `lookupStatus`. If you need account-level `private` / `not_found`, call the profile route first. See [Errors](/docs/errors).
### "When should I prefer the SDK?"
Prefer the SDK for TypeScript when the route is wrapped and you want typed `Result` handling. Prefer raw HTTP or OpenAPI when:
* you are integrating from another language
* you need to inspect the exact on-the-wire schema
## Good default workflow
1. Call `whoami`.
2. Choose the route family from the tables above.
3. Check the [Capability matrix](/docs/capability-matrix) for identifiers, pagination, outcome semantics, and SDK coverage.
4. Open the exact operation page in the [API reference](/docs/api).
---
# Credits
Source: https://www.socialfetch.dev/docs/credits
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/credits](https://www.socialfetch.dev/docs/credits)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/credits.mdx](https://www.socialfetch.dev/docs/credits.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Credits (https://www.socialfetch.dev/docs/credits)
Most lookup endpoints consume **credits** from your account balance. When the balance runs out, those routes return **`402`** instead of doing the work.
Social Fetch is **pay-as-you-go by default** — buy credit packs once and spend them whenever. **PAYG credits never expire.** Optional subscription plans add included credits each month for steadier volume. Plan names, pack sizes, and prices are on the [Pricing](/pricing) page.
## How metering works
* **Credits are charged when we complete a lookup attempt**, as documented per endpoint. That includes outcomes like a private or not-found profile, or a `restricted` post — these come back in the `200` body (via `data.lookupStatus`), not as HTTP errors, and they still cost credits.
* **Cache hits still charge.** Some endpoints may return `meta.cached: true` (and an HTTP `Age` header) when the response comes from our short-lived completed-result cache. That avoids repeating upstream work; it is **not** a free or discounted credit path — `meta.creditsCharged` remains the full endpoint price.
* **`GET /v1/whoami`** and **`GET /v1/balance`** are free — use them for connectivity checks and balance reads without spending credits.
* The exact cost per route lives in the [API reference](/docs/api), on each operation's page.
## Planning your integration
* **Check your balance before high-volume jobs** with `GET /v1/balance` (or your own ledger).
* **Treat `402` as a signal**, not a crash — top up, throttle, or pause until you have credits.
* **Reconcile against `meta.creditsCharged`** so your accounting matches what actually billed.
## Pay-as-you-go and subscriptions
**Non-subscribers** spend PAYG balance only. When it is empty, metered routes return **`402 insufficient_credits`**.
With an active subscription, usage draws credits in this order:
1. **Included subscription credits** for the current monthly period
2. **Pay-as-you-go balance** (pack purchases, free signup credits, prior refill packs)
3. **Prepaid tier refill packs** — auto-purchased when spendable balance drops below your refill threshold (not metered usage)
Included credits **reset at the start of each monthly period** — even on annual base plans, the credit clock is monthly. **Unused included credits do not roll over.** Your PAYG balance (pack purchases and refill-pack credits) is separate and **never expires**. Canceling a subscription never forfeits PAYG or refill credits.
You can **buy credit packs while subscribed**. PAYG balance acts as a buffer before auto-refill kicks in.
## Auto-refill
Subscribers with **auto-refill enabled** (on by default at subscribe checkout) keep serving when included credits run out: usage continues through PAYG balance, then **prepaid refill packs** charge your saved card off-session. Refill credits land in your **PAYG bucket** and **do not expire**.
Auto-refill triggers when your **spendable balance drops to 100 credits or below** (the default threshold). You can raise the trigger in billing. You can optionally set a **per-period auto-refill spend cap** — when reached, refill charges stop and metered routes return **`402`** until the next period or you raise the cap.
Toggle auto-refill off in billing if you prefer a hard stop once included + PAYG balance are exhausted.
Subscribers can use their **tier refill pack** (default) or any **credit top-up pack** chosen in billing settings. For pay-as-you-go accounts, **auto top-up is on by default after your first credit pack purchase** — we charge the same pack size you bought when your balance drops to **100 credits or below** (configurable in billing). Toggle it off anytime if you prefer a hard stop at zero.
## Grace buffer when a refill charge fails
If an auto-refill charge fails (card declined, insufficient funds), we grant a **one-time grace buffer** so production apps keep running while you fix payment. Grace requires **auto-refill enabled** with a saved payment method, and applies only to **paying accounts** (you have purchased credits or subscribed). Free signup credits alone do not qualify.
| Account type | Grace buffer |
| -------------------------------------- | -------------- |
| **PAYG** (pack purchase / auto top-up) | 2,000 credits |
| **Starter** subscriber | 2,000 credits |
| **Growth** subscriber | 5,000 credits |
| **Scale** subscriber | 10,000 credits |
Grace credits are granted once per unpaid episode. When your next successful **charge** succeeds (auto-refill or a credit pack purchase), the grace amount is **recouped** before the remainder stays in your balance. If grace is exhausted while payment still fails, requests return **`402`** and billing shows an **update payment method** banner.
This is separate from **base subscription renewal** failure — if base renewal payment fails at period reset, **included credits for that month are skipped** until the invoice pays. You keep any remaining PAYG/refill balance. Update your card in the Stripe billing portal to restore full service.
## Canceling or changing plans
* **Cancel** from billing — effective at period end. Included credits remain until the period closes; then you revert to pay-as-you-go only.
* **Upgrade** takes effect immediately with a prorated charge and matching included-credit top-up.
* **Downgrade** schedules for period end.
Payment methods and invoices are managed through the Stripe billing portal.
## Balance polling
[`GET /v1/balance`](/docs/api/v1/balance) is free. Poll it before large jobs or on a schedule.
* **`data.balance`** — spendable credits you can use right now (aligned with when metered routes return **`402`**). During a grace episode, pre-granted grace is excluded from `balance` until included and regular PAYG credits are exhausted; after that, `balance` counts down grace runway.
* **`data.billingAlert`** — billing health for alerting: `none`, `payment_action_required`, or `suspended`. Check this even when `balance` still looks healthy — for example, auto-refill failed but the grace buffer has credits left.
Other fields (`payg`, `paygSpendable`, `graceDebtCredits`, `refillState`) break down the same state; see the [Balance API reference](/docs/api/v1/balance) for field descriptions.
**Recommended alert** (low credits *or* payment needs attention):
```ts
const { data } = await client.billing.getBalance();
const MIN_CREDITS = 1_000;
if (data.billingAlert !== "none" || data.balance < MIN_CREDITS) {
notifyOps(); // fix payment in the dashboard and/or buy a pack
}
```
Example during grace — payment failed, spending the grace buffer (`balance` is runway; `billingAlert` is the warning):
```json
{
"data": {
"balance": 1998,
"billingAlert": "payment_action_required",
"paygSpendable": 0,
"refillState": "grace",
"graceDebtCredits": 2000
}
}
```
## Throughput and concurrency
Paid metered `/v1/*` routes have **no request quotas** — **credits are the only limit**. There is no enforced requests-per-second cap on paid lookups. Run parallel requests as your product needs; for best performance and reliability, stay below **\~500 concurrent requests**.
Under load, requests may be **queued**. Under extreme concurrency, the API can return **`503 temporarily_unavailable`** with an accurate **`Retry-After`** header. That means we are busy — not that you hit a customer rate limit (we do **not** use `429` for paid metered saturation). These responses are **not charged** on metered lookup routes. Honor `Retry-After` (or use gradual backoff) until the request succeeds.
Free routes (`GET /v1/whoami`, `GET /v1/balance`) have per-key rate limits and may return **`429`** — see [Errors](/docs/errors).
- [Pricing](/pricing) — Compare PAYG packs and subscription tiers with live Stripe prices.
- [Balance endpoint](/docs/api/v1/balance) — GET /v1/balance — read your current credit balance for free.
- [API reference](/docs/api) — Per-operation credit cost for every endpoint.
- [Errors & outcomes](/docs/errors#outcome-semantics) — Why not_found and private outcomes arrive as HTTP 200 — and still bill.
---
# Errors
Source: https://www.socialfetch.dev/docs/errors
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/errors](https://www.socialfetch.dev/docs/errors)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/errors.mdx](https://www.socialfetch.dev/docs/errors.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Errors (https://www.socialfetch.dev/docs/errors)
Social Fetch uses two response shapes: a `{ data, meta }` envelope for successes and an `{ error }` envelope for failures. The catch most integrations miss is that a successful HTTP `200` can still carry a "not found" or "private" outcome inside `data` — so check both the status code and the outcome fields.
## Success envelope
Successful JSON responses are wrapped in a `{ data, meta }` envelope.
* **`data`** — the endpoint-specific payload
* **`meta`** — response metadata, including a support-friendly request ID
Example (`200` success):
```json
{
"data": {
"lookupStatus": "found",
"profile": {
"platform": "tiktok",
"handle": "charlidamelio",
"displayName": "charli",
"bio": "hey",
"avatarUrl": "https://example.com/avatar-large.jpg",
"verified": true,
"profileUrl": "https://www.tiktok.com/@charlidamelio",
"privateAccount": false
},
"metrics": {
"followers": 150000000,
"following": 123,
"likes": 12345678901,
"posts": 456
}
},
"meta": {
"requestId": "req_01example",
"creditsCharged": 1,
"version": "v1"
}
}
```
The exact `data` shape varies by endpoint — check the operation's `200` schema in the [API reference](/docs/api).
## Outcome semantics
Some endpoints report domain outcomes inside a `200` response rather than as a `4xx` error. For example, a profile lookup returns `lookupStatus: "not_found"` with HTTP `200`:
```json
{
"data": {
"lookupStatus": "not_found",
"profile": null,
"metrics": null
},
"meta": {
"requestId": "req_01example",
"creditsCharged": 1,
"version": "v1"
}
}
```
A single Instagram post lookup returns `lookupStatus: "restricted"` when the URL is valid but the media isn't publicly accessible (for example, age-gated posts):
```json
{
"data": {
"lookupStatus": "restricted",
"post": null,
"owner": null,
"metrics": null,
"media": null,
"downloads": []
},
"meta": {
"requestId": "req_01example",
"creditsCharged": 1,
"version": "v1"
}
}
```
Rule of thumb:
* **HTTP `200`** — parse the success envelope and check the endpoint's outcome fields (like `data.lookupStatus`).
* **Non-`200`** — parse the standard error envelope below.
### Outcome values
Depending on the endpoint, a successful response can represent any of these outcomes:
* **`found`** — the target was resolved and the expected data is present.
* **`not_found`** — the target doesn't exist or couldn't be resolved.
* **`private`** — the target exists, but its data isn't public.
* **`restricted`** — the target is reachable but can't be returned (for example, age-gated posts and reels, or pages behind bot protection).
Web extraction routes (`GET /v1/web/markdown`, `/html`, and `/ask`) return `lookupStatus: "restricted"` with HTTP `200` when a page can't be fetched because of access protection. The content fields (`markdown`, `html`, `answer`) come back null. These aren't transient failures — don't retry them.
Always confirm the exact response shape on the endpoint page in the [API reference](/docs/api).
### Empty result vs. not found
An empty collection doesn't always mean "not found." A response can be empty because:
* the profile exists but currently has no media,
* the target is valid but private,
* a post or reel URL is valid but `restricted`, or
* the target is genuinely missing.
Keep these cases distinct in your client instead of collapsing every miss into one.
### Disambiguating list routes
Some list routes return HTTP `200` with an empty collection for more than one reason and don't expose `data.lookupStatus`. When that distinction matters:
1. Call the platform **profile** route for the same handle (`GET /v1/{platform}/profiles/{handle}`).
2. Read `data.lookupStatus` (`found`, `private`, or `not_found`) from that response.
3. Call the **list** route only if you still need feed items.
If you only need "posts or nothing," skip the profile preflight and accept the ambiguity.
### Client logic
1. Check the HTTP status.
2. On `200`, inspect the endpoint's outcome fields.
3. Only fall into your error-handling path on non-`200` responses.
With the TypeScript SDK, the same steps map to `result.ok` and `result.value.data`.
### Credits and outcomes
Metered endpoints can still charge credits when we complete a lookup attempt — even if the outcome is `not_found`, `private`, or `restricted`. See [Credits](/docs/credits) for the billing details.
## Error body
Error responses return JSON with a shared `{ error }` envelope:
```json
{
"error": {
"code": "unauthorized",
"message": "Missing API key.",
"requestId": "req_01example"
}
}
```
### `error.code`
`error.code` is machine-readable and comes from a stable set of values:
* `bad_request`
* `unauthorized`
* `insufficient_credits`
* `payment_required`
* `payment_settlement_failed`
* `lookup_failed`
* `transcript_target_not_video`
* `video_too_long_for_transcription`
* `temporarily_unavailable`
* `internal_error`
Check the [API reference](/docs/api) for the exact codes each route returns per HTTP status (for example `400`, `401`, `402`, `502`, `503`).
## Request ID
Every response carries a request ID — `meta.requestId` on success, `error.requestId` on failure. Log it on failures in your client and quote it when contacting support; it ties your trace to our server logs.
## Status codes at a glance
On `503`, honor `Retry-After` when present; otherwise use exponential backoff. Don't blindly retry `4xx` errors — fix the request first.
HTTP `402` has credits, x402 challenge, and settle-failure meanings — classify before retrying.
* **`400` `bad_request`** — invalid request, or a known limitation such as `transcript_target_not_video` or `video_too_long_for_transcription`.
* **`401` `unauthorized`** — missing or invalid API key.
* **`402`** — **three related meanings:** (1) JSON `insufficient_credits` when using an API key without enough credits (optional `checkoutUrl`); (2) x402 payment required when no API key is sent — JSON `payment_required` plus the `PAYMENT-REQUIRED` header; (3) JSON `payment_settlement_failed` when payment verified and the handler succeeded but USDC settle failed (resource body withheld). See [x402](/docs/integrations/x402). Do not treat every `402` as credits exhaustion.
* **`429` `temporarily_unavailable`** — free routes only (`whoami`, `balance`); per-key rate limit. Paid metered saturation uses **`503`**, not `429`.
* **`500` `internal_error`** — unexpected server error.
* **`502` `lookup_failed`** — the lookup couldn't be completed.
* **`503` `temporarily_unavailable`** — service briefly unavailable (including queue/capacity saturation under extreme concurrency). Safe to retry; honor **`Retry-After`** when present. **Not charged** on metered lookup routes — see [Credits](/docs/credits).
- [Credits](/docs/credits) — When routes charge and how to handle `402`.
- [API reference](/docs/api) — Full response schemas per status code.
- [SDK](/docs/sdk) — If you use the TypeScript SDK, the same HTTP and outcome semantics still apply.
---
# Integrations
Source: https://www.socialfetch.dev/docs/integrations
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/integrations](https://www.socialfetch.dev/docs/integrations)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/integrations.mdx](https://www.socialfetch.dev/docs/integrations.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Integrations (https://www.socialfetch.dev/docs/integrations)
Use Social Fetch wherever you work — wire it into automation platforms or call the API from your own code. Every path uses the same endpoints, response envelope, and credit metering.
Integrations map directly to the [API reference](/docs/api). Each n8n operation or Apify Actor corresponds to one documented route; the SDK wraps the same surface with typed methods.
## No-code & automation
- [MCP](/mcp) — Connect Cursor, VS Code, or Claude with OAuth — every endpoint as a tool, plus docs your agent can read while it builds.
- [Agent Skills](/docs/integrations/skills) — Install with npx skills — teach agents to read llms.txt, use MCP, call POST /v1/ask, and never invent endpoints.
- [x402](/docs/integrations/x402) — Pay USDC per request on Base without an API key (agents and wallets).
- [n8n](/docs/integrations/n8n) — Fetch TikTok, Instagram, YouTube, and 8 more platforms from n8n workflows — one node, every public endpoint.
- [Pipedream](/docs/integrations/pipedream) — Polling profile updates plus consolidated profile, post, transcript, and balance actions for Pipedream workflows.
- [Apify](/docs/integrations/apify) — Four TikTok Store Actors — profiles, videos, transcripts, and profile feeds with pay-per-result billing and dataset export.
## Build with the API
- [TypeScript SDK](/docs/sdk) — Typed client methods, Result handling, and parity with every documented route.
- [REST API](/docs/api) — Interactive operation pages — params, examples, and response shapes.
## Browse all integrations
Visit the [Integrations hub](/integrations) for a quick overview of every way to connect to Social Fetch.
---
# Apify
Source: https://www.socialfetch.dev/docs/integrations/apify
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/integrations/apify](https://www.socialfetch.dev/docs/integrations/apify)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/integrations/apify.mdx](https://www.socialfetch.dev/docs/integrations/apify.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Apify (https://www.socialfetch.dev/docs/integrations/apify)
Run **Social Fetch** on [Apify](https://apify.com) as Store Actors under [@social-fetch](https://apify.com/social-fetch). Each Actor maps 1:1 to a [documented REST route](/docs/api), writes results to the default dataset, and bills via Apify pay-per-event (PPE). Sign in with your **Apify token only** — no Social Fetch API key in Actor input.
## What you'll need
* A free [Apify](https://apify.com) account.
* An **Apify API token** for the Console, `apify-client`, REST API, or schedules.
* Billing through **Apify PPE** (per dataset row) — not Social Fetch credits.
## Quick start
1. Open the [@social-fetch](https://apify.com/social-fetch) Store page and pick an Actor.
2. Click **Try for free**, paste handles or URLs on the **Input** tab, and click **Start**.
3. Open the run **Output** tab when the Actor finishes. Each dataset row matches the REST API `{ data, meta }` envelope. Export as JSON, CSV, or Excel from **Export**.
## Results
Each completed lookup becomes one dataset item. HTTP **200** does not always mean data was found — check `lookupStatus` on each item when present. See [Errors](/docs/errors).
## Pricing
**$1.98 per 1,000 dataset rows** on all Actors, plus a small per-run start fee on Apify. You are charged for **completed** lookups, including `not_found`. See each Actor's Store page for the live pricing table.
## Programmatic runs
Trigger runs with `apify-client`, the Apify REST API, schedules, or webhooks.
```javascript
import { ApifyClient } from "apify-client";
const client = new ApifyClient({ token: "YOUR_APIFY_TOKEN" });
const run = await client.actor("social-fetch/tiktok-profile-scraper").call({
handles: ["mrbeast"],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```
## Troubleshooting
| Symptom | What to check |
| -------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| Run fails with auth error | Apify token missing or invalid — regenerate in Console → Settings → Integrations. |
| Empty dataset | Invalid handle or URL in input. Check the run log for per-item errors. |
| `lookupStatus: not_found` or `private` | Lookup completed successfully but nothing was found — still billed as a row. See [Errors](/docs/errors). |
| Rate limit (429) | Wait and retry; use smaller batches. |
| Higher cost than expected | PPE charges per dataset row. Profile-videos emits one row per video, including `not_found`. |
## Next steps
- [API reference](/docs/api) — Response shapes and parameters behind every Actor — same routes, same envelope.
- [n8n](/docs/integrations/n8n) — Full platform coverage in no-code workflows with your own API key.
- [MCP](/docs/integrations/mcp) — OAuth-connected tools for Cursor, VS Code, and Claude.
- [Credits & billing](/docs/credits) — How metered routes work when you switch to the REST API or SDK.
---
# MCP
Source: https://www.socialfetch.dev/docs/integrations/mcp
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/integrations/mcp](https://www.socialfetch.dev/docs/integrations/mcp)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/integrations/mcp.mdx](https://www.socialfetch.dev/docs/integrations/mcp.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# MCP (https://www.socialfetch.dev/docs/integrations/mcp)
Connect Social Fetch to Cursor, VS Code, Claude, and other MCP clients. Every [public API endpoint](/docs/api) becomes a tool your agent can call — billed like the REST API. Sign in once with **OAuth**; no API key in your config.
Product overview (install buttons, Skills, FAQ): [/mcp](/mcp).
For durable onboarding instructions (read `llms.txt`, use `POST /v1/ask`, never invent routes), also install the [Agent Skills](/docs/integrations/skills) pack: `npx skills add social-freak-ltd/socialfetch -s socialfetch`.
## Connect
Server URL: **`https://api.socialfetch.dev/mcp`**
Only need a couple of platforms? [Scope the tool list](#scope-the-tool-list) to cut context bloat — your client loads fewer tool schemas up front.
### Manual setup
**Cursor** — `~/.cursor/mcp.json` or project `.cursor/mcp.json`:
```json
{
"mcpServers": {
"socialfetch": {
"url": "https://api.socialfetch.dev/mcp"
}
}
}
```
Restart Cursor, open MCP settings, and finish the OAuth browser flow when prompted.
**VS Code** — `settings.json`:
```json
{
"mcp": {
"servers": {
"socialfetch": {
"url": "https://api.socialfetch.dev/mcp"
}
}
}
}
```
**Claude Code**
```bash
claude mcp add --transport http socialfetch https://api.socialfetch.dev/mcp
```
Then `/mcp` → authenticate Social Fetch.
**Claude Desktop** — add a custom remote connector with the server URL above.
**stdio-only clients** — `npx mcp-remote https://api.socialfetch.dev/mcp`
## Scope the tool list
The base URL exposes every public API endpoint tool (plus auth, billing, docs, and nl\_ask helpers). That works in Cursor and other clients that handle large catalogs, but it can bloat agent context. Scope when you only need certain platforms or want a leaner tool list.
Pick the platforms you care about, then copy a URL or config snippet into your client. Leave everything clear for the full catalog.
Query params only affect **`tools/list`** — what your client shows up front. **`tools/call` still works for any valid tool name**, even if it was filtered out of the list (for example, a tool your agent learned from docs).
Every scoped connection still includes these utilities:
`auth_whoami`, `billing_balance_get`, `docs_search`, `docs_read`, `nl_ask_post`
You can also hand-edit URLs: `?platforms=twitter,tiktok`, `?tools=twitter_profile_get`, or both (union). OAuth and one-click install use the base URL **`https://api.socialfetch.dev/mcp`** without query — authenticate on the base URL, then paste a scoped URL if you want a smaller tool list.
## Auth & billing
OAuth 2.1 — your client opens Social Fetch in the browser, you approve, and it stores a token. Credits charge to your signed-in account, same as REST. See [Credits & billing](/docs/credits).
**Walk-up without OAuth:** anonymous MCP clients can pay paid tools with [x402](/docs/integrations/x402) (USDC on Base). Register Exact **and** Upto schemes; metered tools need a one-time Permit2 approve. Whoami, balance, and NL Ask still require OAuth. Invalid Bearer returns **401** (no x402 fallback).
## Tools
One tool per API operation (`tiktok_profile_get` ↔ `tiktok.profile.get`). Arguments and pricing match the [API reference](/docs/api).
On connect, the server sends short agent instructions: prefer the most specific typed tool, use `docs_search` / `docs_read` when unsure, and read `lookupStatus` / `meta.creditsCharged` on responses.
Free helpers: `docs_search`, `docs_read`. For natural-language routing, use `nl_ask_post` (0 routing credits; the nested lookup is metered).
## Example
```json
{ "handle": "nike" }
```
Call `tiktok_profile_get`, or ask with `nl_ask_post`: `{ "query": "TikTok profile for @nike" }`.
## Troubleshooting
| Symptom | Fix |
| ---------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `401` | Reconnect and finish OAuth |
| OAuth loop | Sign in at Social Fetch, then approve access |
| `402` | With OAuth: top up in [Credits & billing](/docs/credits). Anonymous: complete the [x402](/docs/integrations/x402) payment challenge |
| No tools | Reconnect; restart the client if needed |
## Related
- [Agent Skills](/docs/integrations/skills) — npx skills install — llms.txt, MCP, /v1/ask, no invented endpoints.
- [API reference](/docs/api) — Every operation the MCP tools wrap.
- [Credits & billing](/docs/credits) — How credits are metered across MCP and REST.
- [x402](/docs/integrations/x402) — Pay per tool call in USDC without OAuth (Exact + Upto).
- [n8n](/docs/integrations/n8n) — No-code workflows with an API key.
- [Apify](/docs/integrations/apify) — Store Actors with Apify-native billing.
---
# n8n
Source: https://www.socialfetch.dev/docs/integrations/n8n
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/integrations/n8n](https://www.socialfetch.dev/docs/integrations/n8n)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/integrations/n8n.mdx](https://www.socialfetch.dev/docs/integrations/n8n.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# n8n (https://www.socialfetch.dev/docs/integrations/n8n)
Add **Social Fetch** to [n8n](https://n8n.io) and every platform we support becomes a drag-and-drop step: pull profiles, posts, and metrics into a workflow, or attach the node to an AI agent as a live data tool. Each operation maps 1:1 to a [public API endpoint](/docs/api), so anything in the API reference works as a no-code step. **`n8n-nodes-socialfetch`** is a [verified node](https://docs.n8n.io/integrations/community-nodes/installation/verified-install/), so you install it straight from n8n's nodes panel.
## What you'll need
* An **n8n instance** on **v1.94.0 or later**.
* A **Social Fetch API key** (starts with `sfk_`) — create one in your [API Keys](https://app.socialfetch.dev/api-keys) dashboard.
* **Credits** on your account for metered routes — see [Credits & billing](/docs/credits).
## Install
Social Fetch is a verified n8n node, so you can add it to your instance straight from the editor. You'll need **owner or admin** access to install it; once it's in, everyone on the instance can use it.
1. Open a workflow and open the nodes panel — click **`+`** or press **`N`**.
2. Search for **Social Fetch** and select it from the **More from the community** section.
3. On the node's details page, click **Install node**.
4. Pick an action — for example **Get TikTok profile** — to add the node to your workflow.
## Credentials
Social Fetch authenticates with an API key (it starts with `sfk_`). Create one in your [**API Keys**](https://app.socialfetch.dev/api-keys) dashboard, then connect it from inside the node:
1. Open your Social Fetch node and click **Set up credential** next to the **Credential** field.
2. Paste your key into **API Key** and click **Save**.
n8n checks the key against your account as you save it, so an invalid key is flagged right away.
## Using the node
Open the Social Fetch node and set up the request:
1. **Credential** — select the credential you just created.
2. **Resource** — pick the platform (e.g. TikTok, Instagram, Web) or **Account** for whoami/balance.
3. **Operation** — choose the endpoint (e.g. Profile, Search, Markdown).
4. **Required fields** — shown as direct inputs on the node.
5. **Additional Fields** — optional query parameters (sort order, limits, etc.).
The node is marked **usable as tool**, so you can also attach it to n8n AI agents that need live social or web data.
### Pagination and Return All
Only list endpoints that use Social Fetch's **cursor** query parameter show a **Return All** toggle. When enabled, the node follows `data.page.nextCursor` until `data.page.hasMore` is false. Each page is a separate output item containing the full API JSON body (`data`, `meta`, etc.). Use n8n's **Item Lists** or **Code** node if you need a single merged array.
List endpoints that return everything in one response (no cursor), or that paginate with other parameters such as `page`, do not show **Return All** — you get the first response only unless you pass those parameters under **Additional Fields**.
### Credits
Every request consumes credits from your Social Fetch balance (most endpoints cost 1 credit; some search and media-download options cost more). The credits charged for each call are returned in `meta.creditsCharged`. See [Credits & billing](/docs/credits) for details.
## Example workflow
This example fetches a TikTok creator's recent videos and keeps only the high-performing ones.
1. **Manual Trigger** — so you can run the workflow on demand while testing.
2. **Social Fetch** — set **Resource** to `TikTok` and **Operation** to `Profile videos`.
* **Handle**: `n8n`
* Turn on **Return All** to page through every video, or leave it off to fetch the first page.
* Under **Additional Fields**, set **Sort By** to `Popular`.
3. **Split Out** — field to split out: `data.videos` (one item per video).
4. **Filter** — keep videos above a view threshold:
* Condition: `{{ $json.stats.views }}` *is greater than* `100000`.
Each Social Fetch item is one API page. With **Return All** off you get a single page; with it on you get one item per page, each containing `data.videos`, `data.page`, and `meta`. **Split Out** turns the videos array into individual items so the Filter node can evaluate `stats.views` on each video.
Example response shape (first video on a page):
```json
{
"data": {
"videos": [
{
"id": "7639528062975053069",
"caption": "…",
"url": "https://www.tiktok.com/@handle/video/7639528062975053069",
"stats": {
"views": 302447,
"likes": 19880,
"comments": 339,
"shares": 2232,
"saves": 389
}
}
],
"page": { "nextCursor": "…", "hasMore": true }
},
"meta": { "creditsCharged": 1, "requestId": "…", "version": "v1" }
}
```
### Enrichment pattern
A second common pattern is enrichment: use **TikTok → User search** (or **Search videos**) to discover handles, then loop those results back into **Profile videos** or **Profile** to pull full details for each match.
## Next steps
- [API reference](/docs/api) — Browse every endpoint the n8n node exposes — params, examples, and response shapes.
- [Credits & billing](/docs/credits) — Understand metered routes, 402 handling, and creditsCharged metadata.
- [Apify](/docs/integrations/apify) — TikTok Store Actors with dataset export and pay-per-result billing on Apify.
---
# Pipedream
Source: https://www.socialfetch.dev/docs/integrations/pipedream
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/integrations/pipedream](https://www.socialfetch.dev/docs/integrations/pipedream)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/integrations/pipedream.mdx](https://www.socialfetch.dev/docs/integrations/pipedream.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Pipedream (https://www.socialfetch.dev/docs/integrations/pipedream)
Add **Social Fetch** to [Pipedream](https://pipedream.com) workflows and pull live social data without writing HTTP glue. Authenticate with your API key (`sfk_…`); each step returns the same `{ data, meta }` envelope as the [REST API](/docs/api).
The v1 integration ships one polling **source** and five consolidated **actions** that cover the most common workflow paths — profile lookups, post fetches, feed pagination, transcripts, and balance checks.
## What you'll need
* A **Pipedream** account.
* A **Social Fetch API key** (starts with `sfk_`) — create one in your [API Keys](https://app.socialfetch.dev/api-keys) dashboard.
* **Credits** for metered routes — see [Credits & billing](/docs/credits).
## Connect your API key
1. Open a workflow and add a **Social Fetch** step (search for **Social Fetch** in the step picker).
2. When prompted, paste your full `sfk_…` key from [API Keys](https://app.socialfetch.dev/api-keys).
3. Pipedream validates the connection with `GET /v1/whoami` before saving.
The same credential is reused across every Social Fetch source and action in your account.
## Components (v1)
| Type | Name | Purpose |
| ------ | ------------------ | ----------------------------------------------------------- |
| Source | New Profile Update | Poll a profile on a schedule; emit when the payload changes |
| Action | Get Profile | Public profile lookup by handle or URL |
| Action | Get Post | Post, video, or tweet lookup from URL |
| Action | List Profile Posts | Recent feed items with optional cursor pagination |
| Action | Get Transcript | Video or post transcript from URL |
| Action | Get Credit Balance | Current API credit balance |
Every action maps to the same routes documented in the [API reference](/docs/api).
### New Profile Update (source)
The polling source watches one profile and emits when Social Fetch returns a changed payload:
1. Choose a **Platform** and provide a **Handle** (TikTok, Instagram, Twitter/X, Threads) or **Profile URL** (Facebook, LinkedIn).
2. Pipedream polls on the default timer interval, fetches the profile, and compares the response to the last stored snapshot.
3. When a diff is detected, the workflow receives the full API response plus a `diff` object showing what changed.
Use this for creator monitoring, follower-count alerts, or any workflow that should react to profile changes without polling the REST API yourself.
### Platform coverage by action
**Get Profile** — TikTok, Instagram, Twitter/X, Threads (handle), Facebook and LinkedIn (profile URL).
**Get Post** — TikTok, Instagram, Twitter/X, Threads, Facebook, YouTube, LinkedIn (post URL).
**List Profile Posts** — TikTok (`videos`), Instagram (`posts` or `reels`), Twitter/X (`tweets`), Threads and Facebook (`posts`). Pass `data.page.nextCursor` from a previous response to fetch the next page.
**Get Transcript** — TikTok, Instagram, Facebook, YouTube (media URL).
**Get Credit Balance** — account-wide; no platform input required.
### Credits
Each step consumes credits from your Social Fetch balance. The amount charged is returned in `meta.creditsCharged` on every response. See [Credits & billing](/docs/credits) for metered routes and 402 handling.
## Full API surface
Pipedream v1 intentionally covers high-traffic workflow paths. For every documented route — Reddit, Spotify, web scrape, and more — use the [REST API](/docs/api), [TypeScript SDK](/docs/sdk), [n8n node](/docs/integrations/n8n), or [Apify Store Actors](/docs/integrations/apify) for TikTok-only Apify-native runs.
## Next steps
- [API reference](/docs/api) — Browse every endpoint behind the Pipedream actions — params, examples, and response shapes.
- [n8n](/docs/integrations/n8n) — Full platform coverage in no-code workflows with the same API key.
- [MCP](/docs/integrations/mcp) — OAuth-connected tools for Cursor, VS Code, and Claude.
- [Credits & billing](/docs/credits) — Understand metered routes, 402 handling, and creditsCharged metadata.
---
# Agent Skills
Source: https://www.socialfetch.dev/docs/integrations/skills
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/integrations/skills](https://www.socialfetch.dev/docs/integrations/skills)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/integrations/skills.mdx](https://www.socialfetch.dev/docs/integrations/skills.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Agent Skills (https://www.socialfetch.dev/docs/integrations/skills)
Give coding agents a short onboarding pack for Social Fetch: how to read [`/llms.txt`](https://www.socialfetch.dev/llms.txt) and [`/agents.txt`](https://www.socialfetch.dev/agents.txt), use per-platform [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt) files, connect [MCP](/mcp), call `POST /v1/ask`, create an API key, and stop inventing routes that do not exist.
## Install
```bash
npx skills add social-freak-ltd/socialfetch -s socialfetch
```
Useful flags: `-g` for a user-level install, `-y` to skip prompts, `-a cursor` (or `claude-code`, etc.) to target one agent.
Install from the skill path only (avoids other skills that may live in this monorepo):
```bash
npx skills add https://github.com/social-freak-ltd/socialfetch/tree/main/skills/socialfetch
```
Browse the ecosystem at [skills.sh](https://skills.sh/). Source: [`skills/socialfetch`](https://github.com/social-freak-ltd/socialfetch/tree/main/skills/socialfetch) in the Social Fetch repo.
## What the skill teaches
* Read **`/llms.txt`** and **`/agents.txt`**, then **`/llms-endpoints.txt`** or **`/llms-{platform}.txt`**, before writing integration code
* Connect hosted MCP at `https://api.socialfetch.dev/mcp` with **OAuth** (no API key in MCP config)
* Use **`POST /v1/ask`** / MCP `nl_ask_post` to explore, then pin the typed route
* Create a **`sfk_…`** key at [API Keys](https://app.socialfetch.dev/api-keys) for REST and the SDK
* Treat `lookupStatus` and `meta.requestId` correctly — never invent endpoints
After install, ask your agent to fetch Social Fetch data or scaffold a lookup. It should load the skill when Social Fetch is in scope.
## Skills vs MCP vs llms.txt
| Piece | Role |
| --------------------------------------------- | -------------------------------------------------------------------------- |
| **Agent Skill** | Durable instructions in the agent harness (when / how to use Social Fetch) |
| **MCP** | Live tools — call endpoints and docs search while coding |
| **`/llms.txt`** / **`/agents.txt`** | Public orientation and crawl/onboarding files |
| **`/llms-{platform}.txt`** | Per-platform parameters, credits, and example curls |
You can use any combination. Skill + MCP is the usual Cursor/Claude setup; REST + skill works for custom orchestrators.
## Related
- [MCP](/mcp) — OAuth tool server for Cursor, VS Code, and Claude.
- [Quickstart](/docs/quickstart) — API key, first request, and response envelope.
- [Cursor & Claude guide](/guides/social-fetch-with-cursor-claude) — End-to-end MCP + llms.txt workflow.
---
# x402
Source: https://www.socialfetch.dev/docs/integrations/x402
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/integrations/x402](https://www.socialfetch.dev/docs/integrations/x402)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/integrations/x402.mdx](https://www.socialfetch.dev/docs/integrations/x402.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# x402 (https://www.socialfetch.dev/docs/integrations/x402)
Most integrations should use an [API key and credits](/docs/credits). **x402** is the walk-up path: call a paid `/v1` endpoint without a key, pay **USDC on Base**, get the same JSON back.
Account routes (`/v1/whoami`, `/v1/balance`) and NL Ask (`POST /v1/ask`) always need an API key — they are not on the x402 rail.
Paid endpoints are also discoverable in the [Coinbase x402 Bazaar](https://docs.cdp.coinbase.com/x402/bazaar) catalog (HTTP and MCP).
## How it works
```mermaid
sequenceDiagram
participant You
participant API as Social Fetch API
participant Wallet
You->>API: Request (no API key)
API-->>You: 402 + PAYMENT-REQUIRED
You->>Wallet: Sign payment
You->>API: Same request + PAYMENT-SIGNATURE
API-->>You: 200 + data + PAYMENT-RESPONSE
```
1. Call a paid endpoint **without** `x-api-key`.
2. Read HTTP **402** and the `PAYMENT-REQUIRED` header (Base64 JSON — amount, network, pay-to, **scheme**).
3. Sign the payment (wallet or [`@x402/fetch`](https://docs.x402.org/getting-started/quickstart-for-buyers)).
4. Retry the **same** request with `PAYMENT-SIGNATURE`.
5. On success, use the JSON body as usual; `PAYMENT-RESPONSE` is the settlement receipt.
Price matches the Starter pack list rate: **$0.014 per credit**. Metering is the same as the credits rail (including attempt floors on some search endpoints).
Optional: send a [payment-identifier](https://docs.x402.org/extensions/payment-identifier) so retries stay idempotent.
## Exact vs upto
The `PAYMENT-REQUIRED` challenge includes a **scheme**. Register both schemes on your buyer client so every paid route works.
| Scheme | When you see it | Buyer setup |
| ----------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| **`exact`** | Flat-price routes (most endpoints) | Sign each request. USDC uses EIP-3009 — **no** on-chain approve |
| **`upto`** | Metered routes (e.g. list/search that charge per returned record) | Authorize a **ceiling**; settle charges only what was used. Needs a one-time Permit2 approve (below) |
If you only register `ExactEvmScheme`, metered/`upto` calls will fail after the payment challenge.
## One-time Permit2 approve
For **`upto`** on Base, your buyer wallet must approve the canonical Permit2 contract to spend USDC **once**:
* USDC (Base): `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`
* Permit2: `0x000000000022D473030F116dDEE9F6B43aC78BA3`
Call `USDC.approve(Permit2, maxUint256)` (or a large allowance) from the paying wallet. Exact / EIP-3009 routes do **not** need this. This is standard x402 EVM buyer setup for Permit2-based `upto`, not a Social Fetch-specific quirk. See the [CDP / x402 buyer docs](https://docs.cdp.coinbase.com/x402/quickstart-for-buyers).
## Distinguish HTTP 402
| Kind | How to tell | What to do |
| -------------- | ------------------------------------------------------------- | ------------------------------------------------------------------- |
| Credits | `error.code = "insufficient_credits"` (API key present) | Top up credits |
| x402 challenge | `PAYMENT-REQUIRED` header + `error.code = "payment_required"` | Pay USDC and retry |
| Settle failed | `error.code = "payment_settlement_failed"` | Not a successful response — retry only with a new payment if needed |
Do **not** treat every `402` as “out of credits.” For walk-up pay, look for the `PAYMENT-REQUIRED` header. Full envelopes: [Errors](/docs/errors).
## Try unpaid
```bash
curl -i "https://api.socialfetch.dev/v1/twitter/profiles/elonmusk"
```
Expect `402`, a `PAYMENT-REQUIRED` header, and a JSON body pointing at this page (and the API-key quickstart).
## Pay from Node
Install the official buyer helpers, then wrap `fetch`. Register **Base** (`eip155:8453`) and **both** Exact and Upto schemes.
```bash
npm install @x402/fetch @x402/evm viem
```
```ts
import { wrapFetchWithPayment, x402Client } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { UptoEvmScheme } from "@x402/evm/upto/client";
import { privateKeyToAccount } from "viem/accounts";
const signer = privateKeyToAccount(
process.env.EVM_PRIVATE_KEY as `0x${string}`,
);
const client = new x402Client()
.register("eip155:8453", new ExactEvmScheme(signer))
.register("eip155:8453", new UptoEvmScheme(signer));
const fetchWithPayment = wrapFetchWithPayment(fetch, client);
const res = await fetchWithPayment(
"https://api.socialfetch.dev/v1/twitter/profiles/elonmusk",
);
console.log(res.status, await res.json());
console.log(res.headers.get("PAYMENT-RESPONSE"));
```
Keep the private key server-side. Prefer the official [buyer quickstart](https://docs.x402.org/getting-started/quickstart-for-buyers) for other languages (Go, Python, etc.).
## MCP
[MCP](/docs/integrations/mcp) supports the same dual-rail idea:
* **OAuth** → tools bill **credits** on your account (whoami, balance, and NL Ask always need OAuth).
* **Anonymous** (no Bearer) → paid tools challenge with x402; attach payment meta and settle in USDC (Exact + Upto, same Permit2 rule as HTTP).
Invalid Bearer still returns **401** (it does not fall through to x402).
## Further reading
* [x402 protocol docs](https://docs.x402.org/)
* [Buyer quickstart](https://docs.x402.org/getting-started/quickstart-for-buyers)
* [Payment identifier](https://docs.x402.org/extensions/payment-identifier)
* [Coinbase x402 Bazaar](https://docs.cdp.coinbase.com/x402/bazaar)
* [Credits & billing](/docs/credits) — API key path
* [Errors](/docs/errors) — `402` envelopes
---
# Quickstart
Source: https://www.socialfetch.dev/docs/quickstart
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/quickstart](https://www.socialfetch.dev/docs/quickstart)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/quickstart.mdx](https://www.socialfetch.dev/docs/quickstart.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Quickstart (https://www.socialfetch.dev/docs/quickstart)
Use the **TypeScript SDK** tab in step 2 for a typed client call, then see the [**TypeScript SDK**](/docs/sdk) guide for `Result`-based error handling and the full method inventory.
## Before you start
* **Base URL:** `https://api.socialfetch.dev`
* **API key:** create one in [**API Keys**](https://app.socialfetch.dev/api-keys)
* **Auth header:** send `x-api-key` on every request under `/v1`
* **Security rule:** keep the key server-side only; never ship it in browsers or mobile apps
## 1. Save your API key
Keep the key in an environment variable rather than hardcoding it. Use `.env` for app code, or export it in your shell for one-off requests.
## 2. Make your first request
Start with a single profile lookup. It confirms your auth works and returns the standard `data + meta` envelope you'll see on every endpoint.
A `200` means your key works and you can move on to reading `data`. A `401` means auth isn't wired up yet — re-check the header and environment variable in step 1.
## 3. Read the response
A successful response wraps the endpoint payload in a standard envelope:
```json
{
"data": {
"lookupStatus": "found",
"profile": { "...": "..." },
"metrics": { "...": "..." }
},
"meta": {
"requestId": "req_01example",
"creditsCharged": 1,
"version": "v1"
}
}
```
Check these fields in order:
1. **HTTP status** — `200` means the request succeeded at the transport level. Anything else: read the `{ error }` body instead.
2. **`meta.requestId`** — log it on failures and quote it in support requests.
3. **`meta.creditsCharged`** — on metered routes, exactly what this call billed.
4. **Outcome fields in `data`** — for profile lookups, check `data.lookupStatus`. `found`, `private`, and `not_found` all arrive with HTTP `200`.
The one rule worth remembering: **`200` doesn't always mean "data is present."** Many routes report the real outcome inside `data`, so check it before using the payload.
## 4. Handle common first-run failures
* **`401 unauthorized`** — the key is missing, invalid, or sent incorrectly. Re-check your `x-api-key` header and environment variable.
* **`402 insufficient_credits`** — auth is fine, but the account is out of credits for that route. See [Credits](/docs/credits).
* **`503 temporarily_unavailable`** — the service is briefly unavailable (including under extreme concurrency). Honor `Retry-After` when present; otherwise retry with backoff. Not charged on metered routes — see [Credits](/docs/credits).
* **`200` with `lookupStatus: "not_found"` or `"private"`** — a successful response, just not a "found" outcome. Handle it as data, not as an error.
For the full error envelope, retry guidance, and request ID semantics, see [Errors](/docs/errors).
## Where to go next
- [API reference](/docs/api) — Every documented endpoint, with params, schemas, and per-route behavior.
- [TypeScript SDK](/docs/sdk) — Typed methods, `Result` handling, and `unwrap()` for TypeScript-first integrations.
- [Errors](/docs/errors) — HTTP errors, outcome semantics, request IDs, and retry guidance.
- [Credits](/docs/credits) — Which routes charge, how to interpret `creditsCharged`, and what `402` means.
---
# Recipes
Source: https://www.socialfetch.dev/docs/recipes
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/recipes](https://www.socialfetch.dev/docs/recipes)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/recipes.mdx](https://www.socialfetch.dev/docs/recipes.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Recipes (https://www.socialfetch.dev/docs/recipes)
Recipes are short, opinionated workflows built from routes that already exist in the [API reference](/docs/api). Each one shows which endpoints to call, how credits usually add up, and a TypeScript SDK sketch you can paste into a worker.
They are not a second API. If a route is not linked here, it is not part of the recipe — check [`/llms-endpoints.txt`](/llms-endpoints.txt) or the platform pages before inventing one.
Metered lookups bill on completed attempts, including `not_found` / `private` on HTTP `200`. Routing via [`POST /v1/ask`](/docs/api/v1/ask/post) is free; the nested lookup is not. Always trust `meta.creditsCharged`. See [Credits](/docs/credits).
## Pick a recipe
- [Brand monitoring](/docs/recipes/brand-monitoring) — Ask once to discover routes, then pin platform search on a schedule.
- [Competitor profile tracking](/docs/recipes/competitor-profile-tracking) — Fan out the same brand across TikTok, Instagram, YouTube, and X.
- [Video transcription](/docs/recipes/video-transcription) — YouTube, TikTok, and Instagram transcripts into one worker shape.
- [Facebook Ad Library](/docs/recipes/facebook-ad-library) — Keyword search plus company ad lists for competitive creative.
- [Creator engagement scoring](/docs/recipes/creator-engagement-scoring) — Profile + recent posts, then score median views yourself.
- [Reddit research](/docs/recipes/reddit-research) — Global search, subreddit scope, and comment pulls for a listening pulse.
## How to use these
1. Start from [Quickstart](/docs/quickstart) or the [TypeScript SDK](/docs/sdk) if you do not have a key yet.
2. Prefer typed routes once you know the platform. Use [`POST /v1/ask`](/docs/api/v1/ask/post) (or MCP `nl_ask_post`) only to discover `data.routedOperation`, then pin that method.
3. In Cursor or Claude, connect [MCP](/docs/integrations/mcp) and optionally install [Agent Skills](/docs/integrations/skills) so the agent reads `/llms.txt` instead of guessing paths.
4. For longer tutorials with storage and alert patterns, see the [Guides](/guides) section — recipes stay short on purpose.
## Related
* [Platform hubs](/platforms) — product pages per network
* [API reference](/docs/api) — generated schemas and examples
* [Errors](/docs/errors) — `lookupStatus` vs HTTP status
* [Credits](/docs/credits) — metering, balance, and `402`
---
# Brand monitoring
Source: https://www.socialfetch.dev/docs/recipes/brand-monitoring
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/recipes/brand-monitoring](https://www.socialfetch.dev/docs/recipes/brand-monitoring)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/recipes/brand-monitoring.mdx](https://www.socialfetch.dev/docs/recipes/brand-monitoring.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Brand monitoring (https://www.socialfetch.dev/docs/recipes/brand-monitoring)
Watch public mentions of a brand without maintaining per-platform scrapers. Use [`POST /v1/ask`](/docs/api/v1/ask/post) once to learn which typed route fits a question, then call that search endpoint on a cron. Social Fetch does not push webhooks — listening is pull + your scheduler.
**You'll need** an [API key](https://app.socialfetch.dev/api-keys) and the [TypeScript SDK](/docs/sdk). For agent prototyping, connect [MCP](/docs/integrations/mcp) and use `nl_ask_post` the same way.
## Credit budget
Ask routing is **0 credits**. Each nested or direct search page bills at that route's rate — typically **1 credit** (TikTok, YouTube, Reddit, Instagram) or **2 credits** (X/Twitter search). Empty result pages still bill when the lookup completes. Check balance with free [`GET /v1/balance`](/docs/api/v1/balance) before high-frequency polls.
Rough daily math: `platforms × keywords × polls_per_day × credits_per_call`. Example: 4 platforms × 3 terms × 24 hourly polls × \~1.5 avg credits ≈ **432 credits/day** (X at 2 credits pulls the average up).
## Step 1: Discover with Ask
Ask is one-shot routing, not a chat. Read `data.routedOperation`, then switch to the typed SDK method for every repeat call.
```ts
import { SocialFetchClient } from "@socialfetch/sdk";
const client = new SocialFetchClient({
apiKey: process.env.SOCIALFETCH_API_KEY!,
});
const ask = await client.ask({
query: "Search recent TikTok videos mentioning Acme coffee",
});
if (!ask.ok) {
console.error(ask.error.code, ask.error.requestId);
return;
}
console.log(ask.value.data.routedOperation);
console.log(ask.value.meta.creditsCharged); // nested lookup only
```
MCP equivalent: tool `nl_ask_post` with `{ "query": "…" }`.
## Step 2: Pin platform search
Once you know the routes, call them directly:
| Platform | Route | SDK | Credits |
| ------------------------------- | ----------------------------------------------------------- | ------------------------------------------------------ | ------- |
| [TikTok](/platforms/tiktok) | [`GET /v1/tiktok/search`](/docs/api/v1/tiktok/search/get) | `client.tiktok.searchVideos({ query, … })` | 1 |
| [X/Twitter](/platforms/twitter) | [`GET /v1/twitter/search`](/docs/api/v1/twitter/search/get) | `client.twitter.search({ query, section?, … })` | 2 |
| [YouTube](/platforms/youtube) | [`GET /v1/youtube/search`](/docs/api/v1/youtube/search/get) | `client.youtube.search({ query, uploadDate?, … })` | 1 |
| [Reddit](/platforms/reddit) | [`GET /v1/reddit/search`](/docs/api/v1/reddit/search/get) | `client.reddit.search({ query, sortBy?, timeframe? })` | 1 |
```ts
async function pollBrand(query: string) {
const capturedAt = new Date().toISOString();
const [tiktok, twitter, youtube, reddit] = await Promise.all([
client.tiktok.searchVideos({ query, sortBy: "date-posted" }),
client.twitter.search({ query, section: "latest", language: "en" }),
client.youtube.search({ query, uploadDate: "this_week", sortBy: "relevance" }),
client.reddit.search({ query, sortBy: "new", timeframe: "week" }),
]);
return {
capturedAt,
batches: [
{ platform: "tiktok", result: tiktok },
{ platform: "twitter", result: twitter },
{ platform: "youtube", result: youtube },
{ platform: "reddit", result: reddit },
],
};
}
```
Branch on `result.ok` first. On success, store `meta.requestId` and `meta.creditsCharged` with each snapshot. Paginate with `data.page.nextCursor` / `hasMore` when you need more than one page.
Hashtag campaigns: [TikTok hashtags](/docs/api/v1/tiktok/search/hashtags/get), [YouTube hashtags](/docs/api/v1/youtube/search/hashtags/get), [Twitter hashtags](/docs/api/v1/twitter/hashtags/get).
## Step 3: Dedupe in your warehouse
Social Fetch returns point-in-time JSON. Upsert on `(platform, postId)`, compare today's net-new IDs to a baseline, and alert on velocity — not on `items.length` from a single poll.
Longer pipeline (cron, spike detection, Slack): [Build a social listening dashboard](/guides/social-listening-dashboard).
## Related
* [Ask](/docs/api/v1/ask/post) · [Credits](/docs/credits) · [MCP](/docs/integrations/mcp) · [SDK](/docs/sdk)
* Platforms: [TikTok](/platforms/tiktok) · [Twitter](/platforms/twitter) · [YouTube](/platforms/youtube) · [Reddit](/platforms/reddit)
---
# Competitor profile tracking
Source: https://www.socialfetch.dev/docs/recipes/competitor-profile-tracking
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/recipes/competitor-profile-tracking](https://www.socialfetch.dev/docs/recipes/competitor-profile-tracking)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/recipes/competitor-profile-tracking.mdx](https://www.socialfetch.dev/docs/recipes/competitor-profile-tracking.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Competitor profile tracking (https://www.socialfetch.dev/docs/recipes/competitor-profile-tracking)
Track competitor accounts across networks with one API key. Each platform is an independent lookup: a missing YouTube channel does not fail Instagram. Same handle is not the same person — treat each row as a candidate until you link them.
**You'll need** an [API key](https://app.socialfetch.dev/api-keys) and the [TypeScript SDK](/docs/sdk). Agents can explore with MCP `nl_ask_post`, then pin profile tools like `tiktok_profile_get`.
## Credit budget
Profile lookups are typically **1 credit** each when the request completes — including `not_found` and `private`. Four platforms × one competitor = **\~4 credits** per snapshot. Re-poll on your cadence; failed infrastructure (`lookup_failed`, `503`) is not charged.
Check [`GET /v1/balance`](/docs/api/v1/balance) before batching a large roster.
## Routes
| Platform | Route | SDK |
| --------------------------------- | ----------------------------------------------------------------------------------- | ----------------------------------------- |
| [TikTok](/platforms/tiktok) | [`GET /v1/tiktok/profiles/{handle}`](/docs/api/v1/tiktok/profiles/handle/get) | `client.tiktok.getProfile({ handle })` |
| [Instagram](/platforms/instagram) | [`GET /v1/instagram/profiles/{handle}`](/docs/api/v1/instagram/profiles/handle/get) | `client.instagram.getProfile({ handle })` |
| [YouTube](/platforms/youtube) | [`GET /v1/youtube/channel`](/docs/api/v1/youtube/channel/get) | `client.youtube.getChannel({ handle })` |
| [X/Twitter](/platforms/twitter) | [`GET /v1/twitter/profiles/{handle}`](/docs/api/v1/twitter/profiles/handle/get) | `client.twitter.getProfile({ handle })` |
Optional: [Facebook profile](/docs/api/v1/facebook/profiles/get) (URL or page id), [LinkedIn company](/docs/api/v1/linkedin/companies/get), [Threads profile](/docs/api/v1/threads/profiles/handle/get).
## Fan-out example
```ts
import { SocialFetchClient } from "@socialfetch/sdk";
const client = new SocialFetchClient({
apiKey: process.env.SOCIALFETCH_API_KEY!,
});
type PlatformRow = {
platform: string;
handle: string;
lookupStatus: string | undefined;
followers: number | null;
requestId: string;
creditsCharged: number;
};
async function trackCompetitor(handle: string): Promise {
const [tiktok, instagram, youtube, twitter] = await Promise.all([
client.tiktok.getProfile({ handle }),
client.instagram.getProfile({ handle }),
client.youtube.getChannel({ handle }),
client.twitter.getProfile({ handle }),
]);
const rows: PlatformRow[] = [];
for (const [platform, result] of [
["tiktok", tiktok],
["instagram", instagram],
["youtube", youtube],
["twitter", twitter],
] as const) {
if (!result.ok) {
console.error(platform, result.error.code, result.error.requestId);
continue;
}
const data = result.value.data as {
lookupStatus?: string;
metrics?: { followers?: number; subscribers?: number };
};
rows.push({
platform,
handle,
lookupStatus: data.lookupStatus,
followers: data.metrics?.followers ?? data.metrics?.subscribers ?? null,
requestId: result.value.meta.requestId,
creditsCharged: result.value.meta.creditsCharged,
});
}
return rows;
}
```
Always branch on `data.lookupStatus` when the route exposes it. HTTP `200` alone is not "found."
## What to store
Persist `capturedAt`, per-platform `lookupStatus`, follower/subscriber metrics, and `meta.requestId`. Diff follower counts across snapshots in your warehouse — the API does not compute deltas.
For identity linking when handles diverge (bio URLs, display-name checks): [Cross-platform creator profiles](/guides/cross-platform-creator-profiles).
## Related
* [Errors](/docs/errors) · [Credits](/docs/credits) · [SDK](/docs/sdk) · [MCP](/docs/integrations/mcp)
* Next recipe: [Creator engagement scoring](/docs/recipes/creator-engagement-scoring)
---
# Creator engagement scoring
Source: https://www.socialfetch.dev/docs/recipes/creator-engagement-scoring
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/recipes/creator-engagement-scoring](https://www.socialfetch.dev/docs/recipes/creator-engagement-scoring)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/recipes/creator-engagement-scoring.mdx](https://www.socialfetch.dev/docs/recipes/creator-engagement-scoring.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Creator engagement scoring (https://www.socialfetch.dev/docs/recipes/creator-engagement-scoring)
Social Fetch returns per-item metrics (views, likes, comments, followers). It does not ship a black-box "engagement score." Pull a profile, pull recent content, score in your warehouse with a formula you can explain to a client.
**You'll need** an [API key](https://app.socialfetch.dev/api-keys) and the [TypeScript SDK](/docs/sdk). Start from [Competitor profile tracking](/docs/recipes/competitor-profile-tracking) if you do not have handles yet.
## Credit budget
Profile get is typically **1 credit**. TikTok / Instagram / YouTube content pages are typically **1 credit** each. Twitter profile tweets are **2 credits** per page. Two content pages after a profile ≈ **3 credits** per creator on TikTok (1 + 1 + 1). Budget before scoring a large roster.
## Suggested pipeline
1. Resolve the profile (`lookupStatus` must be `found`).
2. Fetch one or two pages of recent posts/videos.
3. Compute median views (or likes) in your code.
4. Optionally normalize by follower count for cross-creator ranking.
| Platform | Profile | Recent content |
| --------------------------------- | ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| [TikTok](/platforms/tiktok) | [`getProfile`](/docs/api/v1/tiktok/profiles/handle/get) | [`getProfileVideos`](/docs/api/v1/tiktok/profiles/handle/videos/get) |
| [Instagram](/platforms/instagram) | [`getProfile`](/docs/api/v1/instagram/profiles/handle/get) | [`getProfilePosts`](/docs/api/v1/instagram/profiles/handle/posts/get) / [`getProfileReels`](/docs/api/v1/instagram/profiles/handle/reels/get) |
| [YouTube](/platforms/youtube) | [`getChannel`](/docs/api/v1/youtube/channel/get) | [`getChannelVideos`](/docs/api/v1/youtube/channels/videos/get) |
| [X/Twitter](/platforms/twitter) | [`getProfile`](/docs/api/v1/twitter/profiles/handle/get) | [`getProfileTweets`](/docs/api/v1/twitter/profiles/handle/tweets/get) (2 credits/page) |
Call the profile route before trusting an empty video/post list — some list routes omit `private` / `not_found` the way profile routes do. See the [capability matrix](/docs/capability-matrix).
## TikTok example
```ts
import { SocialFetchClient } from "@socialfetch/sdk";
const client = new SocialFetchClient({
apiKey: process.env.SOCIALFETCH_API_KEY!,
});
function median(nums: number[]): number {
if (nums.length === 0) return 0;
const sorted = [...nums].sort((a, b) => a - b);
return sorted[Math.floor(sorted.length / 2)] ?? 0;
}
async function scoreTikTokCreator(handle: string) {
const profile = await client.tiktok.getProfile({ handle });
if (!profile.ok) {
return { ok: false as const, error: profile.error };
}
if (profile.value.data.lookupStatus !== "found") {
return {
ok: true as const,
handle,
lookupStatus: profile.value.data.lookupStatus,
score: null,
};
}
const followers = profile.value.data.metrics?.followers ?? 0;
const videos = await client.tiktok.getProfileVideos({
handle,
sortBy: "latest",
});
if (!videos.ok) {
return { ok: false as const, error: videos.error };
}
const views = (videos.value.data.videos ?? [])
.map((v) => v.metrics?.views ?? 0)
.filter((n) => n > 0);
const medianViews = median(views);
const engagementRate =
followers > 0 ? medianViews / followers : null;
return {
ok: true as const,
handle,
lookupStatus: "found" as const,
followers,
sampleSize: views.length,
medianViews,
engagementRate,
creditsCharged:
profile.value.meta.creditsCharged + videos.value.meta.creditsCharged,
requestIds: [
profile.value.meta.requestId,
videos.value.meta.requestId,
],
};
}
```
Pick your own formula. Median views beats average when one viral clip skews the feed. Document the rule in code — clients will ask.
## Discovery seed
When the roster is empty, seed with [`GET /v1/tiktok/users/search`](/docs/api/v1/tiktok/users/search/get) (`client.tiktok.searchUsers`) or [Instagram profile search](/docs/api/v1/instagram/search/profiles/get), then run the scoring pass.
Longer identity + engagement walkthrough: [Cross-platform creator profiles](/guides/cross-platform-creator-profiles).
## Related
* [Credits](/docs/credits) · [SDK](/docs/sdk) · [MCP](/docs/integrations/mcp) · [Capability matrix](/docs/capability-matrix)
---
# Facebook Ad Library aggregation
Source: https://www.socialfetch.dev/docs/recipes/facebook-ad-library
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/recipes/facebook-ad-library](https://www.socialfetch.dev/docs/recipes/facebook-ad-library)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/recipes/facebook-ad-library.mdx](https://www.socialfetch.dev/docs/recipes/facebook-ad-library.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Facebook Ad Library aggregation (https://www.socialfetch.dev/docs/recipes/facebook-ad-library)
Pull public Meta Ad Library creatives for competitive research. Two complementary paths: keyword search across the library, and company/page ad lists when you already know the advertiser.
**You'll need** an [API key](https://app.socialfetch.dev/api-keys) and the [TypeScript SDK](/docs/sdk). Platform overview: [Facebook](/platforms/facebook).
## Credit budget
Facebook Ad Library search, company lists, company search, and single-ad get are **1 credit** per successful request (per page when paginating). Empty pages still bill when the lookup completes. Trust `meta.creditsCharged`.
## Routes
| Goal | Route | SDK |
| -------------------- | ------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
| Keyword search | [`GET /v1/facebook/ad-library/ads/search`](/docs/api/v1/facebook/ad-library/ads/search/get) | `client.facebook.searchAdLibraryAds({ query, … })` |
| Find advertisers | [`GET /v1/facebook/ad-library/companies/search`](/docs/api/v1/facebook/ad-library/companies/search/get) | `client.facebook.searchAdLibraryCompanies({ query })` |
| List a company's ads | [`GET /v1/facebook/ad-library/companies/ads`](/docs/api/v1/facebook/ad-library/companies/ads/get) | `client.facebook.listCompanyAds({ pageId?, companyName?, … })` |
| One ad by URL/id | [`GET /v1/facebook/ad-library/ads`](/docs/api/v1/facebook/ad-library/ads/get) | `client.facebook.getAdLibraryAd({ url?, adId?, … })` |
Useful filters on search / company lists: `country`, `status` (`active` / `inactive` / `all`), `mediaType`, `sortBy` (`impressions` / `most-recent`), `startDate` / `endDate`, `cursor`.
## Keyword search
```ts
import { SocialFetchClient } from "@socialfetch/sdk";
const client = new SocialFetchClient({
apiKey: process.env.SOCIALFETCH_API_KEY!,
});
const page = await client.facebook.searchAdLibraryAds({
query: "running shoes",
country: "US",
status: "active",
mediaType: "video",
sortBy: "most-recent",
});
if (!page.ok) {
console.error(page.error.code, page.error.requestId);
return;
}
for (const ad of page.value.data.ads ?? []) {
console.log(ad);
}
console.log(page.value.meta.creditsCharged, page.value.data.page);
```
## Resolve advertiser, then list ads
```ts
const companies = await client.facebook.searchAdLibraryCompanies({
query: "Acme Coffee",
});
if (!companies.ok) {
console.error(companies.error.code, companies.error.requestId);
return;
}
const first = companies.value.data.companies?.[0];
if (!first?.pageId) return;
const ads = await client.facebook.listCompanyAds({
pageId: first.pageId,
status: "active",
sortBy: "impressions",
});
if (!ads.ok) {
console.error(ads.error.code, ads.error.requestId);
return;
}
console.log(ads.value.data.lookupStatus, ads.value.data.ads?.length);
```
If you already know the advertiser name, skip company search and call `listCompanyAds({ companyName: "Acme Coffee", status: "active" })` directly.
Paginate with `data.page.nextCursor` while `hasMore` is true. Keep the same filters on every page.
## Optional: other ad libraries
Same product idea, different networks:
* [TikTok Ad Library search](/docs/api/v1/tiktok/ad-library/ads/search/get)
* [LinkedIn Ad Library search](/docs/api/v1/linkedin/ad-library/ads/search/get)
* [Google Ad Library](/docs/api/v1/google/ad-library/companies/ads/get) (company ads are priced higher — see that operation page)
## Related
* [Facebook API](/docs/api/v1/facebook) · [Credits](/docs/credits) · [SDK](/docs/sdk) · [MCP](/docs/integrations/mcp)
---
# Reddit research / listening pulse
Source: https://www.socialfetch.dev/docs/recipes/reddit-research
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/recipes/reddit-research](https://www.socialfetch.dev/docs/recipes/reddit-research)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/recipes/reddit-research.mdx](https://www.socialfetch.dev/docs/recipes/reddit-research.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Reddit research / listening pulse (https://www.socialfetch.dev/docs/recipes/reddit-research)
Use Reddit for switching stories, competitor mentions, and early complaint signal. Start with a global keyword sweep, narrow to the communities that matter, then pull comments on high-signal threads.
**You'll need** an [API key](https://app.socialfetch.dev/api-keys) and the [TypeScript SDK](/docs/sdk). Platform hub: [Reddit](/platforms/reddit).
## Credit budget
Global search, subreddit search, subreddit post lists, and comment pages are **1 credit** per successful page. A sprint with 12 query variants × 2 pages + 20 comment pulls is roughly **44 credits** before dedupe. Empty completed searches still bill.
Subreddit names are **case-sensitive** (`r/SaaS` ≠ `r/saas`). Pass the casing from the URL.
## Routes
| Goal | Route | SDK |
| ------------------------- | --------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
| Global posts | [`GET /v1/reddit/search`](/docs/api/v1/reddit/search/get) | `client.reddit.search({ query, sortBy?, timeframe?, cursor? })` |
| Subreddit metadata | [`GET /v1/reddit/subreddits`](/docs/api/v1/reddit/subreddits/get) | `client.reddit.getSubreddit({ subreddit })` |
| Subreddit feed | [`GET /v1/reddit/subreddits/{subreddit}/posts`](/docs/api/v1/reddit/subreddits/subreddit/posts/get) | `client.reddit.listSubredditPosts({ subreddit, sort?, timeframe? })` |
| Search inside a subreddit | [`GET /v1/reddit/subreddits/search`](/docs/api/v1/reddit/subreddits/search/get) | `client.reddit.searchSubreddit({ subreddit, query?, … })` |
| Comments | [`GET /v1/reddit/posts/comments`](/docs/api/v1/reddit/posts/comments/get) | `client.reddit.listPostComments({ url, cursor? })` |
## Listening pulse
```ts
import { SocialFetchClient } from "@socialfetch/sdk";
const client = new SocialFetchClient({
apiKey: process.env.SOCIALFETCH_API_KEY!,
});
const QUERIES = [
"acme alternative",
"switching from acme",
"acme too expensive",
];
const SUBREDDITS = ["SaaS", "startups", "ProductManagement"];
async function redditPulse() {
const hits = [];
for (const query of QUERIES) {
const global = await client.reddit.search({
query,
sortBy: "new",
timeframe: "week",
});
if (!global.ok) {
console.error(global.error.code, global.error.requestId);
continue;
}
hits.push({
scope: "global" as const,
query,
posts: global.value.data.posts ?? [],
creditsCharged: global.value.meta.creditsCharged,
requestId: global.value.meta.requestId,
});
}
for (const subreddit of SUBREDDITS) {
const scoped = await client.reddit.searchSubreddit({
subreddit,
query: "acme",
sort: "new",
timeframe: "week",
});
if (!scoped.ok) {
console.error(scoped.error.code, scoped.error.requestId);
continue;
}
hits.push({
scope: "subreddit" as const,
subreddit,
query: "acme",
posts: scoped.value.data.posts ?? [],
creditsCharged: scoped.value.meta.creditsCharged,
requestId: scoped.value.meta.requestId,
});
}
return hits;
}
```
## Pull comments on top threads
```ts
async function enrichWithComments(postUrl: string) {
const comments = await client.reddit.listPostComments({
url: postUrl,
});
if (!comments.ok) {
return { ok: false as const, error: comments.error };
}
return {
ok: true as const,
lookupStatus: comments.value.data.lookupStatus,
comments: comments.value.data.comments ?? [],
creditsCharged: comments.value.meta.creditsCharged,
requestId: comments.value.meta.requestId,
};
}
```
Dedupe by post id across query variants. Store `capturedAt` — Reddit ranking moves; each poll is a snapshot.
For brand monitors that also cover TikTok / X / YouTube, pair this recipe with [Brand monitoring](/docs/recipes/brand-monitoring). Full research sprint: [Reddit product research](/guides/reddit-product-research).
## Agents
MCP: connect [MCP](/docs/integrations/mcp), then call Reddit tools by name or discover with `nl_ask_post` (`"Search Reddit for switching from Notion"`). Prefer typed tools once routed.
## Related
* [Reddit hub](/platforms/reddit) · [Reddit API](/docs/api/v1/reddit) · [Credits](/docs/credits) · [SDK](/docs/sdk)
* [How to get a Reddit API key](/guides/how-to-get-a-reddit-api-key) · [Reddit API pricing](/blog/reddit-api-pricing) · [Best Reddit Data APIs](/blog/best-reddit-data-apis-2026)
* [Free Reddit research tool](/tools/reddit-research) · [Does Reddit have an API?](/glossary/does-reddit-have-an-api) · [Ask](/docs/api/v1/ask/post)
---
# Video transcription pipeline
Source: https://www.socialfetch.dev/docs/recipes/video-transcription
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/recipes/video-transcription](https://www.socialfetch.dev/docs/recipes/video-transcription)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/recipes/video-transcription.mdx](https://www.socialfetch.dev/docs/recipes/video-transcription.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# Video transcription pipeline (https://www.socialfetch.dev/docs/recipes/video-transcription)
Turn public video URLs into text you can store, search, or feed to an LLM. Three platforms, three routes, one auth header. Response shapes differ; normalize in your app.
**You'll need** an [API key](https://app.socialfetch.dev/api-keys) and the [TypeScript SDK](/docs/sdk). MCP tools map 1:1 to these routes after OAuth.
## Credit budget
YouTube and Instagram transcripts are typically **1 credit** per completed lookup. TikTok is **1 credit**, or **up to 11** when `useAiFallback=true` (base +10). Completed `not_found` attempts still bill. `lookup_failed` / `503` do not.
Pre-check with [`GET /v1/balance`](/docs/api/v1/balance) before large batches.
## Routes
| Platform | Route | SDK | Notes |
| --------------------------------- | ----------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | ---------------------------------------------------------------------- |
| [YouTube](/platforms/youtube) | [`GET /v1/youtube/videos/transcript`](/docs/api/v1/youtube/videos/transcript/get) | `client.youtube.getVideoTranscript({ url, language? })` | `segments` + `plainText`; video can be `found` with `transcript: null` |
| [TikTok](/platforms/tiktok) | [`GET /v1/tiktok/videos/transcript`](/docs/api/v1/tiktok/videos/transcript/get) | `client.tiktok.getVideoTranscript({ url, language?, useAiFallback? })` | WebVTT in `transcript.content` |
| [Instagram](/platforms/instagram) | [`GET /v1/instagram/posts/transcript`](/docs/api/v1/instagram/posts/transcript/get) | `client.instagram.getPostTranscript({ url })` | Plain text rows in `transcripts[]` |
Also available when you need them: [Twitter tweet transcript](/docs/api/v1/twitter/tweets/transcript/get) (video tweets, \~2 min max), [Facebook post transcript](/docs/api/v1/facebook/posts/transcript/get), [Reddit post transcript](/docs/api/v1/reddit/posts/transcript/get), [LinkedIn post transcript](/docs/api/v1/linkedin/posts/transcript/get).
## Worker sketch
```ts
import { SocialFetchClient } from "@socialfetch/sdk";
const client = new SocialFetchClient({
apiKey: process.env.SOCIALFETCH_API_KEY!,
});
type Platform = "youtube" | "tiktok" | "instagram";
function detectPlatform(url: string): Platform | null {
if (url.includes("youtube.com") || url.includes("youtu.be")) return "youtube";
if (url.includes("tiktok.com")) return "tiktok";
if (url.includes("instagram.com")) return "instagram";
return null;
}
async function transcribe(url: string, useAiFallback = false) {
const platform = detectPlatform(url);
if (!platform) throw new Error("unsupported_url");
const result =
platform === "youtube"
? await client.youtube.getVideoTranscript({ url })
: platform === "tiktok"
? await client.tiktok.getVideoTranscript({ url, useAiFallback })
: await client.instagram.getPostTranscript({ url });
if (!result.ok) {
return { ok: false as const, error: result.error };
}
const { data, meta } = result.value;
return {
ok: true as const,
platform,
lookupStatus: data.lookupStatus,
creditsCharged: meta.creditsCharged,
requestId: meta.requestId,
data,
};
}
```
Enable TikTok `useAiFallback` only when caption tracks are missing and you accept the surcharge. Do not flip it on for every URL by default.
## Normalize for RAG
Store plain text for embeddings. Keep timed segments / WebVTT if you need clip boundaries. Chunk with overlap and attach `url`, `platform`, and `language` as metadata.
Deep dive: [How to get YouTube, TikTok & Instagram transcripts](/guides/how-to-get-youtube-and-tiktok-transcripts).
## Related
* [Credits](/docs/credits) · [Errors](/docs/errors) · [SDK](/docs/sdk) · [MCP](/docs/integrations/mcp)
* [Ask](/docs/api/v1/ask/post) — useful when you have a URL but are unsure which transcript route to call
---
# TypeScript SDK
Source: https://www.socialfetch.dev/docs/sdk
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/sdk](https://www.socialfetch.dev/docs/sdk)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/sdk.mdx](https://www.socialfetch.dev/docs/sdk.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# TypeScript SDK (https://www.socialfetch.dev/docs/sdk)
## Install
## Requirements
* **Node.js** `18+`
* A Social Fetch API key (`sfk_...`) — [**API Keys**](https://app.socialfetch.dev/api-keys)
## Quick start
```ts
import { SocialFetchClient } from "@socialfetch/sdk";
const client = new SocialFetchClient({
apiKey: process.env.SOCIALFETCH_API_KEY!,
});
const result = await client.tiktok.getProfile({ handle: "charlidamelio" });
if (!result.ok) {
console.error(result.error.code, result.error.requestId);
return;
}
console.log(result.value.data.profile);
```
## Client configuration
Most integrations only need `apiKey`:
* **`apiKey`** — required, sent as the `x-api-key` header
```ts
import { SocialFetchClient } from "@socialfetch/sdk";
const client = new SocialFetchClient({
apiKey: process.env.SOCIALFETCH_API_KEY!,
});
```
Advanced options like `baseUrl` and `fetch` exist for tests and custom environments, but most integrations only need `apiKey`.
## Result handling
SDK methods return a `Result` instead of throwing for expected API failures:
```ts
type Result =
| { ok: true; value: T }
| { ok: false; error: E };
```
That means your normal flow can branch on `result.ok`:
```ts
const result = await client.tiktok.getProfile({ handle: "charlidamelio" });
if (!result.ok) {
console.error(result.error.code, result.error.requestId);
} else {
console.log(result.value.data.profile);
}
```
## `unwrap()` and thrown failures
If you prefer exception-style control flow, import `unwrap()`:
```ts
import { SocialFetchClient, SocialFetchUnwrapError, unwrap } from "@socialfetch/sdk";
const client = new SocialFetchClient({
apiKey: process.env.SOCIALFETCH_API_KEY!,
});
try {
const tweets = unwrap(
await client.twitter.getProfileTweets({ handle: "elonmusk" })
);
console.log(tweets.data.tweets);
} catch (error) {
if (error instanceof SocialFetchUnwrapError) {
console.error(error.error.code, error.error.requestId);
} else {
throw error;
}
}
```
`unwrap()` returns `result.value` on success and throws `SocialFetchUnwrapError` on SDK/API failures.
## Error handling
The SDK uses `SocialFetchSdkError`, which has two categories:
* **`kind: "api"`** — normalized public API errors such as `unauthorized`, `insufficient_credits`, or `temporarily_unavailable`
* **`kind: "client"`** — local/runtime failures such as `network_error`, `parse_error`, or `invalid_response`
You can also import:
* **`PUBLIC_API_ERROR_CODES`**
* **`isSocialFetchSdkError()`**
The SDK keeps the same API semantics. A route can return HTTP `200` and still resolve to `not_found` or `private`, so check fields like `lookupStatus` when the route provides them.
## After `result.ok`
Handle SDK/API errors first, then inspect `result.value.data`:
```ts
import { SocialFetchClient } from "@socialfetch/sdk";
const client = new SocialFetchClient({
apiKey: process.env.SOCIALFETCH_API_KEY!,
});
const profile = await client.instagram.getProfile({ handle: "instagram" });
if (!profile.ok) {
// 401, 402, 503, parse errors, etc.
console.error(profile.error.code, profile.error.requestId);
return;
}
switch (profile.value.data.lookupStatus) {
case "found":
// use profile.value.data.profile / metrics
break;
case "private":
case "not_found":
// still HTTP 200 from the API — handle without treating as SDK failure
break;
}
```
Some list routes omit `lookupStatus` and can return empty arrays for more than one reason. See [Errors](/docs/errors).
## Recommended workflow
1. Start with [Quickstart](/docs/quickstart) for environment setup, your first request, and the response-envelope basics.
2. Use this page for `Result` handling and `unwrap()`.
3. Use the [API reference](/docs/api) for exact params and schemas.
4. Use [Errors](/docs/errors) and [Credits](/docs/credits) for runtime behavior.
- [Quickstart](/docs/quickstart) — Authenticate, make a first platform request, and choose between raw HTTP and SDK paths.
- [API reference](/docs/api) — See the exact routes, parameters, and response schemas behind SDK methods.
- [Errors](/docs/errors) — HTTP error handling, outcome semantics, and retry guidance still apply to SDK users.
- [npm package](https://www.npmjs.com/package/@socialfetch/sdk) — Published package metadata and install source on npm.
---
# SDK reference
Source: https://www.socialfetch.dev/docs/sdk-reference
> **For coding agents and LLMs:** This is one page from the Social Fetch docs (markdown export). For curated orientation and workflow guidance, start with [`/llms.txt`](https://www.socialfetch.dev/llms.txt); for agent onboarding and crawl rules, use [`/agents.txt`](https://www.socialfetch.dev/agents.txt); for the full endpoint list with links to pages like this one, use [`/llms-endpoints.txt`](https://www.socialfetch.dev/llms-endpoints.txt); for one platform's parameters and curls, use [`/llms-{platform}.txt`](https://www.socialfetch.dev/llms-tiktok.txt); use [`/llms.json`](https://www.socialfetch.dev/llms.json) when you need structured JSON for tool registration.
## This page
- **On-site (HTML):** [https://www.socialfetch.dev/docs/sdk-reference](https://www.socialfetch.dev/docs/sdk-reference)
- **Markdown (.mdx) URL:** [https://www.socialfetch.dev/docs/sdk-reference.mdx](https://www.socialfetch.dev/docs/sdk-reference.mdx)
## API base URL and authentication
- **API origin (from OpenAPI `servers`):** `https://api.socialfetch.dev`
- **Authentication:** send `x-api-key: sfk_...` on `/v1/**` routes unless the operation is explicitly anonymous (check OpenAPI `security`, the [API reference hub](https://www.socialfetch.dev/docs/api.mdx), [`/llms.txt`](https://www.socialfetch.dev/llms.txt), or [`/llms.json`](https://www.socialfetch.dev/llms.json) for each route).
- **OpenAPI JSON:** [https://www.socialfetch.dev/openapi.json](https://www.socialfetch.dev/openapi.json)
---
# SDK reference (https://www.socialfetch.dev/docs/sdk-reference)
## SDK inventory
The current `SocialFetchClient` exposes five resource namespaces plus one top-level utility:
| Surface | Methods | Wrapped routes |
| ----------- | -------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| *(client)* | `health()` | `GET /health` |
| `auth` | `whoami()` | `GET /v1/whoami` |
| `billing` | `getBalance()` | `GET /v1/balance` |
| `tiktok` | `getProfile()`, `getProfileLive()`, `getProfileVideos()`, `getVideo()`, `getVideoComments()`, `getVideoTranscript()` | `GET /v1/tiktok/profiles/{handle}`, `GET /v1/tiktok/profiles/{handle}/live`, `GET /v1/tiktok/profiles/{handle}/videos`, `GET /v1/tiktok/videos`, `GET /v1/tiktok/videos/comments`, `GET /v1/tiktok/videos/transcript` |
| `twitter` | `getProfile()`, `getProfileTweets()`, `getTweet()` | `GET /v1/twitter/profiles/{handle}`, `GET /v1/twitter/profiles/{handle}/tweets`, `GET /v1/twitter/tweets` |
| `instagram` | `getProfile()`, `getProfilePosts()`, `getPost()` | `GET /v1/instagram/profiles/{handle}`, `GET /v1/instagram/profiles/{handle}/posts`, `GET /v1/instagram/posts` |
## Method-by-method reference
```ts
client.health()
client.auth.whoami()
client.billing.getBalance()
client.tiktok.getProfile({ handle })
client.tiktok.getProfileLive({ handle })
client.tiktok.getProfileVideos({ handle, sortBy?, cursor?, userId?, region?, trim? })
client.tiktok.getVideo({ url, region?, trim?, downloadMedia? })
client.tiktok.getVideoComments({ url, cursor?, trim? })
client.tiktok.getVideoTranscript({ url, language?, useAiFallback? })
client.twitter.getProfile({ handle })
client.twitter.getProfileTweets({ handle, limit?, cursor?, includeReplies?, includePinned? })
client.twitter.getTweet({ url, trim? })
client.instagram.getProfile({ handle })
client.instagram.getProfilePosts({ handle, cursor? })
client.instagram.getPost({ url, region?, trim?, downloadMedia? })
```
## Route mapping
| SDK method | HTTP route | Main identifiers / params |
| ----------------------------------------------------------------------------------------------- | ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| `client.health()` | `GET /health` | none |
| `client.auth.whoami()` | `GET /v1/whoami` | none |
| `client.billing.getBalance()` | `GET /v1/balance` | none |
| `client.tiktok.getProfile({ handle })` | `GET /v1/tiktok/profiles/{handle}` | `handle` |
| `client.tiktok.getProfileLive({ handle })` | `GET /v1/tiktok/profiles/{handle}/live` | `handle` |
| `client.tiktok.getProfileVideos({ handle, sortBy?, cursor?, userId?, region?, trim? })` | `GET /v1/tiktok/profiles/{handle}/videos` | `handle`, `sortBy`, `cursor`, `userId`, `region`, `trim` |
| `client.tiktok.getVideo({ url, region?, trim?, downloadMedia? })` | `GET /v1/tiktok/videos` | `url`, `region`, `trim`, `downloadMedia` |
| `client.tiktok.getVideoComments({ url, cursor?, trim? })` | `GET /v1/tiktok/videos/comments` | `url`, `cursor`, `trim` |
| `client.tiktok.getVideoTranscript({ url, language?, useAiFallback? })` | `GET /v1/tiktok/videos/transcript` | `url`, `language`, `useAiFallback` |
| `client.twitter.getProfile({ handle })` | `GET /v1/twitter/profiles/{handle}` | `handle` |
| `client.twitter.getProfileTweets({ handle, limit?, cursor?, includeReplies?, includePinned? })` | `GET /v1/twitter/profiles/{handle}/tweets` | `handle`, `limit`, `cursor`, `includeReplies`, `includePinned` |
| `client.twitter.getTweet({ url, trim? })` | `GET /v1/twitter/tweets` | `url`, `trim` |
| `client.instagram.getProfile({ handle })` | `GET /v1/instagram/profiles/{handle}` | `handle` |
| `client.instagram.getProfilePosts({ handle, cursor? })` | `GET /v1/instagram/profiles/{handle}/posts` | `handle`, `cursor` |
| `client.instagram.getPost({ url, region?, trim?, downloadMedia? })` | `GET /v1/instagram/posts` | `url`, `region`, `trim`, `downloadMedia`. Outcomes: `data.lookupStatus` is `found`, `not_found`, or `restricted`. |
---
# What is Social Fetch?
Source: https://www.socialfetch.dev/
## Social Fetch overview
**Social Fetch** is a **versioned public REST API** (base path `/v1`) that returns **normalized public social data** — profiles, posts, media, comments, engagement, transcripts, and more — from supported platforms, using a **single API key** (`x-api-key: sfk_...`) and a **predictable JSON envelope**.
- **Docs home:** https://www.socialfetch.dev/docs
- **Quickstart:** https://www.socialfetch.dev/docs/quickstart
- **API reference:** https://www.socialfetch.dev/docs/api
- **OpenAPI JSON:** https://www.socialfetch.dev/openapi.json
- **TypeScript SDK guide:** https://www.socialfetch.dev/docs/sdk
- **Marketing home:** https://www.socialfetch.dev/
Use the [capability matrix](https://www.socialfetch.dev/docs/capability-matrix) to compare routes, pagination, and outcomes per platform.
---
# Plans and pricing
Source: https://www.socialfetch.dev/pricing
## Plans and pricing
- **Free tier:** 100 free credits on signup (no card required).
- **Subscriptions (recommended for steady volume):** Starter, Growth, and Scale include credits each monthly period. Auto-refill (on by default) buys prepaid tier refill packs when spendable balance runs low. Exact monthly, annual, and refill prices are in Stripe — open [Pricing](https://www.socialfetch.dev/pricing) or call `get_pricing` for live amounts in your currency.
- **Pay as you go:** one-time credit packs when you want prepaid capacity without a recurring plan — **PAYG credits never expire**.
- **Credit expiry:** subscription included credits reset each period and do not roll over; PAYG pack and refill credits never expire (see [FAQ](/product/faq)).
### Subscription tiers (credit amounts)
- **Starter**: 15,000 included credits/period · 1,000 refill pack · 2,000 grace buffer
- **Growth**: 50,000 included credits/period · 10,000 refill pack · 5,000 grace buffer
- **Scale**: 150,000 included credits/period · 15,000 refill pack · 10,000 grace buffer
### Pay-as-you-go packs (sizes)
- **Starter** (`credits_starter`): 1,000 credits
- **Growth** (`credits_growth`): 25,000 credits
- **Scale** (`credits_scale`): 230,000 credits
### Volume / enterprise
For **1M+ credits**, invoicing, SLAs, and custom terms, use [Contact](https://www.socialfetch.dev/contact).
### More detail
- [Credits & billing](https://www.socialfetch.dev/docs/credits) — metering, subscriptions, auto-refill, grace buffer, `402`, and `meta.creditsCharged`.
- [Subscriptions product note](/product/subscriptions) — concise billing behavior for Ask AI.
---
# Subscriptions, auto-refill, and grace buffer
Source: https://www.socialfetch.dev/pricing
## Subscriptions and auto-refill
**Starter**, **Growth**, and **Scale** subscriptions include credits each monthly period for teams with steadier volume. **Pay-as-you-go credit packs** remain available anytime — they never expire.
### Tier allowances (from catalog)
- **Starter**: 15,000 included credits/period · 1,000 refill pack · 2,000 grace buffer
- **Growth**: 50,000 included credits/period · 10,000 refill pack · 5,000 grace buffer
- **Scale**: 150,000 included credits/period · 15,000 refill pack · 10,000 grace buffer
### How usage is charged
1. **Included subscription credits** for the current monthly period
2. **Pay-as-you-go balance** (pack purchases, free signup credits, prior refill packs)
3. **Prepaid tier refill packs** — auto-purchased when spendable balance drops to **100 credits or below** (default subscriber trigger; not metered usage). Proactive grace bridges the async payment window.
**Auto-refill** is on by default at subscribe checkout. **Pay-as-you-go auto top-up** is on by default after your first credit pack purchase (same pack size, default trigger 100 credits). Refill credits land in your PAYG bucket and **do not expire**. Toggle auto-refill off or set an optional **per-period spend cap** in billing.
### Grace buffer when a refill charge fails
If an auto-refill charge fails, a **one-time grace buffer** keeps requests running while you fix payment. Grace equals each tier's buffer above. When the next refill succeeds, grace is recouped from that pack.
### Included credits reset
Included credits **reset at the start of each monthly period** (even on annual base plans). Unused included credits do not roll over. Canceling a subscription never forfeits PAYG or refill credits.
### Live prices
Open [Pricing](https://www.socialfetch.dev/pricing) or use `get_pricing` for current Stripe amounts (monthly, annual, refill packs) in your currency.
Full behavior: [Credits docs](https://www.socialfetch.dev/docs/credits). Manage your plan in the app [Billing](https://www.socialfetch.dev/billing).
---
# Supported platforms (public API)
Source: https://www.socialfetch.dev/docs/capability-matrix
## Supported platforms in the public API
For **which routes exist today**, use the **documented API surface** (see [capability matrix](https://www.socialfetch.dev/docs/capability-matrix) and [API reference](https://www.socialfetch.dev/docs/api)).
**Platform families in the public API documentation:** **TikTok**, **Facebook**, **Google**, **Instagram**, **Pinterest**, **LinkedIn**, **YouTube**, **X (Twitter)**, **Threads**, **Bluesky**, **Reddit**, **Rumble**, **Twitch**, **Telegram**, **Linktree**, **Hacker News**, **Truth Social**, **Spotify**, and **GitHub**, plus **Web** routes (`/v1/web/search`, `markdown`, `ask`, `html`, `crawl`) and shared **auth** (e.g. `whoami`, `balance`) and **system** (`health`) routes.
Marketing copy should match the [capability matrix](https://www.socialfetch.dev/docs/capability-matrix) and OpenAPI — treat those as the source of truth for available endpoints.
---
# Integrations (n8n, Apify, SDK, REST API)
Source: https://www.socialfetch.dev/integrations
## Social Fetch integrations
Social Fetch supports several ways to connect, depending on whether you want **no-code automation** or **direct API access**.
### n8n (no-code)
- Install the verified node **`n8n-nodes-socialfetch`** directly from n8n's nodes panel (under “More from the community”).
- Full setup, credentials, pagination, and examples: [n8n integration docs](https://www.socialfetch.dev/docs/integrations/n8n).
- Overview of all integration paths: [Integrations docs](https://www.socialfetch.dev/docs/integrations).
### Apify (Store Actors)
- Run Social Fetch as pay-per-event **Store Actors** under [@social-fetch](https://apify.com/social-fetch) — Apify token only, no `sfk_` key in input.
- Full setup, actor catalog, PPE pricing, and quick start: [Apify integration docs](https://www.socialfetch.dev/docs/integrations/apify).
### TypeScript SDK
- Typed client with `Result`-based errors: [SDK guide](https://www.socialfetch.dev/docs/sdk).
### REST API
- Every operation with params and examples: [API reference](https://www.socialfetch.dev/docs/api).
### Integrations hub
- Marketing overview: [Integrations](https://www.socialfetch.dev/integrations).
**Note:** Questions about “integrations” may mean **platform connectors** (TikTok, Instagram, …) or **product connectors** (n8n, Apify, SDK). For platform coverage, see [Supported platforms](https://www.socialfetch.dev/docs/capability-matrix); for n8n, Apify, and automation, use the links above.
---
# Social Fetch on RapidAPI Hub
Source: https://www.socialfetch.dev/compare/rapidapi
## Social Fetch on RapidAPI Hub
Social Fetch is available on **[RapidAPI Hub](https://rapidapi.com/)** as a marketplace listing — the same public API surface documented at [API reference](https://www.socialfetch.dev/docs/api) and [OpenAPI](https://www.socialfetch.dev/openapi.json).
### How it works
- **On socialfetch.dev:** authenticate with `x-api-key: sfk_...` (see [Quickstart](https://www.socialfetch.dev/docs/quickstart)).
- **On RapidAPI Hub:** authenticate with your **RapidAPI subscription key** on the RapidAPI gateway (configured in the Hub listing). Requests are forwarded to the same API origin.
- **Response shape:** `{ data, meta }` on success; `meta.requestId` and `meta.creditsCharged` for support and billing (see [Errors](https://www.socialfetch.dev/docs/errors) and [Credits](https://www.socialfetch.dev/docs/credits)).
### Pricing and platforms
- **Pay-as-you-go credits** on socialfetch.dev apply to direct API usage; compare [Pricing](https://www.socialfetch.dev/pricing) for pack sizes.
- **All documented platforms** (TikTok, Instagram, YouTube, X, LinkedIn, Facebook, Google, Reddit, Threads, Telegram, Linktree, Hacker News, Truth Social, Spotify, Web utilities) share one schema — see [Capability matrix](https://www.socialfetch.dev/docs/capability-matrix).
### Marketplace vs direct API
For a detailed comparison of RapidAPI marketplace tradeoffs (per-provider subscriptions, rate limits, multiple schemas) vs one Social Fetch API key, see [Social Fetch vs RapidAPI](https://www.socialfetch.dev/compare/rapidapi).
**Full docs:** [Documentation](https://www.socialfetch.dev/docs) · [Integrations](https://www.socialfetch.dev/integrations) (n8n, SDK).
---
# Credits, balance, and billing signals
Source: https://www.socialfetch.dev/docs/credits
## Credits
- New accounts receive **100 free credits** (see [pricing knowledge](/product/pricing)).
- Some routes are **metered**; see per-operation notes and `x-socialfetch-credits-pricing` in OpenAPI.
- Successful metered responses include **`meta.creditsCharged`** for what was billed.
- **Outcome billing:** `lookupStatus` values like **`not_found`**, **`private`**, and **`restricted`** on HTTP **200** still charge when we complete a lookup attempt (e.g. wrong handle). **`lookup_failed`** and **`503 temporarily_unavailable`** do not charge.
- **`GET /v1/whoami`** and **`GET /v1/balance`** are for connectivity/balance checks and are documented as **non-charging** for those purposes in [Credits](https://www.socialfetch.dev/docs/credits).
- Insufficient balance can return **HTTP 402** with a typed error (see [Errors](https://www.socialfetch.dev/docs/errors)).
---
# Get started: API key and first requests
Source: https://www.socialfetch.dev/docs/quickstart
## Get started
**Social Fetch** is a REST API for **normalized public social data**. Your **`sfk_...` API key** authenticates requests to `https://api.socialfetch.dev`.
1. **Create an account** and obtain an API key (`sfk_...`).
2. **Smoke test** with `GET /v1/whoami` (see [Quickstart](https://www.socialfetch.dev/docs/quickstart)).
3. Use the **dashboard playground** to explore: https://www.socialfetch.dev/playground
4. Read [Errors](https://www.socialfetch.dev/docs/errors) for the shared envelope, `requestId`, and outcome codes.
**Base URL (production):** `https://api.socialfetch.dev` (also in [docs home](https://www.socialfetch.dev/docs)).
---
# Use cases
Source: https://www.socialfetch.dev/
## Use cases
Teams use Social Fetch for **lookups, dashboards, monitoring, compliance/safety, and data pipelines** where you need **normalized public social data** without owning scrapers or one-off integrations per network.
Social Fetch is especially useful as the **social-data layer** behind products that enrich profiles, rank creators, monitor accounts, compare competitors, or score opportunities from public social signals.
Start from the [docs](https://www.socialfetch.dev/docs) and [capability matrix](https://www.socialfetch.dev/docs/capability-matrix) to match **your task** to a **concrete route**.
---
# Profile enrichment, valuation, and scoring workflows
Source: https://www.socialfetch.dev/
## Profile enrichment, valuation, and scoring workflows
Social Fetch is a **strong fit for the social-data retrieval layer** of profile enrichment, creator ranking, valuation, diligence, and scoring products.
Use Social Fetch to fetch **normalized public social data** such as profiles, posts, media, comments, transcripts, engagement, and public metrics across supported platforms through one API and TypeScript SDK.
For weighted metrics, influence scores, verification tokens, or valuation formulas, the best architecture is usually:
1. **Fetch social signals with Social Fetch** from the relevant platform endpoints.
2. **Normalize and store the returned fields** in your application database.
3. **Apply your own scoring, weighting, verification-token, or valuation model** in your product.
4. **Refresh scores on your schedule** by re-fetching live public data when needed.
That split is intentional and useful: Social Fetch handles the hard social-data access and normalization work, while your application owns the business-specific valuation logic.
Good fit examples include creator profile enrichment, influencer/creator ranking, account diligence, lead qualification from public social signals, portfolio monitoring, brand-safety review, and valuation dashboards.
Social Fetch does **not** provide a universal built-in valuation score or verification-token system as a managed product feature. It provides the source data foundation those systems can be built on.
Start with the [API reference](https://www.socialfetch.dev/docs/api), try relevant endpoints in the dashboard playground (https://www.socialfetch.dev/playground), or use [Contact](https://www.socialfetch.dev/contact) for high-volume or custom workflow questions.
---
# Performance, uptime, and live data
Source: https://www.socialfetch.dev/
## Reliability and freshness
**Public product claims** (see also [FAQ](/product/faq)):
- **Live data:** requests fetch **publicly available data at request time**, not a long-lived stale cache of social graphs.
- **~3.16s average response time** (user-visible FAQ copy).
- **~99.8% uptime** over the last 90 days on the public API (per FAQ).
- **No enforced rate limits or RPS caps** on paid metered routes (per FAQ) — recommend below ~500 concurrent requests; practical limit is credit balance. Occasional **`503 temporarily_unavailable`** — safe to retry.
- Every response includes a **`requestId`** for support (see [Errors](https://www.socialfetch.dev/docs/errors)).
---
# Compliance, privacy, and security
Source: https://www.socialfetch.dev/security
## Compliance, privacy, and security
Social Fetch returns **publicly available** data. You are responsible for **how you use it** under your contracts, **platform terms**, and **applicable law**.
### Operator
- **Social Freak Ltd** (UK company no. 14659411) operates Social Fetch.
### Certifications
- Social Fetch does **not** hold **SOC 2** or **ISO 27001** certification.
- This is not a third-party GDPR certification programme; we support UK/EU GDPR rights as described in our policies.
### Data handling (summary)
- **API logs:** We retain operational API logs for approximately 30 days, including request metadata and response previews, for support, billing, and reliability, then delete them.
- **Payments:** Stripe processes card payments.
- **Subprocessors:** public docs use **generic categories** (hosting, email, analytics). A **detailed list is available on request** for legitimate security reviews.
### Security practices (summary)
- TLS in transit; optional **2FA** on accounts; API keys (`sfk_...`); secure secrets configuration.
### Links
- [Security overview](https://www.socialfetch.dev/security)
- [Privacy Policy](https://www.socialfetch.dev/privacy)
- [Terms of Service](https://www.socialfetch.dev/terms)
For **policy and security questions:** `support@socialfetch.dev`.
For **sales and enterprise diligence**, use [Contact](https://www.socialfetch.dev/contact).
---
# Support, contact, and account help
Source: https://www.socialfetch.dev/contact
## Support and contact
- **Product issues / bug reports:** `support@socialfetch.dev` (include the **`requestId`** from API responses).
- **Sales, enterprise, and partnerships:** [Contact](https://www.socialfetch.dev/contact).
For **account-specific billing questions** (charges, invoices, card failures), use **support** or your **dashboard billing** — the assistant can only provide **public** information.
---
# Frequently asked questions (marketing)
Source: https://www.socialfetch.dev/
## Frequently asked questions
### Do I need a credit card to get started?
No credit card required. Sign up and receive 100 free credits instantly—start making real API calls in minutes with no payment information needed.
### Do credits expire?
Pay-as-you-go pack credits never expire — buy once and use them on your schedule. Subscription included credits reset each monthly period; unused included credits do not roll over. Refill-pack credits land in your PAYG balance and never expire.
### Do I need a subscription?
No — pay-as-you-go credit packs work without a recurring plan. Starter, Growth, and Scale subscriptions are available when you want included credits each month at a lower effective rate; cancel anytime from billing with no penalty.
### Do not_found lookups cost credits?
Yes. Credits are charged when we complete a lookup attempt, whether the target exists or not — a wrong username that returns lookupStatus: not_found still ran a real lookup. lookup_failed and 503 temporarily_unavailable are not charged.
### Are there rate limits?
No enforced rate limits or RPS caps on paid metered routes—your limit is credit balance. Stay below ~500 concurrent requests for best reliability. whoami and balance have per-key limits. Retry 503 temporarily_unavailable with backoff.
### Do you offer team or workspace accounts?
Not today. Each account has one billing owner. Teams often share an API key with their own internal controls, or contact us for enterprise arrangements.
### What is the average response time?
Around 3.2 seconds on average. Because Social Fetch fetches live data from each platform on every request (no caching), responses take a little longer than a static API — and in return you always get fresh data, not yesterday's snapshot.
### Is the data real-time?
Yes. Every request fetches the latest publicly available data from the platform at request time — typically in around 3.2 seconds — so your product always reflects what's live instead of a stale cache.
### What's your uptime?
We currently run at 99.8% uptime measured across the public API over the last 90 days. If you ever hit an issue, every response includes a request ID you can send to support@socialfetch.dev.
### Which platforms are supported?
TikTok, Facebook, Instagram, Pinterest, LinkedIn, YouTube, X (Twitter), Threads, Bluesky, Reddit, Rumble, Twitch, Telegram, Spotify, GitHub, Google Ad Library, and Web routes for generic URL tasks. See the capability matrix for the full route list.
### Can we use this in production?
Yes. The API is designed for production SaaS: predictable JSON shapes, versioned routes, and operational focus so your team ships features instead of maintaining scrapers.
### Can Social Fetch support profile enrichment, valuation, or scoring workflows?
Yes. Social Fetch is a strong fit for the social-data layer: fetch normalized public profiles, posts, metrics, comments, transcripts, and engagement signals, then apply your own weighting, scoring, verification, or valuation logic in your app.
### What about compliance?
Social Fetch returns publicly available data. You are responsible for how you use it under your contracts, platform terms, and applicable law. We are operated by Social Freak Ltd (UK). See our Security and Privacy pages for data handling, retention, and GDPR rights.
### Are you SOC 2 or ISO 27001 certified?
No. We do not hold SOC 2 or ISO 27001 certification. See our Security page for our current practices (TLS, optional 2FA, approximately 30-day API logs). For enterprise security questionnaires, email support@socialfetch.dev.
### Do you support GDPR?
We are designed to support UK and EU GDPR rights — this is our privacy practice, not a third-party certification programme. See our Privacy page for legal bases, retention, and how to contact us. Email support@socialfetch.dev for data subject requests.
### Who are your subprocessors?
Public documentation describes generic categories (hosting, payments, email, analytics). Stripe processes payments. A detailed subprocessor list is available on request for legitimate security reviews — email support@socialfetch.dev.
---
# Subscription billing: auto-refill, grace, and spend cap
Source: https://www.socialfetch.dev/docs/credits
## Subscription billing FAQs
### What happens when included credits run out?
Active subscribers with **auto-refill on** (default) keep calling the API. Usage draws from PAYG balance first, then auto-purchases your tier's **prepaid refill pack**. Turn auto-refill off in billing for a hard stop at zero.
### Grace buffer vs base renewal failure
- **Refill charge failed:** one-time grace buffer (Starter 2,000 · Growth 5,000 · Scale 10,000 credits) keeps requests running until payment is fixed or grace is exhausted.
- **Base subscription renewal failed:** separate dunning path — update payment in billing; see [Credits docs](https://www.socialfetch.dev/docs/credits).
### Spend cap
Optional **per-period auto-refill spend cap** in billing. When reached, refill charges stop and metered routes return **`402 insufficient_credits`** until the next period or you raise the cap.
### Cancel or change plan
Cancel at period end from billing — included credits last until the period closes; PAYG balance is never forfeited. Upgrades apply immediately; downgrades schedule for the next period.
### Live prices
Use `get_pricing` or [Pricing](https://www.socialfetch.dev/pricing) for current Stripe amounts. Credit amounts per tier come from the product catalog — see [/product/subscriptions](/product/subscriptions).
---
# When do lookups charge credits?
Source: https://www.socialfetch.dev/docs/credits
## When metered lookups charge credits
Credits are charged when we **complete a lookup attempt**, whether the target exists or not — the API still resolves the request and returns a definitive outcome in the success envelope.
**Charges credits (HTTP 200, completed lookup attempt):**
- `lookupStatus: found`
- `lookupStatus: not_found` — e.g. wrong username/handle, unresolved target
- `lookupStatus: private` or `restricted` when the endpoint uses those outcomes
A wrong Instagram handle or mistyped URL that resolves to `not_found` is still a **completed lookup attempt** and bills like any other completed request on that route.
**Does not charge:**
- `lookup_failed` (HTTP 502) — the lookup could not be completed safely
- `503 temporarily_unavailable` — transient upstream pressure; retry
- `400 bad_request` — invalid request before work starts
- `402 insufficient_credits` — balance too low
Check `meta.creditsCharged` on every metered response. See [Credits](https://www.socialfetch.dev/docs/credits) and [Errors — credits and outcomes](https://www.socialfetch.dev/docs/errors#credits-and-outcomes).
---
# Throughput, concurrency, and retries
Source: https://www.socialfetch.dev/docs/credits
## Throughput and retries
**Paid metered `/v1/*` routes:** Social Fetch enforces **no API rate limits or requests-per-second caps**. Run parallel requests as your product needs — your practical limit is **credit balance**. For best performance and reliability, recommend staying below **~500 concurrent requests**.
**When something goes wrong upstream:** you may see HTTP **`503 temporarily_unavailable`**. This is transient — **retry immediately** or use gradual backoff. These responses are **not charged** on metered lookup routes.
**Free routes** (`GET /v1/whoami`, `GET /v1/balance`) have per-key rate limits and may return **`429`** — see [Errors](https://www.socialfetch.dev/docs/errors).
---
# Team and workspace accounts
Source: https://www.socialfetch.dev/docs/quickstart
## Team and workspace accounts
Social Fetch does **not** offer team, workspace, or organization accounts today. Each signup is a **single user** with their own billing and API keys.
**Common workarounds:**
- Share one API key within your team using your own access controls
- One billing owner purchases credits; developers use keys you issue
For enterprise billing, invoicing, or multi-seat arrangements, use [Contact](https://www.socialfetch.dev/contact).
---
# Facebook group post keyword filtering
Source: https://www.socialfetch.dev/docs/api/v1/facebook/groups/posts
## Facebook group keyword filtering
`GET /v1/facebook/groups/posts` does **not** support server-side keyword, text, or content filtering. Upstream does not expose a filter parameter.
**Workaround:** paginate with `cursor` / `data.page.nextCursor`, then filter each page client-side on fields like `text` (or equivalent post body fields in the response).
**Cost note:** each page is **1 credit** per successful request. Upstream returns a **small number of posts per page** (often around three). Large groups require many pages to scan fully.
For Facebook **search** endpoints that accept a query (e.g. Ad Library, Marketplace), use those routes instead — they are different products from group feed listing.
---
# Facebook profile vs group URL mistakes
Source: https://www.socialfetch.dev/docs/api/v1/facebook/groups/posts
## Facebook URL type mistakes
Use the endpoint that matches the URL type:
| Goal | Route | URL type |
| --- | --- | --- |
| Profile or page lookup | `GET /v1/facebook/profiles` | Profile or page URL (`facebook.com/username`, `/people/…`, etc.) |
| Group feed posts | `GET /v1/facebook/groups/posts` | **Group URL** (`facebook.com/groups/{id-or-slug}/…`) |
The **profile** endpoint rejects `/groups/` URLs with HTTP **400**.
The **group posts** endpoint requires a group URL. Passing a profile or page URL may return HTTP **200** with `lookupStatus: not_found` and **still charge credits** — this is a common pagination frustration.
Always pass a full group URL such as `https://www.facebook.com/groups/742354120555345/`.
---
# Platform support boundaries
Source: https://www.socialfetch.dev/docs/capability-matrix
## Platform support boundaries
For **which routes exist today**, use the [capability matrix](https://www.socialfetch.dev/docs/capability-matrix) and [API reference](https://www.socialfetch.dev/docs/api) — not marketing landing copy.
**Supported platform families in the public API:** TikTok, Facebook, **Google**, Instagram, Pinterest, LinkedIn, YouTube, X (Twitter), Threads, **Bluesky**, Reddit, **Rumble**, **Twitch**, Telegram, **Linktree**, **Hacker News**, **Truth Social**, Spotify, **GitHub**, plus **Web** utilities and shared auth/system routes.
**Bluesky** (examples): `GET /v1/bluesky/profiles/{handle}`, `GET /v1/bluesky/profiles/{handle}/posts`, `GET /v1/bluesky/posts`.
**Google** (Ad Transparency Library examples): `GET /v1/google/ad-library/companies/ads`, `GET /v1/google/ad-library/ads`, `GET /v1/google/ad-library/advertisers/search`. Only public ads are available.
**Pinterest** (examples): `GET /v1/pinterest/search`, `GET /v1/pinterest/pins`, `GET /v1/pinterest/profiles/{handle}/boards`, `GET /v1/pinterest/boards/pins`.
**Rumble** (examples): `GET /v1/rumble/search`, `GET /v1/rumble/channels/videos`, `GET /v1/rumble/videos`, `GET /v1/rumble/videos/comments`, `GET /v1/rumble/videos/transcript`.
**Twitch** (examples): `GET /v1/twitch/profiles/{handle}`, `GET /v1/twitch/profiles/{handle}/videos`, `GET /v1/twitch/profiles/{handle}/schedule`, `GET /v1/twitch/clips`.
**Web** (generic URL tasks, not social platforms): `GET /v1/web/search`, `GET /v1/web/markdown`, `GET /v1/web/ask`, `GET /v1/web/html`, `GET /v1/web/crawl`.
**Not supported:** **VK (VKontakte)** — not in the API and not on the public roadmap. Snapchat and other marketing-only names are not API platforms unless listed in the capability matrix.
---
# News sites vs social data vs Web routes
Source: https://www.socialfetch.dev/docs/capability-matrix
## News, web content, and social platforms
Social Fetch is primarily a **social platform API** (TikTok, Instagram, Facebook, etc.) with normalized JSON — **not** a dedicated news-publisher scraping product.
**For social content** (posts, profiles, comments on social networks): use the platform-specific routes in the [capability matrix](https://www.socialfetch.dev/docs/capability-matrix).
**For arbitrary web pages or search-like tasks:** use **Web** routes:
- `GET /v1/web/search` — search the web (similar to a search engine, not a news archive)
- `GET /v1/web/markdown` — fetch a page as Markdown
- `GET /v1/web/ask` — ask a question about a page URL
- `GET /v1/web/html` — fetch rendered HTML
- `GET /v1/web/crawl` — crawl up to several URLs in one request
These Web routes work on **URLs you already have**; they do not replace a full news-aggregator product.
---
# Facebook group posts sortBy options
Source: https://www.socialfetch.dev/docs/api/v1/facebook/groups/posts
## Facebook group `sortBy` values
`GET /v1/facebook/groups/posts` accepts optional `sortBy`:
| Value | Use when |
| --- | --- |
| `top` | Top posts by engagement |
| `recentActivity` | Sorted by recent activity |
| `chronological` | **Default choice** — standard time-ordered group feed |
| `chronologicalListings` | **Buy/Sell or marketplace groups** — listing/product posts in chronological order |
**Recommendation:** use `chronological` for general group monitoring. Use `chronologicalListings` only when the group is a marketplace/Buy-Sell community and you care about product listings.
Pagination uses `cursor` / `data.page.nextCursor`. Each page bills separately. Upstream returns a small number of posts per page.
---
# What Ask AI can and cannot do
Source: https://www.socialfetch.dev/docs/quickstart
## Ask AI boundaries
The on-site **Ask AI assistant** helps with Social Fetch **product, pricing, docs, API reference, SDK, and onboarding** — it is **not** a live API client.
**It does not:**
- Execute API lookups for pasted handles, usernames, or URLs in chat
- Return live social data for a specific account you name in the chat
- Provide geo or vertical business directories (e.g. "all dentists in Los Angeles")
**To fetch real data:** use the [playground](https://www.socialfetch.dev/playground) or call the public API with your API key. See [Quickstart](https://www.socialfetch.dev/docs/quickstart).
**Monitoring dashboards:** Social Fetch does not host a turnkey monitoring UI. Your application should **poll the API** on a schedule you control and store results in your own database or dashboard.
---
# Public metrics vs logged-in platform UI
Source: https://www.socialfetch.dev/docs/credits
## Public metrics vs logged-in UI
Social Fetch returns **public** data available without logging into the target platform. Counts for Facebook and Instagram (followers, likes, views, etc.) may **differ** from what you see when logged into that platform's app or website.
Common reasons:
- Logged-in views can include private or personalized metrics
- Platforms round, delay, or segment public vs authenticated counts
- The API normalizes fields from upstream public endpoints
**When something looks wrong:** log `meta.requestId` from the API response (or `error.requestId` on failures) and send it to [Contact](https://www.socialfetch.dev/contact) so support can trace the exact lookup.
See [Errors — request ID](https://www.socialfetch.dev/docs/errors#request-id).
---
# Product limitations: Stories, SOC2, valuation
Source: https://www.socialfetch.dev/docs/capability-matrix
## Known product limitations
**Instagram Stories:** Social Fetch does **not** offer ephemeral 24-hour Stories. **Highlight** routes are supported — see the [capability matrix](https://www.socialfetch.dev/docs/capability-matrix).
**SOC 2:** Social Fetch does **not** publish a SOC 2 Type II report or certification claim on the marketing site. For enterprise security questionnaires, use [Contact](https://www.socialfetch.dev/contact).
**Valuation / scoring products:** Social Fetch is a **data layer** — profiles, posts, metrics, and text you can feed into **your** models or rules. Credit scoring, fraud models, and final valuations are **your application's** responsibility.
---
# Public API error codes
Source: https://www.socialfetch.dev/docs/errors
## Public API error codes (`error.code`)
Authoritative list from the public API contract. Check [Errors](https://www.socialfetch.dev/docs/errors) and `meta.creditsCharged` / billing docs for route-specific charging.
| Code | Typical HTTP | Charged? | Next step |
| --- | --- | --- | --- |
| `bad_request` | 400 | No | Fix parameters, URL type, or validation before retrying. |
| `unauthorized` | 401 | No | Send a valid `x-api-key` (`sfk_...`). |
| `insufficient_credits` | 402 | No | Top up credits; see [Credits](https://www.socialfetch.dev/docs/credits). |
| `lookup_failed` | 502 | No on metered lookups | Transient upstream failure; retry with backoff. |
| `transcript_target_not_video` | 400 | No | Use a video URL on transcript routes. |
| `video_too_long_for_transcription` | 400 | No | Video exceeds transcript length limit; try a shorter clip. |
| `temporarily_unavailable` | 503 | No on metered lookups | Safe to retry immediately or with backoff. |
| `internal_error` | 500 | Varies | Retry once; contact support with `error.requestId` if it persists. |
Quote `error.requestId` (or `meta.requestId` on success) when contacting [support](https://www.socialfetch.dev/contact).
---
# TikTok video comments pagination
Source: https://www.socialfetch.dev/docs/api/v1/tiktok/videos/comments
## TikTok video comments pagination
`GET /v1/tiktok/videos/comments` uses **cursor pagination** — there is **no fixed number of comments per page**.
- Pass `cursor` from `data.page.nextCursor` on the next request
- Stop when `data.page.hasMore` is `false`
- Do **not** assume a fixed page size or loop on `totalComments` alone — totals may not match paginatable rows
Each successful page costs **1 credit** (see route pricing in the API reference).
---
# When to use POST /v1/ask vs typed endpoints
Source: https://www.socialfetch.dev/docs/api/v1/ask/post
## POST /v1/ask (natural language routing)
Use **`POST /v1/ask`** when you want to send **one** natural-language question and get **one** routed API lookup back.
- **One-shot only** — no conversation history, no follow-up clarifications.
- **Billing** — routing cost is absorbed in v1; you pay credits for the **routed lookup only** (`meta.creditsCharged` matches the nested lookup).
- **Response** — includes `data.routedOperation` (method, path, params) plus `data.lookup` (the same envelope the typed endpoint would return).
### Prefer typed endpoints in production
For automation, integrations, and predictable schemas, call the typed platform route directly (e.g. `GET /v1/youtube/channels?handle=MrBeast`).
### Not the same as GET /v1/web/ask
`GET /v1/web/ask` answers a question **about one URL** using a web-page LLM. `POST /v1/ask` routes social/API lookups across the catalog.
### Free browser demo
Try the capped demo at https://www.socialfetch.dev/tools/ask (1-credit lookups only). For multi-credit routes, use an API key.
---
# Cross-platform field crosswalk (author, timestamps, metrics)
Source: https://www.socialfetch.dev/product/ask-ai/field-crosswalk
## Cross-platform field crosswalk
Public API field names are **platform-native** (not renamed to a single vocabulary). Use this matrix when mapping snapshot types across platforms.
### Post / video get — author key & richness
| Platform | Resource | Author key | Author metrics on this get? | Timestamp |
| --- | --- | --- | --- | --- |
| TikTok | Video get | `author` | **No** (identity only: handle, verified, avatar) — call profile get for followers/posts | `video.createdAt` |
| Twitter | Tweet get | `author` | **Yes** (`author.profile` + `author.metrics`) unless `trim=true` | tweet created fields |
| Instagram | Post/reel get | `owner` | Thin owner card — use profile get for full metrics | `takenAt` (not `createdAt`) |
| YouTube | Video get | `channel` | Channel id/title style — use channel get for full metrics | `publishedAt` |
### Profile get — common snapshot fields
| Platform | Followers | Post/content count | Private | Verified | Account age |
| --- | --- | --- | --- | --- | --- |
| TikTok | `metrics.followers` | `metrics.posts` (agents often say videoCount) | `privateAccount` | `verified` | `accountCreatedAt` |
| Twitter | profile metrics | tweets count | private/protected flags | verified | created/age fields |
| Instagram | follower metrics | posts count | private | verified | when available |
| YouTube | subscriber metrics | video count | n/a | when available | when available |
### Trim footgun
On Twitter tweet get, **`trim=true` omits `author`** (and related core fields). Do not trim the first fetch if you need baseline author metadata.
### Docs workflow for agents
1. `docs_search` for the platform + resource + fields
2. `docs_read` with `mode=outline` on the primary **Get** page
3. Read this note when comparing platforms side-by-side
Canonical API pages: [TikTok profile](https://www.socialfetch.dev/docs/api/v1/tiktok/profiles/handle/get), [TikTok video](https://www.socialfetch.dev/docs/api/v1/tiktok/videos/get), [Twitter tweet](https://www.socialfetch.dev/docs/api/v1/twitter/tweets/get), [Instagram post](https://www.socialfetch.dev/docs/api/v1/instagram/posts/get), [YouTube video](https://www.socialfetch.dev/docs/api/v1/youtube/videos/get).
---
# Ask social data questions in plain English
Source: https://www.socialfetch.dev/blog/ask-in-plain-english
# Ask social data questions in plain English
Type a question about TikTok, YouTube, or Instagram — we route it, run the lookup, and return live JSON. How Ask works for agents and apps.
**Read on the site:** https://www.socialfetch.dev/blog/ask-in-plain-english
For years the deal with APIs was simple: here is the catalog, here are the params, good luck. That made sense when humans were the only integrators. You read the reference, wired the route, and moved on. It makes less sense now. Your teammate asks in Slack for MrBeast's TikTok followers. Your AI agent has a tool slot and a user question, not an afternoon to grep OpenAPI specs. Sometimes you want to try a lookup before you pick a path in code. The bottleneck is usually finding the right endpoint, not the data itself. We shipped POST /v1/ask: plain English on the way in, the same structured JSON our typed endpoints return on the way out. No path template. No up-front debate about handle vs channelId. You ask. We route, run the lookup, and return the same structured data the typed endpoint would have returned. Why AI agents need natural language APIs Tool use works when the model can say what it wants in human language and get a reliable result back. It works less well when every run starts with locating operationId tiktok.profile.get in the spec. A natural language endpoint cuts token overhead and routing mistakes on exploratory calls. Natural language at the boundary does not replace typed routes, stable schemas, or boring envelopes. We still publish full reference docs. There is room for a second front door: one question, one lookup, live JSON back. Ask in English when you are exploring. Pin the typed endpoint when you are shipping a cron job. How the natural language API works When you send "get the Instagram profile for @instagram," the intent router picks the platform (TikTok, YouTube, Instagram, and the rest) and the data type you want: profile, video, search, comments. It extracts handles, URLs, and search terms from the text, so you do not need our path templates up front. Then we run the underlying typed endpoint and return the same JSON you would get from calling that route directly. Each call is one shot. No thread, no memory, no back-and-forth on our side. You get the lookup payload plus data.routedOperation, which records which path we chose. That field is useful for debugging, for agents, and for discovering the typed route to use in production. Try the Ask demo We put a free browser demo on the site for exactly this: you have a question, you want to see if the router gets it, and you do not want to sign up first. Open /tools/ask, type a question, submit. You will see the routed operation and the live response — the production Ask route, without signing up first. The demo is capped to simple one-credit lookups so the page stays fair. When you need volume, grab a key and call Ask (or the typed route it returns) from your backend. Questions we typed while testing: How many TikTok followers does MrBeast have? How many YouTube subscribers does MrBeast have? Get the Instagram profile for @instagram If you already have an API key, the playground under Ask does the same thing with your credentials. When to use Ask vs typed routes Natural language does not replace your integration layer. For cron jobs, billing pipelines, and anything with a fixed schema contract, call the typed route. What Ask gives you is intent in, JSON out, without a documentation detour first. Agents enriching user context on the fly can call ask instead of injecting a full OpenAPI spec into every run. Internal Slack bots can answer "how many followers does X have on TikTok?" without a custom command per platform. When you are still exploring what data exists across networks, you can poke at a few questions before you wire specific routes. A few things to expect: Vague questions ("how many followers does MrBeast have?") may fail or pick the wrong network. Name the platform. One question, one lookup. Comparing TikTok and YouTube for the same creator is two calls. Off-topic questions get rejected before a lookup runs. You are not charged for those. Routing on POST /v1/ask costs 0 credits. The nested lookup bills at that endpoint's normal rate on a completed lookup. Infrastructure failures are not charged. A completed not_found or private result still bills, same as calling the typed path directly. Trust meta.creditsCharged. See Pricing. API reference Request shape, response fields, error codes, and billing: API reference for POST /v1/ask. } /> } />
---
# Best Facebook APIs 2026: Graph & Ad Library
Source: https://www.socialfetch.dev/blog/best-facebook-data-apis-2026
# Best Facebook APIs 2026: Graph & Ad Library
Compare Facebook APIs for pages, posts, groups, Marketplace, and Ad Library — Meta Graph vs scrapers and sync REST.
**Read on the site:** https://www.socialfetch.dev/blog/best-facebook-data-apis-2026
"Facebook API," "Facebook Ad Library API," or "Facebook scraper" usually points at Meta's Graph API. Teams shopping those phrases usually need one of three things: pages and ad accounts they administer, public Ad Library research, or enrichment of pages, groups, and Marketplace listings they do not own. Those are different products. Mixing them up is how you burn weeks on app review for a competitor page card, or buy a headless Actor when you only needed Marketing API insights on your own spend. Facebook still shows up for local pages, public groups, Marketplace, and paid creative archives even when creator work moved to Instagram and TikTok. Homegrown scrapers against Meta properties hit the same login walls and markup churn as every other Meta surface. Social Fetch is my pick for sync REST over public Facebook pages, posts, reels, groups, Marketplace helpers, transcripts, and Ad Library lookups, especially if you already normalize Instagram and TikTok under one key. Use Meta's Graph and Marketing APIs when you need owned Pages, Insights, publishing, or ad accounts you control. Use Meta's Ad Library API when counsel wants a first-party transparency path and you can live inside Meta's product limits. Use Apify for a custom Actor or a scheduled batch dump. Use Bright Data when enterprise proxy volume and procurement drive the decision. The short list 1. Social Fetch — sync REST for public Facebook data, same envelope as other platforms 2. Meta Graph / Marketing APIs — first-party route for Pages, Insights, and ad accounts you administer 3. Meta Ad Library API — official transparency product for public ads research 4. Apify Facebook Actors — marketplace scrapers when you need custom fields or scheduled runs 5. Bright Data — enterprise proxy and dataset infrastructure 6. SociaVault / ScrapeCreators — smaller multi-platform social PAYG options 7. RapidAPI Facebook listings — discovery marketplace, not one production contract | Option | Best for | Sync REST | Pages + groups + ads | Starting cost | | --- | --- | --- | --- | --- | | Social Fetch | Public enrichment + multi-platform apps | Yes | Yes (public surfaces) | 100 free credits, then PAYG | | Meta Graph / Marketing | Owned Pages, Insights, publishing, ad accounts | Yes (when approved) | Owned assets | Free for authorized assets; app review | | Meta Ad Library API | First-party ads transparency | Yes (Meta product) | Ads archive | Meta developer access | | Apify Actors | Custom scrapes, batch schedules | Poll runs | Via Actors | ~$5/mo free credit, then plans | | Bright Data | Enterprise volume + proxies | Async / datasets | Via scrapers | Trial / spend floors | | SociaVault / ScrapeCreators | Simple PAYG social JSON | Yes | Partial (verify FB routes) | Credit packs | | RapidAPI listings | Prototyping niche endpoints | Varies | Varies | Per listing | Full Facebook route list and examples live on the Facebook platform page. How I rank Facebook data APIs I rank on production behavior, not landing-page adjectives: 1. What you can actually call — page/profile cards, posts, reels, photos, group feeds, Marketplace search, Ad Library get/search/companies. Count real paths, not "Facebook support" on a marketing grid. 2. Owned vs public enrichment — Graph and Marketing APIs are a different compliance path from public-page JSON. Know which one your counsel and product actually need. 3. Ad Library is its own product — competitor creative research is not Page Insights on a Page you admin. Vendors that collapse both into "Facebook ads API" force bad architecture. 4. Sync vs async — one HTTP response you can await in a product request, or start-a-run / poll-a-dataset / burn execution hours. 5. Error shape — typed lookupStatus and a requestId beat silent empty HTML or a 200 with a broken parser. 6. Multi-platform tax — if your app already pulls Instagram and TikTok, does Facebook force a second schema and a second vendor? 7. Private / gated surfaces — private groups and logged-in-only content are out of scope for public enrichment. Ask what happens on not_found and private before you promise coverage. 8. Compliance fit — official APIs for assets Meta authorizes; third-party public-data APIs for enrichment of publicly visible pages and Ad Library rows. Read Meta's Terms for your use case. I am not your lawyer. Ranked picks 1. Social Fetch: public Facebook over one REST key _Best for: product teams and agents that need public page cards, posts, reels, group feeds, Marketplace helpers, and Ad Library search without a Meta app for assets they do not own, and that already (or soon will) pull other social platforms._ Social Fetch exposes first-party Facebook routes under /v1/facebook/: profiles and Pages by URL, profile posts / reels / photos, post detail and comments, post transcripts, public group posts, Marketplace location and listing helpers, and Ad Library ad get, keyword search, company search, and company ads. Responses use the shared envelope. Metrics land in the same conventions as other platforms, so Facebook rows sit next to Instagram in one warehouse. What I like: Sync GET routes for the common enrichment path; no Actor run polling for a page card or Ad Library keyword page Explicit lookupStatus on profile lookups (found, private, not_found) instead of silent empty payloads profileType of person or business so you do not treat every URL as a Page Ad Library search with country, status, media type, and date filters, plus cursor pagination meta.requestId and meta.creditsCharged on every response Same API key as Instagram, TikTok, YouTube, and the rest of the catalog (20 platforms / 154 marketplace operations) 100 free credits on signup, no card; PAYG packs do not expire What to watch: This is public enrichment, not Page Insights, publishing, Messenger, or ads-account management Private groups are out of scope. Public group feeds still return small pages (often a few posts); filter keywords in your own pipeline List routes may omit lookupStatus. Call the profile route first when you need an explicit found/private/not_found before interpreting an empty posts page Heavier or paginated lookups still bill per completed page. Trust meta.creditsCharged and the operation docs Coverage follows what Facebook shows publicly. Gated or logged-in-only sections are out of scope Pricing: Free (100 credits) → Starter $14 (1,000) → higher packs on pricing. Credits charge on completed lookups — trust meta.creditsCharged. Most Facebook profile, post list, group, Marketplace, and Ad Library routes are 1 credit per successful request. Verdict: Default pick when Facebook is one surface in a multi-platform product, or when you want sync public JSON without owning a Meta scraper stack. See the Facebook hub for the full route list. For a one-off Ad Library spot check without wiring keys, use the free browser tool below. 2. Meta Graph and Marketing APIs: when you administer the asset _Best for: apps that manage Pages, Insights, publishing, messaging, or ads accounts under Meta Login and app review._ Meta's Graph API and Marketing API are the correct products when you need data or actions on assets you control (or that users grant you). That path is free for authorized use within Meta's rate limits and is the right compliance story for first-party data. It is not a general "look up any public Page URL" enrichment free-for-all. What I like: First-party ToS path when you qualify. Stable docs for the surfaces you are allowed to call. Works for owned Insights and Marketing API spend data. What to watch: App review, Business Verification, and token scopes gate access. Competitor enrichment and public group polling are usually the wrong fit. If a sales deck claims "official Facebook API access" for arbitrary public profiles, ask which Meta product and which OAuth grant. Verdict: Use it when ownership and compliance require Meta-authorized access. Supplement or replace it for public enrichment volume when you never get (or should not apply for) those scopes. 3. Meta Ad Library API: official ads transparency _Best for: teams that need Meta's first-party Ad Library product for public ads research and can live inside Meta's access model and field set._ Meta publishes Ad Library data for transparency. The official Ad Library API is the right call when counsel wants a Meta-signed path and your workflow fits what Meta documents. It is still a different product from Graph access to a Page you admin. What I like: First-party transparency path. Clear separation from Marketing API on owned spend. What to watch: Access rules, rate limits, and field coverage follow Meta's product, not your warehouse schema. Keyword sweeps, cursor pagination in your own envelope, and multi-platform normalization are why teams still buy third-party Ad Library routes. Verdict: Prefer Meta's Ad Library API when the official path covers the job. Prefer a managed third-party route when you need the same shape as the rest of your social catalog, or a free spot-check UI before you wire keys. 4. Apify: Facebook Actors for custom and batch work _Best for: scheduled page dumps, niche field extraction, and scrapers you want to configure as Actors rather than maintain as a fleet of browsers._ Apify hosts many Facebook Actors (Pages, posts, groups, Marketplace, Ad Library-adjacent scrapers). You start a run, poll, download a dataset. Schemas differ by Actor author. Billing mixes compute and event fees; monthly plan credits expire. What I like: Marketplace breadth. Good when no managed REST route exposes the field you need. Scheduling is built into the platform. What to watch: You are buying a runtime, not one Facebook schema. Actor quality varies. Sync product UIs that need a single HTTP round trip fit poorly. Meta anti-bot pressure hits Actor authors unevenly. Verdict: Right for batch and custom scrapes. Wrong as your only integration if you want one typed client for page + Ad Library in a request handler. Longer take: Social Fetch vs Apify. 5. Bright Data: enterprise infrastructure _Best for: high-volume teams with budget for proxy networks, dataset pipelines, and sales-led contracts._ Bright Data sells unblock and collection infrastructure. Facebook scrapers exist on top of that stack. You are buying a platform: residential IPs, browser farms, async exports. That is not a product engineer's REST schema for a single Page card. What I like: Volume pricing and hard-target success rates that large orgs already understand. Procurement and SLAs. What to watch: No unified multi-social schema by default. Spend floors and enterprise pricing. You still own parsers unless you buy a higher-level dataset product. Verdict: Justified when volume and procurement dominate the spreadsheet. Overkill for a startup shipping one Facebook enrichment feature. See Social Fetch vs Bright Data. 6. SociaVault and ScrapeCreators: smaller PAYG social APIs _Best for: a short list of mainstream platforms and simple credit math when Facebook is one of a few networks you care about._ These vendors sit in the same broad category as Social Fetch: credit-based social JSON rather than proxy farms. Platform coverage and Facebook depth vary. Confirm page, group, Marketplace, and Ad Library routes on their docs before you promise those surfaces. What I like: Predictable packs. Lower ceremony than enterprise proxy contracts. What to watch: Smaller catalogs than Social Fetch's 20-platform matrix. Schema normalization is often partial. Solo-vendor ops risk on some packs. Re-check Facebook-specific coverage live. Marketing "social API" claims drift. Verdict: Credible alternatives at low volume. Compare envelope shape, Ad Library filters, and support model before you standardize. 7. RapidAPI Facebook listings: browse, then graduate _Best for: finding a niche Facebook endpoint over a weekend without signing an enterprise contract or waiting on Meta app review._ RapidAPI hosts third-party Facebook scrapers under one billing dashboard. Discovery is the strength: try a Page profile listing, an Ad Library scraper, and a group feed endpoint in the same afternoon. Prototypes move fast because the marketplace test console will call anything. Facebook surfaces (Pages, groups, Marketplace, Ad Library) often ship as separate listings with incompatible schemas. Production teams that stitch three of them inherit three rate limits and three publishers who can change terms after a Meta crackdown. Multi-platform products pay again for Instagram and TikTok listings. Marketplace social scrapers commonly wander around $2.50–$4+ per 1,000 depending on the publisher. Verify before you model Ad Library volume. What I like: Fast shopping. Low commitment for disposable experiments. Fine if Facebook is a tiny input among many unrelated RapidAPI line items. What to watch: Graph vs public-enrichment confusion gets worse on a marketplace shelf. No shared envelope. Support tickets route through a middleman. Verdict: Keep it for exploration. Prefer Meta Graph when you manage the asset, or a first-party public-data API when you need public Page/Ad Library JSON in a product. Longer take: Social Fetch vs RapidAPI. Graph API vs third-party data APIs Pick owned-asset scopes vs public enrichment before you compare pricing. | Need | Prefer | | --- | --- | | Page Insights, publishing, Messenger, ads accounts you manage | Meta Graph / Marketing APIs | | Official Ad Library transparency product | Meta Ad Library API | | Public Page/profile card for CRM or competitive research | Managed public-data REST (Social Fetch, etc.) | | Public group feed polling | Public-data group routes or an Actor. Not Graph without membership | | Marketplace listing search near a lat/long | Managed Marketplace helpers or a custom scrape | | Keyword Ad Library sweeps in your warehouse envelope | Social Fetch Ad Library search, or Meta's Ad Library API if it fits | | One brand/keyword Ad Library check, no API key yet | /tools/facebook-ad-library | | Nightly custom scrape with odd fields | Apify Actor | Social Fetch only returns publicly visible data. Content gated beyond public visibility is out of scope. Graph does not unlock "any Page on the internet" either. It unlocks what Meta authorizes for your app and the assets you manage. If a vendor claims "official Facebook API access" for arbitrary public profiles, ask which Meta product and which grant. Public enrichment and owned Insights are different products. Free Ad Library search before you buy If the job is one brand or keyword, you do not need an API key yet. The free Facebook Ad Library search runs the same production GET /v1/facebook/ad-library/ads/search route with Turnstile and per-IP caps (1/min · 3/hour · 10/day). Paste a brand or keyword, pick Active / All / Inactive, and read advertiser, copy, platforms, and a link into Meta's library. When you need pagination, country filters, media type, date ranges, company search, or warehouse inserts, move to the API on /platforms/facebook. New accounts get 100 free credits with no card. Which API fits which job Multi-platform enrichment product, sync JSON → Social Fetch (Facebook hub) Owned Pages, Insights, publishing, ads accounts → Meta Graph / Marketing APIs Official ads transparency path → Meta Ad Library API Nightly scrape with custom fields → Apify Actor Enterprise proxy volume → Bright Data One-off Ad Library spot check in the browser → /tools/facebook-ad-library Agent calling Facebook + Instagram + TikTok → Social Fetch MCP + unified schema If you only need Facebook today but Instagram next quarter, pick the option whose envelope you can reuse. Rewriting parsers per Meta property is where most "cheap" Facebook scrapers get expensive. Questions before you buy 1. Do you need owned-asset scopes, or public enrichment? That fork decides Graph/Marketing vs third-party first. 2. Page card, group feed, Marketplace, or Ad Library? Confirm the vendor has separate, documented paths, not one HTML dump labeled "Facebook." 3. Will Ad Library pagination and filters fit your cron? Free UIs return one page. Pipelines need cursor + filters. 4. Sync or batch? Product request handlers prefer sync. Overnight dumps can live on Actors or datasets. 5. One schema across platforms? Call Facebook and Instagram with the same parser. If you need if (platform === "facebook") for basic identity fields, you do not have unification. 6. Do credits expire? Spiky enrichment workloads hate monthly resets. 7. Private groups? If the answer must include closed groups, no public enrichment API will save you. Plan for ownership or membership. 8. Can you preview without shipping? Use the free Ad Library tool, the playground, or free credits before you lock a vendor. Frequently asked questions What is the best Facebook data API in 2026? For public sync REST with pages, posts, reels, groups, Marketplace helpers, and Ad Library, plus the same envelope as other social platforms, Social Fetch is my pick. I built it. Meta's Graph and Marketing APIs win for owned assets. Meta's Ad Library API wins when you want the official transparency path. Apify wins for custom Actors. Bright Data wins on enterprise infra. Is there an official Facebook API for any public page? Meta's Graph API covers assets you manage (and scopes Meta approves). It is not a general public-page enrichment API for competitor URLs. Third-party data APIs fill that gap for publicly visible content. Read Meta's Terms and talk to counsel for your jurisdiction. Can I access Facebook Ad Library via API? Yes. Social Fetch exposes Ad Library get, keyword search, company search, and company ads under /v1/facebook/ad-library/. Meta also offers an official Ad Library API. For a free browser spot check, use /tools/facebook-ad-library. Do you support Facebook groups? Public group post routes are included on Social Fetch (GET /v1/facebook/groups/posts). Private groups are not accessible via public lookup. See the Facebook groups use case. Facebook Graph API vs Social Fetch: which should I use? Use Graph / Marketing when you need Meta's auth model on assets you administer. Use Social Fetch when you need enrichment of publicly visible pages, groups, Marketplace, and Ad Library rows without page admin access. Scrapers and Actors fill gaps neither covers. They also shift maintenance onto you. How much does Social Fetch charge for Facebook? Most Facebook profile, posts, reels, photos, group, Marketplace, and Ad Library lookups are 1 credit per successful request. Credits charge on completed lookups. Trust meta.creditsCharged. See pricing and the Facebook hub. Should I build my own Facebook scraper? Build your own for a one-off research script. Use a managed API for anything production. Meta frontend and anti-bot churn usually costs more than credits within a few months. What about compliance? We return publicly visible data. Compliance with Meta's terms and local law is your responsibility. Consult counsel for your use case. See our docs.
---
# Best Hacker News APIs & scrapers in 2026
Source: https://www.socialfetch.dev/blog/best-hacker-news-data-apis-2026
# Best Hacker News APIs & scrapers in 2026
Compare Hacker News data APIs for search, feeds, stories, comments, users, and hiring — Social Fetch vs DIY, Apify, and scrapers.
**Read on the site:** https://www.socialfetch.dev/blog/best-hacker-news-data-apis-2026
Hacker News still concentrates a kind of signal that social feeds dilute: Show HN launches, Ask HN tooling debates, monthly Who is Hiring threads, and comment threads that are more honest than most review sites. When people search for a "Hacker News API," they usually want one of three things — wire HN into a product request handler, run overnight batch dumps, or cobble public HN endpoints together themselves. Those are different products. Mixing them up is how you end up with a fragile glue layer: ranked id lists with no titles attached, comment trees you walk node by node, search hits that do not match your story schema, and a favorites page that never showed up in the JSON APIs at all. This is a coverage and ergonomics comparison for July 2026. Re-check each vendor's docs and pricing before you commit budget. Social Fetch is my pick for sync REST over HN search, ranked feeds, stories, comment pages, user history, public favorites, and structured Who is Hiring rows — especially if you already normalize Reddit, X, or Web under the same key. Prefer DIY against HN's public read surfaces when HN is your only network and you want to own every hop. Prefer Apify when you need a custom crawl field nobody documents. Prefer raw browser stacks only when you need HTML or screenshots, not a profile of a story. The short list 1. Social Fetch — sync REST for search, feeds, stories, comments, users, favorites, hiring 2. DIY on HN's public read APIs — assemble item, user, feed, and search clients yourself 3. Apify / custom actors — scheduled dumps and niche field extraction 4. API marketplaces — RapidAPI-style listings for weekend discovery 5. Generic proxy + browser stacks — raw page capture when you will parse yourself 6. HN-only niche APIs — smaller catalogs that only cover Hacker News | Option | Best for | Sync REST | Search + stories + users | Starting cost | | --- | --- | --- | --- | --- | | Social Fetch | Multi-platform enrichment | Yes | Yes (one key) | 100 free credits, then PAYG | | DIY public HN APIs | HN-only scripts you own | You build it | You assemble it | Your infra | | Apify / actors | Custom fields, batch schedules | Poll runs | Via actor schema | Free credit, then plans | | Marketplace listings | Prototyping niche endpoints | Varies | Varies | Per listing | | Proxy + browser | Raw HTML / screenshots | No | No | Usage-based | | HN-only niche APIs | HN without other networks | Often yes | Partial catalogs | Trial / plan | Full route list: Hacker News platform page. Hands-on walkthrough: How to scrape Hacker News data. What teams actually buy an HN API for Ignore "we support Hacker News" marketing grids. The jobs that show up in production tickets look like this: | Job | What "done" looks like | | --- | --- | | Launch / brand mention watch | Search hits for a product name, then story cards + comment pages for the ids you keep | | Morning digest | Top / new / show / ask / jobs rows with title, score, URL, comment count — not bare ids | | Sentiment on a thread | Cursor-paginated comments for a known story id, without timing out on busy trees | | Author research | User card, then submissions or comments for prolific posters | | Hiring intel | Monthly Who is Hiring comments as rows you can filter, not one giant text blob | | Saved-signal mining | Public favorites for a username, with private favorites as a typed miss | If a provider cannot clear those rows, you will rebuild the missing pieces yourself — which is how "free official access" turns into a second product. How I rank Hacker News data APIs 1. Assembled objects vs plumbing — do feeds return hydrated stories, or id lists you must fan out? 2. Search and story shape — can one parser handle hits and story gets, or do you maintain two models? 3. Comment pagination — busy threads need pages and cursors, not a single recursive dump that blows timeouts. 4. Hiring and favorites — these are the surfaces DIY most often skips; they are also high-signal. 5. Typed misses — lookupStatus and empty hits beat silent HTML. 6. Sync vs async — product handlers prefer one HTTP round trip; overnight dumps can live on actors. 7. Multi-platform tax — if Reddit already shares your envelope, does HN force a second client? 8. Compliance fit — public HN data under Y Combinator's terms; you own how you use it. I am not your lawyer. Ranked picks 1. Social Fetch — HN under one marketplace key _Best for: product teams and agents that need search, digests, comment pages, author history, public favorites, and Who is Hiring beside other networks — without owning HN glue code._ Social Fetch exposes documented /v1/hackernews/ routes with the shared envelope — meta.requestId, meta.creditsCharged, and typed outcomes where routes expose lookupStatus. Authenticate with x-api-key. New accounts get 100 free credits. Each successful request or cursor page is credit-metered; confirm meta.creditsCharged. What that buys in practice: Search with type, author, domain, URL, and minPoints filters for brand and launch monitors. Ranked feeds (top, new, best, ask, show, jobs) with hydrated items, not id-only lists. Story + comment pages for discussion jobs; polymorphic item get when the id type is unknown. User card + submissions / comments / public favorites for author analysis. Who is Hiring as structured rows with best-effort company / role / location fields and the full plain-text body as source of truth. Coverage is public data. Private favorites return lookupStatus: private_or_unavailable. Upvoted pages are not supported. Pricing: Free (100 credits) → packs on pricing. Verdict: Default when HN is one surface in a multi-platform product, or when hiring / favorites / sync REST matter more than owning every public endpoint yourself. Hub: /platforms/hackernews. Guide: How to scrape Hacker News data. 2. DIY on HN's public read APIs _Best for: HN-only scripts where you want first-party public JSON and will own assembly, retries, and schema glue._ Hacker News publishes public read surfaces for items, users, and ranked feed id lists, plus a separate public search surface. That stack is genuinely useful — and genuinely incomplete as a product API. Feed endpoints give you ids; you hydrate each item. Comment threads are trees you walk. Search hits rarely match your story object 1:1. Public favorites live on HTML pages, not the same JSON paths as items. Who is Hiring is a monthly comment thread you have to discover and parse. DIY wins when HN is the only network, volume is modest, and a staff engineer already knows the quirks. It loses when a customer-facing feature needs one error shape, one credit meter, and the same parser you use for Reddit next quarter. Verdict: Keep it for internal scripts. Prefer a managed API when customers wait on your HTTP response or when hiring / favorites are part of the job. 3. Apify — actors for custom and batch work _Best for: scheduled dumps, niche HTML fields, and scrapers you want to configure as Actors rather than maintain as a fleet of browsers._ Apify hosts HN scrapers that start a run, poll, and download a dataset. Schemas differ by actor author. Billing mixes platform subscription, compute, and per-event fees; monthly plan credits expire. Model the listing you will actually run. Marketplace breadth helps when no managed REST route exposes the field you need. Sync product UIs that need a single HTTP round trip fit poorly. See Social Fetch vs Apify. Verdict: Right for batch and custom scrapes. Wrong as your only integration if you want typed search + comments in a request handler. 4. API marketplaces — browse, then graduate _Best for: finding a niche HN endpoint over a weekend without signing an enterprise contract._ RapidAPI-style marketplaces aggregate third-party HN scrapers. One billing UI, many publishers, no shared schema. Fine for disposable prototypes. Weak for production monitoring: pagination, freshness, and empty-result behavior vary by publisher. Adding Reddit or Truth Social beside HN means more listings and more adapters. Longer take: Social Fetch vs RapidAPI. Verdict: Exploration only. Prefer a first-party sync API when HN sits in a product feature. 5. Generic proxy and browser stacks _Best for: raw HTML, screenshots, or one-off captures you will parse yourself._ Proxy and browser products are infrastructure. They do not give you a Who is Hiring row with lookupStatus. Buy them when you need capture; buy a data API when you need query → JSON. 6. HN-only niche APIs _Best for: teams that only ever need Hacker News and prefer a small catalog over a multi-network marketplace._ A few vendors sell HN-only REST catalogs (search, lists, items, users). They can be fine if HN is the entire product. They leave you with a second vendor the day you add Reddit brand mentions or Web extraction. Compare field coverage carefully — many skip favorites and structured hiring. Verdict: Acceptable for HN-only tools. Prefer Social Fetch when the roadmap already includes other networks. DIY public HN APIs vs a managed product API | Need | DIY public HN APIs | Social Fetch | | --- | --- | --- | | Hydrated front-page digest | Fan out id → item yourself | Feeds return items | | Keyword search + story schema | Separate search client + mapping | One envelope | | Busy comment threads | Recursive walks / custom paging | Cursor pages | | Public favorites | HTML scrape | Dedicated route + typed private miss | | Who is Hiring rows | Discover thread + parse comments | Structured route | | Same key as Reddit / Web | No | Yes | | Support requestId | You invent it | meta.requestId | Which option fits which job | Job | Pick | | --- | --- | | Brand / launch mention watch | Social Fetch search | | Morning top/show digest | Social Fetch feeds | | Comment sentiment on a known story | Social Fetch story comments | | Author analysis | Social Fetch users + activity routes | | Monthly hiring parse | Social Fetch who-is-hiring | | Overnight HTML archive | Apify / browser | | HN-only personal script | DIY public APIs | Questions before you buy 1. Do you need assembled stories, or are bare ids enough? Digests need hydration. 2. Is search part of the job? Many DIY stacks under-build search filters. 3. Will HN sit beside Reddit or Web? Prefer one schema if yes. 4. Sync or batch? Product handlers prefer sync. 5. Do credits expire? Spiky research sprints hate monthly resets. 6. Do you need hiring or favorites?** Ask vendors explicitly — those are the common gaps. Frequently asked questions Is there a Hacker News API? Yes. Hacker News publishes public read APIs for items, users, and feeds, plus a public search surface. Social Fetch provides a managed catalog under /v1/hackernews for search, feeds, stories, comments, users, favorites, and hiring. Hub: /platforms/hackernews. How do I use Hacker News data in a product? Call typed REST routes (or MCP tools), branch on lookupStatus where present, and store meta.requestId. Step-by-step: How to scrape Hacker News data. Does Social Fetch require a Hacker News account? No. You need a Social Fetch API key. Coverage is public HN data only. Can I get a user's favorites? Yes for public favorites via GET /v1/hackernews/users/ /favorites. Private favorites return lookupStatus: private_or_unavailable. Upvoted pages are not supported. Official HN APIs vs a Hacker News data API — which should I use? Use HN's public read APIs when you want to own every hop for an HN-only script. Use a managed data API when you need one key, one envelope, hydrated feeds, hiring helpers, and multi-network parity. Smoke-test search in the playground, or start with 100 free credits on pricing. Broader roundup: Best social media scraping APIs in 2026.
---
# Best Instagram scrapers & data APIs in 2026
Source: https://www.socialfetch.dev/blog/best-instagram-data-apis-2026
# Best Instagram scrapers & data APIs in 2026
Compare Instagram scrapers and data APIs for profiles, reels, comments, and transcripts — Social Fetch vs HikerAPI, Apify, Bright Data, and more.
**Read on the site:** https://www.socialfetch.dev/blog/best-instagram-data-apis-2026
Instagram does not give you a public content API for arbitrary creators. Meta's Graph API reads accounts you manage, behind app review and business verification. If you need a competitor's follower count, a creator's recent reels, or a reel transcript for a brand-safety pipeline, you are shopping for an Instagram scraper or third-party Instagram data API, not Graph. I have maintained Instagram scrapers long enough to know the usual failure mode: GraphQL shapes move, login walls appear mid-cron, and your dashboard shows zero while the mobile app still shows posts. The APIs below are not interchangeable. Some are Instagram-only REST products, some are actor runtimes, some are proxy farms with social endpoints bolted on. The useful ones return typed JSON for profiles, posts, and reels without making you own the anti-bot stack. This is a pricing and coverage comparison for April 2026. Re-check each vendor's pricing page before you commit budget. Where I could not verify a number live, I say so. Social Fetch is my pick when Instagram is one platform among several, or when you want sync REST with the same envelope as TikTok and YouTube. Profile lookups are 1 credit on a completed request. We ship raw metrics, not server-side engagement_rate. HikerAPI often wins on Instagram-only depth and raw per-request price. Apify and Bright Data win when you need custom Actors or enterprise proxy volume. Use the Graph API when you only need accounts you own. The 7 best Instagram data APIs at a glance 1. Social Fetch: sync REST Instagram routes inside a 20-platform catalog 2. HikerAPI: Instagram-only specialist; often the cheapest per-request floor 3. Apify: actor marketplace when you need a custom Instagram scraper 4. Bright Data: enterprise proxy and dataset infrastructure 5. SociaVault: simple pay-as-you-go across a smaller social set 6. ScrapeCreators: flat credit packs for multi-platform social JSON 7. RapidAPI: marketplace discovery, not a single production product | API | Best for | Instagram focus | Starting price | Free tier | | --- | --- | --- | --- | --- | | Social Fetch | Sync REST + multi-platform schema | Profiles, posts, reels, search, transcripts, highlights | $14 / 1k credits | 100 credits, no card | | HikerAPI | Instagram-only volume | Deep IG endpoint catalog | ~$0.60–$1 / 1k req† | ~100 requests (verify) | | Apify | Custom Actors / batch | Actor-dependent | $29/mo + usage | ~$5/mo credit | | Bright Data | Enterprise volume | Dataset / scraper products | ~$1.50 / 1k records† | Trial / free records (verify) | | SociaVault | Simple PAYG | Core social including IG | $29 / 6k credits | 50 credits | | ScrapeCreators | Flat credit packs | Multi-platform social | ~$47 / 25k credits† | 100 credits | | RapidAPI | Prototyping | Varies by listing | Varies | Varies | † Verify on the vendor site before budgeting. Third-party roundups drift. For multi-platform context beyond Instagram, see 10 best social media scraping APIs in 2026. What makes a good Instagram data API I rank tools on what still matters after the demo: 1. Documented Instagram routes: profiles by handle, posts, reels, comments, search, transcripts. Count paths in a public docs index, not a landing-page claim. 2. Typed outcomes: private and missing accounts should return an explicit status, not an empty object that looks like a deleted creator. 3. Sync vs async: can your onboarding flow wait on one HTTP response, or do you poll a dataset run? 4. Pricing: credits that never expire vs monthly resets; surcharges for media download or JS rendering; whether completed lookups bill (including not_found and private). 5. Multi-platform tax: if next quarter adds TikTok and YouTube, do you keep one key and one parser? 6. Agent readiness: OpenAPI or MCP, deterministic JSON, a requestId you can paste into support.
---
# Best LinkedIn APIs in 2026: partner vs public
Source: https://www.socialfetch.dev/blog/best-linkedin-data-apis-2026
# Best LinkedIn APIs in 2026: partner vs public
Compare LinkedIn APIs for people, companies, and posts — official partner / MDP vs public enrichment (Social Fetch, Enrich Layer, Apify).
**Read on the site:** https://www.socialfetch.dev/blog/best-linkedin-data-apis-2026
"LinkedIn API" or "LinkedIn data API" usually means LinkedIn's partner and Marketing Developer Platform products. In practice, teams shopping those phrases need one of three things: member-authorized apps LinkedIn has approved, public person or company enrichment without a partner deal, or browser automations that scrape Sales Navigator-shaped workflows. Those are different products. Mixing them up is how you end up buying Phantom hours when you needed a profile GET, or waiting months for partner access when a public-page lookup would have shipped the feature. Longer walkthrough of that fork: LinkedIn partner API vs public data. Proxycurl shut down in July 2025 after LinkedIn litigation. Rate cards from a dead vendor still float around in RFPs. Treat those numbers as history, not a February 2026 budget. Re-check each vendor's pricing page before you commit. Social Fetch is my pick for sync REST over public LinkedIn people, companies, posts, jobs, Ad Library, and search, especially if you already normalize creators across TikTok and Instagram. Use LinkedIn's official APIs when you need member OAuth or partner features. Use Enrich Layer for the lowest-effort migration off Proxycurl when LinkedIn is your only network. Use Apify for custom Actors or scheduled batch dumps. Use PhantomBuster for outreach automation, not JSON for your backend. The short list 1. Social Fetch — sync REST for public LinkedIn data, same envelope as other platforms 2. LinkedIn official APIs (partner / MDP) — authorized route for member scopes and LinkedIn-approved products 3. Enrich Layer — LinkedIn-focused successor path after Proxycurl shut down 4. Apify LinkedIn Actors — marketplace scrapers when you need custom fields or scheduled runs 5. Bright Data / Oxylabs — enterprise proxy and dataset infrastructure at volume 6. PhantomBuster — cloud automation for sales playbooks, not a profile schema API 7. RapidAPI LinkedIn listings — discovery marketplace, not one production contract | Option | Best for | Sync REST | People + companies | Starting cost | | --- | --- | --- | --- | --- | | Social Fetch | Public enrichment + multi-platform apps | Yes | Yes | 100 free credits, then PAYG | | LinkedIn official APIs | Partner apps, member OAuth | Yes (when approved) | Via LinkedIn products | Partner / MDP process | | Enrich Layer | LinkedIn-only Proxycurl migration | Yes | Yes (LinkedIn-centric) | See enrichlayer.com | | Apify Actors | Custom scrapes, batch schedules | Poll runs | Via Actors | ~$5/mo free credit, then plans | | Bright Data / Oxylabs | Enterprise volume + proxies | Async / datasets | Via scrapers | Trial / spend floors | | PhantomBuster | Outreach automations | Automation API | Via Phantoms | Plans from ~$69/mo (verify) | | RapidAPI listings | Prototyping niche endpoints | Varies | Varies | Per listing | Full LinkedIn route list and examples live on the LinkedIn platform page. Partner vs public enrichment decision: LinkedIn partner API vs public data. How I rank LinkedIn data APIs I care about production behavior, not landing-page adjectives: 1. What you can actually call — people profiles, companies, organizations/schools, posts, people search, jobs, Ad Library, transcripts. Count real paths, not "LinkedIn support" on a marketing grid. 2. Official vs public enrichment — member-authorized partner APIs are a different compliance and product path from public-page JSON. Know which one your counsel and product actually need. 3. Sync vs async — one HTTP response you can await in a product request, or start-a-run / poll-a-dataset / burn execution hours. 4. Person vs company vs job — /in/…, /company/…, and job URLs are different entities. Vendors that collapse them into one "LinkedIn scrape" endpoint force your code to guess. 5. Error shape — typed lookupStatus and a requestId beat silent empty HTML or a 200 with a broken parser. 6. Multi-platform tax — if your app already pulls TikTok and Instagram, does LinkedIn force a second schema and a second vendor? 7. Vendor concentration risk — Proxycurl proved a LinkedIn-only enrichment business can vanish. Ask what happens if this network gets harder, not only what the demo returns today. 8. Compliance fit — official API for experiences LinkedIn approves; third-party public-data APIs for enrichment of publicly visible pages. Read LinkedIn's Terms for your use case. I am not your lawyer. Ranked picks 1. Social Fetch — public LinkedIn over one REST key Good fit for product teams and agents that need public person cards, company pages, posts, jobs, and search without a LinkedIn partner app, and that already (or soon will) pull other social platforms. Social Fetch exposes first-party LinkedIn routes under /v1/linkedin/*: person profiles (batch up to 50 URLs), profile posts, people search, organizations, company pages, company posts, individual posts, post transcripts, post search, Ad Library get/search, jobs, and job search. Thirteen documented operations as of February 2026. Responses use the shared envelope. Follower-style metrics land in the same conventions as other platforms, so cross-network account scores do not fork on field names. Sync GET routes cover the common enrichment path. No Actor run polling for profile or company cards. Person, company, and organization routes are separate. You do not feed a /company/… URL into a person endpoint and hope. Batch profile lookups accept up to 50 URLs per request at 2 credits per URL requested. Every response includes meta.requestId and meta.creditsCharged. The same API key works for TikTok, Instagram, YouTube, and the rest of the catalog. Signup includes 100 free credits with no card; PAYG packs do not expire. Watch the scope: this is public enrichment, not Sales Navigator, InMail, or LinkedIn partner analytics. People search and job search are slower and metered differently than a single profile GET. Plan for about a minute and a half on those searches, and read the credit blurb (attempt fee plus per-record credits). Heavier routes cost more than a simple company GET. Coverage follows what is publicly visible. Gated or logged-in-only sections are out of scope. Credits charge on completed lookups. Trust meta.creditsCharged on every response, not a spreadsheet guess. Profile GETs are 2 credits per URL requested. Company pages, posts, and many other flat routes are 1 credit on success. People search bills a 2-credit attempt fee plus 2 credits per person returned. Free tier (100 credits) → Starter $14 (1,000) → higher packs on pricing. My default pick when LinkedIn is one surface in a multi-platform product, or when you want sync public JSON without waiting on partner access. For a one-off paste-and-copy person lookup without wiring keys, use the free LinkedIn profile viewer. Full route list: LinkedIn hub. 2. LinkedIn official APIs — when you need LinkedIn's auth model Good fit for apps that manage member-authorized experiences, Marketing Developer Platform features, or must stay inside LinkedIn's partner access model. LinkedIn's official APIs are the correct product when LinkedIn has to approve what you build. Partner and MDP processes gate access. That is the right path for products that act as a LinkedIn-connected app, not for "look up any public /in/… card for CRM enrichment" research jobs. First-party ToS path when you qualify. Stable docs for the surfaces you are allowed to call. Fine for member OAuth flows you already run. Access is not "sign up and GET any profile." Many enrichment use cases never get the scopes teams assume exist after watching a general "LinkedIn API" tutorial. Expect review timelines. Use it when ownership and compliance require LinkedIn partner access. Supplement or replace it for public enrichment volume if you never get (or should not apply for) those scopes. 3. Enrich Layer — LinkedIn-only continuity after Proxycurl Good fit for teams that need the lowest-effort migration off Proxycurl and whose roadmap is LinkedIn enrichment only. Proxycurl shut down in July 2025 after LinkedIn litigation. Enrich Layer positions itself for former customers: similar endpoints, key/credit carryover for many users, base URL change. If wire compatibility beats multi-platform breadth, evaluate that path first. Explicit migration story. LinkedIn-deep focus. Less remap work if your clients already speak Proxycurl-shaped requests. You are still concentrating enrichment risk on one network and one operator lineage. Field depth and people-search behavior are not identical to Social Fetch. Compare against your actual payloads, not nostalgia for old Proxycurl rate cards. Right for LinkedIn-only stacks that refuse a schema remap. Wrong as your only integration if TikTok or Instagram is next quarter. Longer migration notes: Social Fetch vs Proxycurl. 4. Apify — LinkedIn Actors for custom and batch work Good fit for scheduled profile dumps, niche field extraction, and scrapers you want to configure as Actors rather than maintain as a fleet of browsers. Apify hosts many LinkedIn Actors (profile, company, posts, jobs, sales-adjacent scrapers). You start a run, poll, download a dataset. Schemas differ by Actor author. Billing mixes compute and event fees; monthly plan credits expire. Marketplace breadth. Good when no managed REST route exposes the field you need. Scheduling is built into the platform. You are buying a runtime, not one LinkedIn schema. Actor quality varies. Sync product UIs that need a single HTTP round trip fit poorly. LinkedIn anti-bot pressure hits Actor authors unevenly. Right for batch and custom scrapes. Wrong as your only integration if you want one typed client for person + company in a request handler. 5. Bright Data and Oxylabs — enterprise infrastructure Good fit for high-volume teams with budget for proxy networks, dataset pipelines, and sales-led contracts. Overkill for a product engineer who only needs public /in/… JSON in an onboarding flow. These vendors sell unblock and collection infrastructure. LinkedIn scrapers and dataset products exist on top of residential IPs, browser farms, and async exports. You are buying a platform with spending limits, domain tiers, and procurement cycles that large data orgs already understand. Social scraper list prices commonly land in a rough ~$2.50–$3.70 per 1,000 records band depending on product page and commitment (verify current Bright Data / Oxylabs quotes before you budget). Floors and spending caps matter as much as the unit rate: hit a cap on launch day and requests stop until someone with admin access raises the limit. Hard-target reliability when volume justifies the stack. SLAs and legal processes enterprises already staff for. Warehouse delivery patterns that sync REST does not try to replace. No unified multi-social schema by default. You still own parsers unless you buy a higher-level dataset product. Justified when volume and hard-target success rates dominate the spreadsheet. Wrong shape for a startup shipping CRM enrichment on public pages. See Social Fetch vs Bright Data. 6. PhantomBuster — automation studio, not a data API Good fit for growth and sales ops that need cloud browser playbooks (scrapes into Sheets, outreach sequences), billed in execution hours and slots. PhantomBuster is easy to put on "LinkedIn API" lists because LinkedIn Phantoms are popular. The product is automation runtime. Paid plans expose an API to drive those automations. You still think in hours, slots, and exports, not one credit per typed profile response. Pre-built sales workflows. Fine when a human or ops tool owns the pipeline. Awkward inside a SaaS request handler that needs 500 profile cards during onboarding. Export caps on free/trial tiers. Wrong abstraction if you only wanted JSON. Keep it for outreach playbooks. Do not use it as your production LinkedIn enrichment API. Longer take: Social Fetch vs PhantomBuster. 7. RapidAPI LinkedIn listings — browse, then graduate Good fit for finding a niche LinkedIn endpoint over a weekend without signing an enterprise contract or a partner deal. RapidAPI hosts third-party LinkedIn scrapers under one billing dashboard. Discovery is the product strength: pick a listing, hit the test console, see whether the JSON looks like a person card or a half-parsed HTML dump. Prototypes move fast because you are not waiting on Marketing Developer Platform review. LinkedIn is a hard target. Listing quality varies more than on softer networks, and anti-bot pressure hits publishers unevenly. Production teams that stitch three LinkedIn marketplace APIs usually inherit three schemas, three rate limits, and three places a publisher can vanish after a ToS scare. Multi-platform enrichment (LinkedIn plus Instagram plus TikTok) multiplies that into separate subscriptions. Marketplace scrapers often price in the rough $2.50–$4+ per 1,000 range per listing. Treat that as a starting guess and verify the publisher before you promise CRM volume. Fast shopping. Low commitment for a one-weekend experiment. Fine if LinkedIn is a tiny input among many unrelated RapidAPI line items. Person vs company vs job endpoints may be separate listings with incompatible shapes. Support tickets route through a middleman. Proxycurl-style shutdown risk exists for any single LinkedIn-only publisher sitting on a marketplace shelf. Keep it for exploration. Prefer a first-party public-data API (or Enrich Layer for LinkedIn-only Proxycurl continuity) when enrichment is load-bearing. Longer take: Social Fetch vs RapidAPI. Official API vs public enrichment Most "LinkedIn API" comparisons bury this fork. In 2026 it decides the vendor list before pricing does. If you want the access-friction version of the same decision, read LinkedIn partner API vs public data. For DIY vs partner/MDP vs Social Fetch with runnable GETs, see How to scrape LinkedIn data. | Need | Prefer | | --- | --- | | Member OAuth, LinkedIn-approved app features | Official partner / MDP APIs | | Public /in/… or /company/… card for CRM enrichment | Managed public-data REST (Social Fetch, Enrich Layer, etc.) | | Nightly custom scrape with odd fields | Apify Actor | | Sales outreach sequences in the browser cloud | PhantomBuster | | One person URL, no API key yet | /tools/linkedin-profile-viewer | Social Fetch only returns publicly visible data. Content gated beyond public visibility is out of scope. Official APIs do not magically unlock "any profile on the internet" either. They unlock what LinkedIn authorizes for your app and members. Edge cases on our side: pass a company URL into the person profile route and you will not get a company card. Use GET /v1/linkedin/companies or GET /v1/linkedin/organizations for the right page type. Branch on lookupStatus before you upsert. Which API fits which job Multi-platform enrichment product, sync JSON → Social Fetch (LinkedIn hub) LinkedIn partner / member-authorized app → Official LinkedIn APIs Proxycurl-shaped LinkedIn-only migration → Enrich Layer first; Social Fetch if you are rebuilding anyway Nightly scrape with custom fields → Apify Actor Enterprise proxy volume → Bright Data or Oxylabs Outreach automation playbooks → PhantomBuster One-off person profile in the browser → /tools/linkedin-profile-viewer If you only need LinkedIn today but Instagram next quarter, pick the option whose envelope you can reuse. Rewriting parsers per platform is where most "cheap" LinkedIn APIs get expensive. Questions before you buy 1. Do you need member-authorized scopes, or public enrichment? That fork decides official vs third-party first. 2. Person, company, job, or Ad Library? Confirm the vendor has separate, documented paths, not one HTML dump. 3. Will people/job search latency fit your UI? Some search routes take well over a minute. Product handlers that need sub-second cards should not share a path with deep search. 4. Sync or batch? Product request handlers prefer sync. Overnight dumps can live on Actors or datasets. 5. One schema across platforms? Call LinkedIn and TikTok with the same parser. If you need if (platform === "linkedin") for basic identity fields, you do not have unification. 6. Do credits expire? Spiky enrichment workloads hate monthly resets. 7. What is your single-vendor LinkedIn risk? Ask what you do if this provider disappears the way Proxycurl did. 8. Can you preview without shipping? Use a playground, free credits, or the free LinkedIn profile viewer before you lock a vendor. Frequently asked questions What is the best LinkedIn Data API in 2026? For public sync REST with people, companies, posts, jobs, Ad Library, and search, and the same envelope as other social platforms, Social Fetch is my pick. I built it. LinkedIn's official APIs win for partner and member-authorized work. Enrich Layer wins for lowest-effort Proxycurl migration when LinkedIn is the only network. Apify wins for custom Actors. PhantomBuster wins for sales automations. Is there an official free LinkedIn API for any public profile? LinkedIn's developer products are built around authorized apps and approved use cases, not an open "GET any /in/… URL" enrichment free-for-all. For public-page enrichment without partner access, teams use third-party public-data APIs. Read LinkedIn's Terms and talk to counsel for your jurisdiction. Can I get LinkedIn company pages via API? Yes on Social Fetch: GET /v1/linkedin/companies with a public company URL (1 credit on a completed lookup). Schools and other organization page types use GET /v1/linkedin/organizations (2 credits per URL requested). Details: /platforms/linkedin. LinkedIn scraper API vs LinkedIn official API — which should I use? Use the official API when you need LinkedIn's auth model and partner features. Use a managed public-data API when you need enrichment of publicly visible pages without Marketing Developer Platform access. Scrapers and Actors fill gaps neither covers; they also shift maintenance and compliance risk onto you. Step-by-step DIY vs partner/MDP vs Social Fetch, including metered people search: How to scrape LinkedIn data. What happened to Proxycurl? Proxycurl shut down in July 2025 after LinkedIn litigation. Enrich Layer is the common continuity bet for LinkedIn-only stacks. Social Fetch is a separate multi-platform rebuild option. See Social Fetch vs Proxycurl. Does Social Fetch require a LinkedIn partner app? No. You need a Social Fetch API key. We return publicly visible LinkedIn data for enrichment-style lookups. Route list: /platforms/linkedin. Smoke-test a person or company URL in the playground, or start with 100 free credits on pricing. For one public person profile without an API key, open the free LinkedIn profile viewer. Partner vs enrichment path: LinkedIn partner API vs public data.
---
# Best Reddit APIs in 2026: official vs REST
Source: https://www.socialfetch.dev/blog/best-reddit-data-apis-2026
# Best Reddit APIs in 2026: official vs REST
Compare Reddit APIs for subreddits, posts, comments, and search — official Reddit pricing vs Social Fetch, Apify, PRAW, and scrapers.
**Read on the site:** https://www.socialfetch.dev/blog/best-reddit-data-apis-2026
"Reddit API" or "Reddit Data API" usually means Reddit's own OAuth product. Teams shopping those phrases often need one of three things: a compliant Reddit client under Reddit's terms, public enrichment without waiting on commercial approval, or bulk scrapes that outgrow a free 100 QPM ceiling. Those are different products. Mixing them up is how you end up fighting an approval ticket for a brand-monitoring job, or paying Actor runtime fees for a single keyword search your UI could await in one HTTP call. For official commercial rates vs prepaid public lookups, see Reddit API pricing. This is a pricing and coverage comparison for May 2026. Re-check each vendor's pricing page before you commit budget. Social Fetch is my pick for sync REST over public Reddit subreddits, posts, comments, and search, especially if you already normalize social data across TikTok, Instagram, and YouTube. Prefer Reddit's official Data API when you need first-party compliance for a Reddit-centric product and you can clear their access process. Prefer Apify when you need a custom Actor or a scheduled batch dump. Prefer PRAW when you are fine hosting OAuth yourself for a personal or approved non-commercial script. The short list 1. Social Fetch — sync REST for public Reddit data, same envelope as other platforms 2. Reddit Data API (official) — first-party OAuth route when compliance and Reddit's access model matter 3. Apify Reddit Actors — marketplace scrapers when you need custom fields or scheduled runs 4. PRAW — Python wrapper over the official API that you host yourself 5. RapidAPI Reddit listings — discovery marketplace, not one production contract 6. Pushshift-style archives — historical dumps and third-party mirrors; not a live product API | Option | Best for | Sync REST | Live search | Starting cost | | --- | --- | --- | --- | --- | | Social Fetch | Public enrichment + multi-platform apps | Yes | Yes | 100 free credits, then PAYG | | Reddit Data API | Official ToS path, owned Reddit clients | Yes (OAuth) | Yes | Free non-commercial / commercial contract | | Apify Actors | Custom scrapes, batch schedules | Poll runs | Via Actors | ~$5/mo free credit, then plans | | PRAW | Scripts on top of official OAuth | Library | Yes | Your infra + Reddit access | | RapidAPI listings | Prototyping niche endpoints | Varies | Varies | Per listing | | Archives / mirrors | Historical research, offline dumps | No | Partial / stale | Free or mirror-dependent | Full Reddit route list and examples live on the Reddit platform page. For product-feedback workflows, see the Reddit research use case. Pricing deep dive: Reddit API pricing. Keys and rate limits: How to get a Reddit API key. How I rank Reddit data APIs I care about production behavior, not landing-page adjectives: 1. What you can actually call — subreddit metadata, feeds, keyword search, comment trees, video transcripts. Count real paths, not "Reddit support" on a marketing grid. 2. Access gate — instant API key vs OAuth app approval vs commercial sales review. Reddit's free tier is not the same as "open signup for commercial monitoring." 3. Quota vs credits — official free access is rate-limited (commonly 100 queries per minute per OAuth client for approved non-commercial use). Credit APIs trade that for prepaid lookups; know which meter you are buying. 4. Sync vs async — one HTTP response you can await in a product request, or start-a-run / poll-a-dataset. 5. Comment depth — product feedback lives in replies. If the provider only returns post titles, you still need a second tool. 6. Error shape — typed outcomes and a requestId beat silent empty HTML. 7. Multi-platform tax — if your app already pulls TikTok and Instagram, does Reddit force a second schema and a second vendor? 8. Compliance fit — official API for Reddit-centric products under Reddit's terms; third-party public-data APIs for enrichment. Read Reddit's Terms for your use case. I am not your lawyer. Ranked picks 1. Social Fetch — public Reddit over one REST key _Best for: product teams and agents that need public subreddit cards, feeds, search, comments, and transcripts without a Reddit OAuth project, and that already (or soon will) pull other social platforms._ Social Fetch exposes first-party Reddit routes under /v1/reddit/*: subreddit lookup, subreddit posts, subreddit-scoped search, global post search, comment trees, and post transcripts. Responses use the shared envelope. Pagination uses data.page.nextCursor / data.page.hasMore the same way as other list routes, so a research job does not invent a Reddit-only cursor convention. Sync GET routes cover the common path. Search and comments sit next to subreddit feeds (GET /v1/reddit/search, GET /v1/reddit/posts/comments). Every response includes meta.requestId and meta.creditsCharged. One API key covers TikTok, Instagram, YouTube, and the rest of the catalog. Signup includes 100 free credits with no card; PAYG packs do not expire. Subreddit names stay case-sensitive (r/SaaS ≠ r/saas), which matches Reddit's actual URLs. This is public enrichment, not Reddit's authenticated inbox, mod tools, or private subreddits. Each search page and each comment page is a separate credit charge, so a 200-thread sprint adds up. Read meta.creditsCharged and set job caps before you promise volume. Credits charge on completed lookups: empty search results still bill because the lookup finished. Upstream pressure that returns 503 temporarily_unavailable does not. See credits for the full rule. Pricing: Free (100 credits) → Starter $14 (1,000) → higher packs on pricing. Verdict: My default when Reddit is one surface in a multi-platform product, or when you want keyword search and comment trees without Reddit commercial approval. See the Reddit hub for the full route list. Deeper sprint patterns: Reddit product research guide. Credit math vs official commercial rates: Reddit API pricing. 2. Reddit Data API (official) — official when you need official _Best for: apps that are Reddit clients under Reddit's terms, moderator tooling, approved non-commercial bots, or commercial products that clear Reddit's partner / Data API process._ Reddit's Data API is the correct product when first-party compliance is non-negotiable. Free access for approved non-commercial use is rate-limited (commonly cited as 100 queries per minute per OAuth client). Commercial use is a different path: manual review, contract terms, and published per-call rates that teams often quote around $0.24 per 1,000 API calls when commercial access is granted. Self-service app registration has tightened; treat approval delay and rejection risk as part of the cost, not an edge case. First-party ToS path. Stable OAuth model for bots and Reddit-native features. Fine when your product is a Reddit client. The free tier is not a commercial monitoring entitlement. Rate limits and listing page sizes (often capped around 100 items) shape architecture. Commercial pricing and approval are not "flip a switch on a pricing page." Scrapers that ignore Reddit's API are a different risk category than calling Reddit's endpoints with an approved client. Verdict: Use it when ownership and compliance require Reddit. Supplement or replace it for public enrichment and multi-platform research if approval, commercial eligibility, or rate-limit math fails your product. 3. Apify — Reddit Actors for custom and batch work _Best for: scheduled subreddit dumps, niche field extraction, and scrapers you want to configure as Actors rather than maintain as a fleet of browsers._ Apify hosts many Reddit Actors (subreddit scrapers, comment extractors, search-style crawlers). You start a run, poll, download a dataset. Schemas differ by Actor author. Billing mixes platform subscription, compute, and per-event fees; monthly plan credits expire. Per-result cost depends on the Actor. Model the listing you will actually run, not a generic marketplace average. Marketplace breadth is the draw when no managed REST route exposes the field you need. Scheduling and dataset export are built into the platform. You are buying a runtime, not one Reddit schema. Actor quality varies. Sync product UIs that need a single HTTP round trip fit poorly. Pricing: Free (~$5/mo platform credit) → Starter and higher monthly plans. See Social Fetch vs Apify. Verdict: Right for batch and custom scrapes. Wrong as your only integration if you want one typed client for search + comments in a request handler. 4. PRAW — official API with a Python wrapper _Best for: research scripts and bots that already have (or can get) Reddit OAuth credentials and prefer a library over raw HTTP._ PRAW is not a hosted data API. It wraps Reddit's official endpoints. You still need Reddit access, still hit Reddit rate limits, and still own breakage when Reddit changes policy. For personal and approved non-commercial scripts it is often the cleanest path: mature Python DX, close to Reddit's object model, and no third-party credit meter sitting between you and Reddit. For a product that also pulls TikTok next quarter, it solves only the Reddit half. Commercial monitoring still faces the same approval and pricing gates as calling Reddit's Data API directly. PRAW does not unlock a free commercial entitlement. Same access gates as the official API. No Social Fetch-style multi-platform envelope. Hosting, secrets, retries, and customer-facing SLAs are yours. Verdict: Keep it for Reddit-only scripts under official access. Prefer a managed public-data API when customers wait on your HTTP response and Reddit is one of several sources. 5. RapidAPI Reddit listings — browse, then graduate _Best for: finding a niche Reddit endpoint over a weekend without signing an enterprise contract or waiting on Reddit commercial review._ RapidAPI aggregates third-party Reddit scrapers. The marketplace model is the same as everywhere else: one billing UI, many publishers, no shared schema. You can try several "Reddit search" listings in an afternoon and keep the one whose JSON looks least cursed. That is a reasonable exploration path. It is a weak production path for brand monitoring. Comment trees, pagination, and search freshness vary by publisher. Adding Instagram or TikTok beside Reddit means more listings and more adapters. When a scraper breaks after a Reddit HTML change, support often routes through RapidAPI to a maintainer you never met. Expect marketplace social pricing to wander by listing (commonly cited in a rough $2.50–$4+ per 1,000 band; verify before you model a research sprint). Fast discovery. Low commitment for a disposable prototype. Fine if Reddit is a tiny input next to other RapidAPI subscriptions you already pay for. No unified envelope. Publisher churn. Empty-result and rate-limit behavior differ per listing, which breaks naive "always retry" clients. Verdict: Keep it for exploration. Prefer a first-party sync API when search + comments sit in a product feature, or when Reddit must share a parser with other networks. Longer take: Social Fetch vs RapidAPI. 6. Pushshift-style archives — history, not live product glue _Best for: offline historical research and academic-style dumps when "what was said in 2019" matters more than "what was posted an hour ago."_ Pushshift was the default Reddit archive layer for researchers for years. Access models, mirrors, and successors have shifted repeatedly; some dumps live as torrents or third-party mirrors, others as research APIs with their own ToS and completeness gaps. Treat "Pushshift" as a category label for historical Reddit corpora, not as a single stable SaaS SKU you can put on a 2026 invoice without checking the mirror you trust. These sources fill gaps live APIs do not: deleted-post archaeology, long-range trend studies, offline bulk analysis. They are a poor substitute for production brand monitoring with freshness SLAs. Completeness, latency, and legal posture change often enough that building a customer-facing feature on an unverified mirror is how research scripts become outages. Historical depth live rate-limited APIs will not give you cheaply. Useful for one-off academic or internal analysis jobs. Stale indexes, missing fields, mirrors that disappear. No charge-on-completed-lookup credit meter and no production support contract. You own verification. Verdict: Useful for history. Prefer a live managed API for brand mentions and product research that needs current threads. Official Reddit API tradeoffs Teams under-price the official path because "free tier" sounds like "we can ship monitoring." In 2026 the practical splits look like this: | Need | Official Reddit Data API | Social Fetch (public) | | --- | --- | --- | | Reddit client / mod tools under Reddit ToS | Yes | No — wrong product | | Commercial brand monitoring without Reddit partner deal | Hard / gated | Common path | | Same schema as TikTok / Instagram | No | Yes | | Instant self-serve key for enrichment | Often no | Yes | | Private subreddits / user inbox | Per Reddit scopes | No — public only | | Cost model | QPM + commercial contract | Credits per completed lookup | If your lawyer and Reddit's commercial team say you need the official API, use it. If you are building a research feature that already standardizes on Social Fetch for other networks, Reddit's OAuth approval queue is usually the expensive part, not the JSON parse. Research and brand mentions without a key Most "Reddit API" comparisons skip the one-off paste-and-copy job. Before you wire keys, try the free browser tools that hit the same production search endpoint: Free Reddit research tool — topic and audience queries (sort + timeframe filters) Free brand mention checker — brand/competitor spot checks (defaults toward recent mentions) Same underlying GET /v1/reddit/search data. Different defaults for the job. Free pages are rate-limited (1/min · 3/hour · 10/day per IP, plus Turnstile) and return the first page only. Paginate with a cursor on the API when you need volume or a schedule. For a full research sprint (query matrix, subreddit mapping, comment trees), use the Reddit research use case and the product research guide. Which API fits which job Multi-platform product feature, sync JSON → Social Fetch (Reddit hub) Reddit-native client / official compliance → Reddit Data API Nightly subreddit scrape with custom fields → Apify Actor Approved personal bot in Python → PRAW on official OAuth One-off topic or brand search in the browser → /tools/reddit-research or /tools/brand-mention-checker Historical archive research → dumps / mirrors (verify freshness) If you only need Reddit today but Instagram next quarter, pick the option whose envelope you can reuse. Rewriting parsers per platform is where most "cheap" APIs get expensive. Questions before you buy 1. Do you need Reddit's official access model, or public enrichment? That fork decides first-party vs third-party first. 2. Is your use commercial? Free non-commercial Reddit access does not cover brand monitoring products by default. 3. Will search + comment pagination fit your budget? Model per-page costs before you promise "pull every reply." 4. Sync or batch? Product request handlers prefer sync. Overnight dumps can live on Actors. 5. One schema across platforms? Call Reddit and TikTok with the same parser. If you need if (platform === "reddit") for every field, you do not have unification. 6. Do credits expire? Spiky research sprints hate monthly resets. 7. Can you preview without shipping? Use a free tool, playground, or free credits before you lock a vendor. Frequently asked questions What is the best Reddit Data API in 2026? For public sync REST with subreddits, posts, comments, and search, and the same envelope as other social platforms, Social Fetch is my pick. I built it. Reddit's Data API wins for official Reddit-centric work. Apify wins for custom Actors. PRAW wins for Python scripts already on official OAuth. Is the official Reddit API free? There is a free tier for approved non-commercial use, commonly rate-limited around 100 queries per minute per OAuth client. Commercial use is a separate approval and pricing path (teams often cite ~$0.24 per 1,000 calls when commercial access is granted). Treat "free" as a constrained personal/research allowance, not unlimited production monitoring. Walkthrough: How to get a Reddit API key. Full cost models: Reddit API pricing. Can I search Reddit and pull comments via API? Yes. Social Fetch: GET /v1/reddit/search for keyword search; GET /v1/reddit/posts/comments for a post URL's comment tree. For a single query in the browser, use /tools/reddit-research or /tools/brand-mention-checker. Official Reddit API vs Reddit scraper API — which should I use? Use the official API when you need Reddit's auth model and first-party compliance. Use a managed public-data API when you need enrichment without Reddit commercial approval, or when multi-platform schema and sync REST ergonomics matter more than Reddit-native scopes. Scrapers and Actors fill gaps neither covers; they also shift maintenance and compliance risk onto you. Does Social Fetch require a Reddit app client ID? No. You need a Social Fetch API key. Details and route list: /platforms/reddit. Can I access private subreddits? No on Social Fetch. Only publicly visible communities and content. Official Reddit scopes are a different product for authenticated access you are authorized to use. Smoke-test a search in the playground, or start with 100 free credits on pricing. For one query without an API key, open the free Reddit research tool or the brand mention checker. Recipe for a listening pulse: Reddit research. Glossary: Does Reddit have an API?.
---
# Best social media scraping APIs in 2026
Source: https://www.socialfetch.dev/blog/best-social-media-scraping-apis-2026
# Best social media scraping APIs in 2026
Compare social scraping APIs side-by-side — schemas, pricing, and coverage. Social Fetch vs Apify, Bright Data, and more.
**Read on the site:** https://www.socialfetch.dev/blog/best-social-media-scraping-apis-2026
Every social media scraping API (and most "social media API" listings) claims a consistent format. Then you wire up TikTok, Instagram, and YouTube and get back followerCount, edge_followed_by.count, and statistics.subscriberCount for the same field. You write three parsers for one dashboard column. I have been building scrapers long enough to know that pain. The APIs in this list are not interchangeable. Some are proxy farms, some are actor runtimes, some are first-party REST products. The useful ones return the same JSON shape across platforms so your integration code does not branch per site. This is a pricing and coverage comparison for January 2026. Re-check each vendor's pricing page before you commit budget. Where I could not verify a number live, I say so. Social Fetch ranks first here because it is a synchronous REST API with one envelope, normalized profile fields across 20 platforms, 154 documented marketplace operations, and pay-as-you-go credits that never expire (optional monthly plans for steady volume). We charge on completed lookups; not_found still bills, lookup_failed does not. We do not ship server-side engagement_rate math. You get raw metrics and compute what you need. The 10 best social media scraping APIs at a glance 1. Social Fetch — my pick for multi-platform REST with a unified schema and MCP tooling 2. SociaVault — simple pay-as-you-go for a handful of core social platforms 3. Apify — largest actor marketplace when you need custom scrapers 4. Bright Data — enterprise proxy and dataset infrastructure at volume 5. ScraperAPI — general web scraping; weak on social-specific benchmarks 6. Smartproxy (Decodo) — proxy-first scraping for teams already at scale 7. Oxylabs — Fortune 500 SLAs and enterprise contracts 8. ProfileSpider — LinkedIn lead-gen via Chrome extension, not an API 9. Scrapfly — strong docs and single-platform scrapers 10. RapidAPI — marketplace discovery, not a single product | API | Best for | Platforms | Starting price | Free tier | | --- | --- | --- | --- | --- | | Social Fetch | Sync REST + unified schema | 20 | $14 / 1k credits | 100 credits, no card | | SociaVault | Simple PAYG | ~8 social (verify) | $29 / 6k credits | 50 credits | | Apify | Custom actors | 24,000+ actors | $29/mo | ~$5/mo credit | | Bright Data | Enterprise volume | ~10 social | ~$100/mo floor | Trial | | ScraperAPI | General web | General web | $49/mo | 1,000 credits | | Smartproxy (Decodo) | Proxy infra | Social via proxy | ~$0.08/1k req† | None | | Oxylabs | Enterprise SLAs | ~3 social | Custom | Trial on request | | ProfileSpider | LinkedIn UI export | LinkedIn only | Subscription | Unverified | | Scrapfly | Single-platform work | 7 social | $30/mo | 1,000 credits | | RapidAPI | API discovery | Varies | Varies | Varies | † Verify current Decodo pricing before committing. The ranked sections below go deeper on pricing, schema shape, and where each tool breaks down in production. What makes a good social media scraping API in 2026 I rank tools on criteria that matter once you leave the demo: 1. Platform coverage you can verify. Count endpoints in a public capability matrix or OpenAPI spec, not a landing-page number. 2. Unified schema. Does metrics.followers mean the same thing on TikTok and Instagram without an adapter layer? 3. Sync vs async. Can your UI or agent wait on one HTTP response, or do you poll a dataset? 4. Terminal errors. When a lookup fails, do you get a typed outcome and a requestId you can send to support? 5. Billing clarity. Do you pay on completed lookups? Does not_found still charge? Does lookup_failed? 6. AI-agent readiness. MCP or OpenAPI tooling, deterministic JSON, documented rate limits. 7. Benchmark success on hard targets. Proxyway's 2025 Web Scraping API Report tested 11 providers on 15 protected sites; only four cleared 80% overall success. Social-specific numbers vary. Ask before you build. What a unified schema looks like in practice Same creator, three native APIs, three different field names: | Field | TikTok native | Instagram native | YouTube native | Social Fetch unified | | --- | --- | --- | --- | --- | | Follower count | followerCount | edge_followed_by.count | statistics.subscriberCount | metrics.followers | | Handle | uniqueId | username | customUrl | profile.handle | | Bio | signature | biography | description | profile.bio | Social Fetch normalizes those into one shape. Swap the platform segment in the path; the parser stays the same. We do not pre-compute engagement_rate or estimated_reach on profile routes. You get raw counts; your warehouse or agent does the math. If you only need Instagram engagement once, we have a free browser tool; the API is for volume. Try the response shape in the playground before you buy a credit pack. Full comparison matrix | Tool | Platforms | Endpoints | Unified schema | Pre-computed engagement | Pricing | Free tier | Playground | MCP | | --- | --- | --- | --- | --- | --- | --- | --- | --- | | Social Fetch | 20 | 154 | Yes | No (raw metrics) | PAYG (never expires) + optional plans | 100 credits | Yes | Yes | | SociaVault | ~8 social | — | Partial | No | PAYG | 50 credits | No | No | | Apify | 24,000+ actors | — | No (per actor) | No | Monthly + compute | ~$5/mo | No | Partial | | Bright Data | ~10 social | 68 | No | No | Enterprise tiers | Trial | No | No | | ScraperAPI | General web | — | No | No | Monthly | 1,000 credits | No | Partial | | Smartproxy | Social via proxy | — | No | No | PAYG minimums | No | No | No | | Oxylabs | ~3 social | — | No | No | Enterprise | Trial | No | No | | ProfileSpider | LinkedIn | — | — | No | Subscription | Unverified | UI only | No | | Scrapfly | 7 social | — | No | No | Monthly | 1,000 credits | No | No | | RapidAPI | Varies | — | No | No | Per listing | Varies | No | No | ScraperAPI note: Proxyway's 2025 Web Scraping API Report reported 0% success on Instagram and Twitter/X for ScraperAPI specifically, while the provider averaged 63.7% overall across all tested sites. Fine for Amazon; risky as a primary social API. SociaVault platform count: Their marketing mentions 25+ sources including ad libraries and shops. Head-to-head social platform coverage is closer to eight. Verify on their pricing page before you plan a multi-platform rollout. Ranked — the 10 best social media scraping APIs 1. Social Fetch — unified REST across 20 platforms Best for product teams and agents that need TikTok, Instagram, YouTube, X, LinkedIn, and the rest in one integration without adapter code. Social Fetch is a first-party REST API. One API key, one credit balance, one envelope on every route. We document 154 marketplace operations across TikTok, Instagram, YouTube, X, LinkedIn, Facebook, Reddit, Threads, Bluesky, Rumble, Twitch, Telegram, Linktree, Hacker News, Truth Social, Spotify, GitHub, Pinterest, Google Ad Library, and Web extraction. Same field names on profiles across platforms (profile.handle, profile.bio, metrics.followers). JSON back in about three seconds on average, with no actor run polling. Every response carries meta.requestId so support can trace your call. The MCP server exposes one tool per public route plus docs search. Signup includes 100 free credits, no card. PAYG pack credits never expire. The TypeScript SDK aligns to route names. Watch for: 20 platforms, not forty. Check the capability matrix before you assume Snapchat is covered. No native batch pipelines or webhooks. Engagement rate and reach estimates are your job. Heavier routes (Twitter search at 2 credits) cost more than a simple profile lookup. Billing: we charge on completed lookups. A 200 with lookupStatus: not_found still ran upstream and bills; read meta.creditsCharged. We do not charge lookup_failed or 503 temporarily_unavailable. Pre-send validation errors (bad URL, missing param) never touch your balance. Pricing: Free (100 credits) → Starter $14 (1,000 credits) → Growth $47 (25,000) → Scale $379 (230,000, about $1.65 per 1,000). See pricing. The right call if you want multi-platform social JSON in one request thread and you are tired of maintaining per-platform parsers. 2. SociaVault — simple pay-as-you-go for core platforms Best for a small set of mainstream platforms and the lowest-friction REST API you can get running in an afternoon. SociaVault is credit-based PAYG like Social Fetch. Their platform list is smaller. Treat "25+" marketing as including ad libraries and adjacent sources; social coverage is roughly eight platforms (verify on sociavault.com before you commit). PAYG credits never expire. Straight REST. Low entry price at $29 for 6,000 credits. Schema normalization is partial. No MCP. No playground in the same sense as a first-party API explorer. Pricing: Free (50 credits) → Starter $29 / 6k → higher tiers on their site. Reasonable if you only need a few platforms and can live with per-platform field differences. 3. Apify — actor marketplace at scale Best for custom scrapers, scheduled batch jobs, and browser automation you control. Apify is a scraper runtime, not a social API. You pick an Actor (Clockworks TikTok Scraper, community Instagram Actors, your own Puppeteer script), configure input JSON, start a run, poll, download a dataset. Each Actor returns its own schema. The marketplace is huge. MCP exists in their ecosystem. SOC2 and enterprise customers. Open-source Crawlee library. Schema varies by Actor author. Billing mixes per-event fees and compute units. Credits expire monthly on paid plans. Pricing: Free (~$5/mo platform credit) → Starter $29/mo → Scale tiers. TikTok profile events from Clockworks run about $3.70+ per 1,000 results at published rates. See our Apify comparison. Pick Apify when you need a niche scraper that does not exist as a managed API. Accept that normalization is your problem. 4. Bright Data — enterprise infrastructure Best for high-volume teams with budget for proxy networks, spending limits, and sales-led contracts. Bright Data sells proxy infrastructure and dataset pipelines. Social scrapers exist, but you are buying a platform: residential IPs, browser farms, async exports. That is not a product engineer's REST API. Top-tier reliability on difficult targets in independent benchmarks. Legal track record in public-data scraping cases. No unified social schema. Spending limits from about $100/month. Pricing pages vary by product line ($2.50–$3.70 per 1,000 records is a common range for social tiers). Verify on brightdata.com. Right when benchmark success on hard targets justifies cost and complexity. Overkill for a startup shipping a creator dashboard. See Social Fetch vs Bright Data for a worked TikTok pricing scenario. 5. ScraperAPI — general web, weak on social Best for e-commerce and general web targets. I would not pick it as a primary Instagram or X API. ScraperAPI rotates proxies and handles CAPTCHAs for generic URLs. Proxyway's 2025 report logged 0% success on Instagram and Twitter/X for this provider. LinkedIn requests can burn 30+ credits each with rendering enabled, and the hobby plan math gets ugly fast. Simple for Amazon, Zillow, and similar. LangChain docs exist. Social endpoints specifically are the weak spot. Monthly credit expiry. Multipliers on hard domains. Pricing: Free (1,000 credits) → Hobby $49/mo → higher tiers on scraperapi.com. Use it for web scraping. Look elsewhere for social-first production pipelines. 6. Smartproxy (Decodo) — proxy-first Best for teams that already run proxy infrastructure and want social endpoints on top. This is proxy infrastructure, not normalized social data. You get raw HTML or JSON from the target. Decodo scored in the top four on Proxyway's overall benchmark, which measures reliability on hard sites, not how pleasant the developer experience is. Minimum request commitments apply, and third-party price comparisons drift quickly, so verify on decodo.com before you commit. Buy it when you need proxies; look elsewhere if you need one JSON schema across platforms. 7. Oxylabs — enterprise reliability Best for large organizations with SLA requirements and procurement cycles. Oxylabs covers roughly Instagram, TikTok, and LinkedIn with dedicated scrapers plus general web products. Same category as Bright Data: enterprise infra, custom quotes, trial on request. Benchmark performance with other top-tier providers. Minimal self-serve. No unified social schema. Not where I would send a two-person startup. Justified at Fortune 500 scale. Heavy for most developer evaluations. 8. ProfileSpider — LinkedIn UI tool ProfileSpider is a Chrome extension for recruiters who export LinkedIn profiles from the browser. It lands on "scraping API" lists through keyword overlap, but there is no endpoint to call from your backend. Skip it for product work; it is fine for manual lead-gen when a CSV from the UI is enough. 9. Scrapfly — capable single-platform scraping Best for one platform at a time with strong technical documentation. Scrapfly publishes open-source scrapers for seven platforms and updates engines frequently. Multi-platform work still means multiple schemas unless you pay for their LLM extraction layer on top. Documentation quality is high. Active maintenance. Credits expire monthly. Normalization is on you. Pricing: Free (1,000 credits) → Discovery $30/mo → higher tiers on scrapfly.io. Good YouTube-or-TikTok-only project pick. Not where I would standardize a multi-platform agent. 10. RapidAPI — discovery, not production glue Weekend prototypes benefit from RapidAPI's catalog: you can find a niche TikTok or Instagram endpoint fast, without signing an enterprise contract first. That speed stops helping once you need three listings with three schemas, three billing accounts, and three support chains for one dashboard. Keep it for exploration. See Social Fetch vs RapidAPI when you outgrow the marketplace model. Which API fits which workflow Multi-platform product feature with the same JSON shape: Social Fetch. Eight core platforms and the simplest PAYG: SociaVault. Custom Actor, batch cron, browser control: Apify. Enterprise proxy volume and procurement budget: Bright Data or Oxylabs. LinkedIn CSV from a browser: ProfileSpider (different category). Agent calling social APIs: Social Fetch MCP plus unified schema. Agents break when field names change per platform. One tool definition should map to metrics.followers everywhere, not three conditional branches. If you only need TikTok profiles today, start with 100 free credits and one endpoint. Add Instagram next week with the same key and the same envelope. Seven questions before you buy 1. How many platforms are actually covered? Open the endpoint list. Ad libraries and shops are not Instagram. 2. One schema or many? Call two platforms with the same parser. If you need if platform === 'instagram', you do not have unification. 3. Who computes engagement metrics? Raw counts vs server-side rates. Know which you are buying. 4. What bills on a completed lookup? Wrong handle and deleted posts often still cost credits on managed APIs. Ask whether lookup_failed is free. 5. Do credits expire? Monthly resets change real cost for spiky workloads. 6. Can you preview responses without shipping code? Use a playground or free tier before you promise a ship date. 7. What are Instagram and X success rates? Ask for benchmark data. Zero percent on a platform you need is a project killer. Frequently asked questions What is social media scraping? Automated extraction of public profile, post, and engagement data from social platforms, usually via HTTP APIs that handle proxies, rendering, and rate limits for you. The alternative is maintaining your own scraper every time a platform changes its frontend. How does a social media scraping API work? You send a request with a handle or URL. The provider fetches public data, parses it, and returns JSON. A unified API normalizes field names so your code does not branch per platform. What are the best social media scraping APIs? For sync REST with a unified schema across 20 platforms, Social Fetch is my pick. I built it. Apify wins on custom Actors. Bright Data and Oxylabs win on enterprise infra. SociaVault is fine for a small platform set at low volume. ScraperAPI is better for general web than social specifically. Why use a unified social media API? You write one integration instead of ten parsers. I have watched teams burn a week normalizing Instagram's nested GraphQL shapes before they touch YouTube, then another week when TikTok field names drift. A single schema keeps your dashboard and agent tool definitions stable while you add platforms. What is the cheapest way to start? Social Fetch's 100 free credits (no card) and SociaVault's 50 free credits are the easiest zero-cost entry points. At volume, compare per-1,000 rates and check whether credits expire. Which API is best for TikTok? Social Fetch: GET /v1/tiktok/profiles/ returns normalized JSON with metrics.followers and charges one credit on a completed lookup (including not_found). Apify's Clockworks Actor is the main alternative when you need a custom extraction pipeline. Should I build my own scraper? Build your own for a one-off research script. Use a managed API for anything production. Maintenance usually costs more than credits within a few months. What about compliance? Read each platform's Terms of Service. Public-data scraping case law is evolving; GDPR still applies to EU personal data in commercial use. We are not lawyers. Treat compliance as your responsibility. See our docs and your counsel for jurisdiction-specific guidance. If you want to verify the Social Fetch claims in this post, paste a handle into the playground or grab 100 free credits on pricing. Spot-check without a key via the free tools hub. Platform-specific shortlists: TikTok scrapers, Instagram scrapers, YouTube transcript APIs, Twitter / X APIs, LinkedIn APIs, Reddit APIs, Facebook APIs, Truth Social APIs, Hacker News APIs. For Apify and Bright Data scenarios with worked numbers, use the compare hub.
---
# Best TikTok scrapers & data APIs in 2026
Source: https://www.socialfetch.dev/blog/best-tiktok-data-apis-2026
# Best TikTok scrapers & data APIs in 2026
Compare TikTok scrapers and data APIs for profiles, videos, Shop, search, and transcripts. Social Fetch vs EnsembleData, Apify, Bright Data, and more.
**Read on the site:** https://www.socialfetch.dev/blog/best-tiktok-data-apis-2026
TikTok does not publish a simple public REST catalog for arbitrary creators. Official developer products target apps that act on behalf of logged-in users: posting, login, partner programs. If you need a competitor's follower count, a creator's recent videos, a Shop product row, or a video transcript for a brand-safety pipeline, you are shopping for a TikTok scraper or third-party TikTok data API. I have maintained TikTok scrapers long enough to know the usual failure mode: signed request churn, region blocks, and selector rot mid-cron while the mobile app still loads fine. The APIs below are not interchangeable. Some are TikTok-heavy REST products, some are actor runtimes, some are proxy farms with social endpoints bolted on. The useful ones return typed JSON for profiles, videos, and search without making you own the anti-bot stack. This is a pricing and coverage comparison for March 2026. Re-check each vendor's pricing page before you commit budget. Where I could not verify a number live, I say so. Social Fetch is my pick when TikTok is one platform among several, or when you want sync REST with the same envelope as Instagram and YouTube. We document 24 TikTok operations inside 154 marketplace ops across 20 platforms. Profile lookups are usually 1 credit on a completed lookup. We ship raw metrics, not server-side engagement_rate. EnsembleData often wins on TikTok-only depth plus Snapchat. ScrapeCreators often wins on raw dollars per 1,000 at large packs. Apify and Bright Data win when you need custom Actors or enterprise proxy volume. Use official TikTok APIs when you need write access or private user data. The 6 best TikTok data APIs at a glance 1. Social Fetch: sync REST TikTok routes inside a 20-platform catalog 2. EnsembleData: TikTok-deep REST with daily unit subscriptions 3. ScrapeCreators: flat credit packs; often cheaper at large volume 4. Apify: actor marketplace when you need a custom TikTok scraper 5. Bright Data: enterprise proxy and dataset infrastructure 6. SociaVault: simple pay-as-you-go across a smaller social set | API | Best for | TikTok focus | Starting price | Free tier | | --- | --- | --- | --- | --- | | Social Fetch | Sync REST + multi-platform schema | Profiles, videos, comments, search, Shop, ads, transcripts | $14 / 1k credits | 100 credits, no card | | EnsembleData | TikTok-heavy volume | Deep TikTok endpoint catalog (~20 ops) | Bronze $200/mo | Trial units | | ScrapeCreators | Flat credit packs | Multi-platform social including TT | ~$47 / 25k credits† | 100 credits | | Apify | Custom Actors / batch | Actor-dependent (Clockworks et al.) | $29/mo + usage | ~$5/mo credit | | Bright Data | Enterprise volume | Dataset / scraper products | ~$1.50 / 1k records† | Trial / free records (verify) | | SociaVault | Simple PAYG | Core social including TT | $29 / 6k credits | 50 credits | † Verify on the vendor site before budgeting. Third-party roundups drift. For multi-platform context beyond TikTok, see 10 best social media scraping APIs in 2026. Sibling Instagram roundup: best Instagram data APIs. What makes a good TikTok data API I rank tools on criteria that matter after the demo: 1. Documented TikTok routes: profiles by handle, videos, comments, search, Shop, transcripts, ads. Count paths in a public docs index, not a landing-page claim. 2. Typed outcomes: private and missing accounts should return an explicit status, not an empty object that looks like a deleted creator. 3. Sync vs async: can your onboarding flow wait on one HTTP response, or do you poll a dataset run? 4. Pricing: credits that never expire vs daily unit resets; whether completed lookups bill (including not_found and private); surcharges for transcripts or media download. 5. Multi-platform tax: if next quarter adds Instagram and YouTube, do you keep one key and one parser? 6. Agent readiness: OpenAPI or MCP, deterministic JSON, a requestId you can paste into support. 7. TikTok success in the wild: ask for TikTok-specific reliability numbers before you build. General web scrapers are a different product. Official TikTok API vs third-party data APIs Use TikTok's official developer products when you need posting, login, or partner features on behalf of a user who authorized your app. That path is the right compliance story for first-party and write access. Use a third-party data API when the handle is not yours: competitor enrichment, creator CRM onboarding, public video transcripts, hashtag discovery, Shop product rows. Social Fetch and the other vendors in this list cover that public half. They do not replace official TikTok products for accounts you manage or content you publish. If a sales deck claims "official TikTok API access" for arbitrary public profiles, ask which TikTok product and which OAuth grant. Public enrichment and partner apps are different products. More context on /platforms/tiktok. TikTok pricing compared Every figure below is indicative for March 2026. Re-check before you buy. | Provider | Entry price | Effective TT profile rate | Free tier | Notes | | --- | --- | --- | --- | --- | | Social Fetch | $14 / 1,000 credits | 1 credit per profile GET (~$0.014 at Starter; ~$0.00165 at Scale) | 100 credits, no card; PAYG never expires | Charges on completed lookups; trust meta.creditsCharged | | EnsembleData | $200/mo Bronze | 1 unit for simple User Info inside a daily bucket | Trial units | Unused daily units reset at 00:00 UTC | | ScrapeCreators | ~$47 / 25k credits | Roughly ~$1.88 / 1k if 1 credit = 1 lookup; large packs ~$0.99 / 1k | 100 lifetime credits | Multi-platform; specialty routes cost more | | Apify | $29/mo + compute | Clockworks profiles often ~$3.70+ / 1k results | ~$5/mo platform credit | Schema and maintenance vary by Actor author | | Bright Data | Usage / enterprise | TikTok scraper listing often ~$1.50 / 1k successful records | Trial or free record allotments (verify) | Spending limits and sales-led contracts common | | SociaVault | $29 / 6k credits | Credit-based (verify TT route costs) | 50 credits | Smaller platform set than Social Fetch | Sticker price is not the whole decision. Daily unit resets, Actor compute surprises, and field-mapping work change real cost more than a $0.50 gap on a pricing table. Ranked picks 1. Social Fetch: TikTok inside a unified REST catalog _Best for: product teams and agents that need TikTok now and will add Instagram, YouTube, or LinkedIn without a second vendor._ Social Fetch is a first-party REST API. TikTok lives under /v1/tiktok/* with the same x-api-key, envelope, and credit balance as the rest of the catalog. We document 20 platforms and 154 marketplace operations. Inside TikTok alone that is 24 operations: profile cards, profile videos, followers and following, region and audience helpers, live checks, user / video / hashtag search, single video detail, comments and replies, transcripts, trending feed, song and music-video lists, Shop product / store / review / profile product-shelf routes, and Ad Library get / search. Full route list: /platforms/tiktok. Same field names as other platforms where the product allows it (profile.handle, metrics.followers). Explicit lookupStatus values (found, private, not_found) instead of silent empty payloads. meta.requestId and meta.creditsCharged on every response. MCP server with one tool per public route, plus Ask for plain-English routing. 100 free credits on signup; PAYG packs never expire. Browser tools for spot checks before you wire the API (see below). We return raw counts. Engagement rate is your job (or the free calculator), not a server-side computed field. We cover 20 platforms, not forty. Check the capability matrix before you assume Snapchat is covered; it is not. No native batch pipelines or webhooks. Transcripts and a few heavier routes document multi-credit costs; plain profile GETs stay at 1 credit on a completed lookup. Large ScrapeCreators packs can undercut Scale on dollars per 1,000 if price is the only axis. Pricing: Free (100 credits) → Starter $14 (1,000) → Growth $47 (25,000) → Scale $379 (230,000, about $1.65 per 1,000). Credits charge on completed lookups. Private and not-found profiles still bill when the lookup completes in the 200 body. Upstream 503 temporarily_unavailable responses are not charged on metered routes. See pricing. Verdict: The right call if TikTok is part of a multi-platform product and you want one parser. If you only ever need TikTok at maximum depth with Snapchat, read EnsembleData next. If you only care about the cheapest published $/1k at half a million credits, price ScrapeCreators packs against Scale. 2. EnsembleData: TikTok-deep REST with daily units _Best for: TikTok-centric pipelines that run steady volume every UTC day and already speak platform-native JSON._ EnsembleData is in the same lane as Social Fetch: synchronous GET, JSON body, API token. Their TikTok slice is deep (hashtag and keyword search, followers, music, live search, multi-depth post pagination; roughly twenty ops; verify current docs). Snapchat user info is on their list and not on ours. Billing is the real fork. Units sit inside a monthly plan with a daily allowance that resets at 00:00 UTC. Unused Monday units do not roll to Tuesday. A spike day that exceeds the daily cap fails until the next reset unless you upgrade. Bronze starts at $200/month for 5,000 units/day. TikTok endpoint depth is real. REST shape is familiar. Unit table in docs is clear. Daily reset economics hurt bursty jobs. Mostly native field names. No first-party TypeScript SDK or playground in the Social Fetch sense. Eight social platforms, not seventeen. Verdict: Win on TikTok-only depth and Snapchat. Lose on never-expire credits and unified multi-platform schema. Worked numbers: Social Fetch vs EnsembleData. 3. ScrapeCreators: flat credit packs _Best for: multi-platform social JSON with simple credit math and aggressive large-pack rates._ ScrapeCreators sells credit packs (commonly cited around $47 for 25,000 credits, roughly $1.88 per 1,000 if one credit equals one lookup; larger packs toward ~$0.99 per 1,000). TikTok sits alongside other social routes. The product is closer to Social Fetch's category than to a proxy farm. Both advertise credits that never expire and 100 free credits to start. Predictable pack pricing. Competitive large-pack floor. Social-native responses instead of raw HTML. Response contract and SDK surface are thinner. Solo-maintained vendors concentrate ops risk. Confirm TikTok endpoint list and specialty credit costs yourself. Verdict: Credible alternative when unit price at volume is the deciding factor. Compare envelope shape, MCP, and support model before you standardize. Details: Social Fetch vs ScrapeCreators. 4. Apify: actor marketplace for custom TikTok scrapers _Best for: scheduled batch jobs, niche extraction logic, and browser automation you control._ Apify is a scraper runtime. Clockworks TikTok Scraper is the common Actor for profiles and posts. You configure input JSON, start a run, poll, download a dataset. Each Actor returns its own schema. Published profile events often land around $3.70+ per 1,000 results on top of platform subscription and compute. Huge marketplace. Scheduling and dataset export. Useful when no managed API exposes the exact field you need. Schema and uptime vary by Actor author. Billing mixes platform fees and compute. Credits expire monthly on paid plans. Wrong tool for a React screen that needs followers before the next paint. Pricing: Free (~$5/mo platform credit) → Starter $29/mo → Scale tiers. See our Apify comparison. Verdict: Pick Apify when you need a custom pipeline. Accept that normalization is your problem. 5. Bright Data: enterprise infrastructure _Best for: high-volume teams with budget for proxy networks, spending limits, and sales-led contracts._ Bright Data sells proxy infrastructure and dataset pipelines. TikTok scrapers exist on top of that stack. Their TikTok scraper listing publishes pay-as-you-go around $1.50 per 1,000 successful records (verify live). You are buying a platform: residential IPs, browser farms, async exports. That is not a product engineer's REST API for a single creator card in an onboarding flow. Pay-for-success messaging on scrapers. Strong reliability on difficult targets in independent benchmarks. Volume pricing that can land near ~$1.50 per 1,000 records. No unified social schema across networks. Spending limits and procurement cycles. Overkill for a startup shipping one TikTok enrichment feature. Verdict: Right when enterprise volume and compliance process justify cost. See Social Fetch vs Bright Data. 6. SociaVault: simple pay-as-you-go _Best for: a small set of mainstream platforms and the lowest-friction REST API you can stand up in an afternoon._ SociaVault is credit-based PAYG in the same broad category as Social Fetch. Platform coverage is smaller. Treat marketing "25+" counts as including ad libraries and adjacent sources; head-to-head social coverage is closer to eight (verify on sociavault.com). PAYG credits that do not expire. Straight REST. Low entry at $29 for 6,000 credits. Partial schema normalization. No MCP in the same sense as a first-party agent tool catalog. Confirm TikTok Shop, ads, and transcript coverage before you promise those features. Verdict: Reasonable for a few platforms at low volume. Thin if you need Shop, Ad Library, transcripts, and LinkedIn on the same key. What Social Fetch returns for a TikTok profile Successful responses wrap the payload the same way as Instagram and YouTube: Follower and like counts above are illustrative of shape, not a live scrape from this article's publish date. Branch on data.lookupStatus before you write rows. Log meta.requestId and meta.creditsCharged on every call. Related docs: Get TikTok profile, profile videos, video transcript. Full hub: /platforms/tiktok. Try the live shape in the playground before you buy a credit pack. Free TikTok tools before you buy If the job is one handle or one video, you do not need an API key yet. These browser tools call the same production routes, with Turnstile and per-IP caps: TikTok profile viewer: paste a handle, get the public profile card TikTok engagement rate calculator: computes engagement in the browser from public metrics (the API returns raw counts) TikTok transcript generator: paste a video URL, copy plain text TikTok earnings calculator: rough revenue estimates from public activity When you need volume, automation, or warehouse inserts, move to the API on /platforms/tiktok. New accounts get 100 free credits with no card. Which API fits which workflow Multi-platform product feature, same JSON shape → Social Fetch TikTok-only, deep endpoints, Snapchat also required → EnsembleData Cheapest published $/1k at large packs → price ScrapeCreators against Social Fetch Scale Custom Actor, batch cron, browser control → Apify Enterprise proxy volume, procurement budget → Bright Data Few platforms, simplest PAYG → SociaVault Write access / partner scopes on owned apps → Official TikTok developer products Agent calling TikTok + other networks → Social Fetch MCP + unified schema One URL in a browser → free TikTok tools Agents break when field names change per platform. One tool definition should map to metrics.followers on TikTok and Instagram, not two conditional branches. Frequently asked questions What is a TikTok data API? A service that accepts a handle, video URL, hashtag, or Shop id and returns structured public TikTok data (profiles, posts, comments, search hits, Shop rows, transcripts) as JSON, usually while handling proxies, rendering, and upstream churn for you. Is there an official TikTok API for public profiles? Official TikTok developer products serve partner and user-authorized app use cases. They are not a general public-profile enrichment API. Third-party data APIs fill that gap for publicly visible content. What is the best TikTok data API in 2026? For sync REST with TikTok inside a 20-platform catalog (154 marketplace operations, 24 TikTok ops), Social Fetch is my pick. I built it. EnsembleData is often better if you are TikTok-only with flat daily volume and need Snapchat. ScrapeCreators can win on pack price at high volume. Apify wins on custom Actors. Bright Data wins on enterprise infra. SociaVault is fine for a smaller PAYG set. How much does Social Fetch charge for TikTok? Most TikTok profile, video list, comment, search, and Shop lookups are 1 credit per completed request. Transcripts and a minority of heavier routes document higher costs. Credits charge on completed lookups, including private and not_found outcomes returned in the 200 body. Always trust meta.creditsCharged. See pricing and the TikTok hub. Can I get TikTok video transcripts via API? Yes. GET /v1/tiktok/videos/transcript accepts public video URLs. Pass useAiFallback=true when captions are missing (extra credits on a completed lookup). There is also a free browser tool for spot checks. Does Social Fetch cover TikTok Shop? Yes. Product search, store products, product detail, reviews, and profile product-shelf routes are documented under TikTok. Exact paths live on /platforms/tiktok. Does Social Fetch compute TikTok engagement rate? No. The API returns raw metrics. Compute rates in your warehouse, or use the free engagement calculator for a one-off check. Should I build my own TikTok scraper? Build your own for a one-off research script. Use a managed API for anything production. Signed-request and region churn usually costs more than credits within a few months. What about compliance? We return publicly visible data. Compliance with TikTok's terms and local law is your responsibility. Consult counsel for your use case. See our docs. If you want to verify the Social Fetch claims in this post, open the TikTok hub, try the free TikTok profile viewer, paste a handle into the playground, or grab 100 free credits on pricing. For Apify, Bright Data, EnsembleData, and ScrapeCreators scenarios with worked numbers, use the compare hub.
---
# Best Truth Social APIs & scrapers in 2026
Source: https://www.socialfetch.dev/blog/best-truth-social-data-apis-2026
# Best Truth Social APIs & scrapers in 2026
Compare Truth Social data APIs for public profiles and posts — Social Fetch vs DIY scrapers, Apify actors, and the official app.
**Read on the site:** https://www.socialfetch.dev/blog/best-truth-social-data-apis-2026
"Truth Social API" usually means one of three jobs: post or manage an account inside Truth Social's own product, enrich public profiles and statuses from a backend you already ship, or dump HTML through a generic scraper when you do not care about a stable schema. Those are different products. Mixing them up is how you end up wiring a second auth story for one network while the rest of your pipeline already speaks one REST key — or paying Actor runtime fees for a single handle lookup your UI could await in one HTTP call. This is a coverage and ergonomics comparison for July 2026. Re-check each vendor's docs and pricing before you commit budget. Social Fetch is my pick for sync REST over public Truth Social profiles and posts, especially if you already normalize social data across TikTok, Instagram, X, or Telegram. Prefer Truth Social's own product when you need to publish, DM, or manage an account. Prefer Apify (or a custom actor) when you need a one-off crawl shape Social Fetch does not expose. Prefer a DIY HTTP or browser client only when you are willing to own auth, pagination, and field drift yourself. The short list 1. Social Fetch — sync REST for public profiles, profile posts, and single-status lookups 2. Truth Social (first-party app / web) — posting, DMs, and account management 3. DIY HTTP / browser clients — self-hosted scrapers against public pages when you own the maintenance 4. Apify / custom actors — scheduled HTML or browser scrapes for fields outside a typed catalog 5. Generic proxy + browser stacks — Bright Data, Oxylabs, Scrapfly, and peers when you only need raw page capture 6. RapidAPI listings — discovery marketplace, not one production contract | Option | Best for | Sync REST | Typed public profiles/posts | Starting cost | | --- | --- | --- | --- | --- | | Social Fetch | Public enrichment + multi-platform apps | Yes | Yes | 100 free credits, then PAYG | | Truth Social first-party | Write / account workflows | N/A | App UI | Free app account | | DIY HTTP / browser client | Full control, internal scripts | You build it | You normalize it | Your infra | | Apify / actors | Custom fields, batch schedules | Poll runs | Via actor schema | Free credit, then plans | | Proxy + browser | Raw HTML / screenshots | No | No | Usage-based | | RapidAPI listings | Prototyping niche endpoints | Varies | Varies | Per listing | Full Truth Social route list and examples live on the Truth Social platform page. Hands-on walkthrough: How to scrape Truth Social data. How I rank Truth Social data APIs I care about production behavior, not landing-page adjectives: 1. What you can actually call — profile by handle, cursor-paginated posts, single status by public URL. Count real paths, not "Truth Social support" on a marketing grid. 2. Access gate — instant API key vs account login vs actor configuration. Public enrichment should not require a Truth Social session cookie in your product path. 3. Sync vs async — one HTTP response you can await in a product request, or start-a-run / poll-a-dataset. 4. Typed misses — lookupStatus: not_found beats an empty 200 that looks like a blank page. 5. Error shape — typed outcomes and a requestId beat silent HTML. 6. Multi-platform tax — if your app already pulls TikTok and Instagram, does Truth Social force a second schema and a second vendor? 7. Compliance fit — first-party tools for write workflows; third-party public-data APIs for enrichment. Read Truth Social's terms for your use case. I am not your lawyer. Ranked picks 1. Social Fetch — public Truth Social over one REST key Best for product teams and agents that need public Truth Social profiles and posts beside other networks, without a Truth Social login in the request path. Social Fetch exposes three typed routes under /v1/truthsocial: profile by handle, cursor-paginated profile posts, and a single post by public status URL. Every response uses the same envelope as the rest of the marketplace — data.lookupStatus, ISO timestamps, author cards, media and link previews when present, meta.requestId, and meta.creditsCharged. Authenticate with x-api-key. New accounts get 100 free credits. Each Truth Social operation is credit-metered (confirm meta.creditsCharged). Coverage is public content only. Watch for: three routes, not a full firehose or private-account access. If you need to publish or manage an account, use Truth Social first-party tools. Endpoint pages: profile, profile posts, post by URL. 2. Truth Social first-party — write and account workflows Best when the job is posting, DMs, notifications, or account settings. Truth Social's own app and web product are the right path for anything that mutates state or requires a logged-in session. That is not a substitute for a metered public enrichment API in your backend. Keep first-party tools for creator and operator workflows; keep a data API for handle → JSON enrichment. 3. DIY HTTP and browser clients Best when you are willing to own field drift, auth, rate limits, and HTML parsers yourself. A personal script that hits public Truth Social pages can work until login walls, rate limits, or markup changes show up without a changelog. That path is rarely enough for a multi-platform product that wants one error shape, one credit meter, and one support requestId across Instagram and Truth Social. If you choose DIY, budget for breakage when public pages change. 4. Apify and custom actors Best when you need a crawl field Social Fetch does not expose, or a scheduled dump into a dataset. Apify is a scraper runtime: pick an actor, configure input, poll a run, download results. Each actor returns its own schema. Fine for research dumps. Awkward as the primary sync path inside a product request handler. See Social Fetch vs Apify for the broader tradeoff. 5. Generic proxy and browser stacks Best when you only need raw HTML, screenshots, or a one-off capture and will parse yourself. Bright Data, Oxylabs, Scrapfly, and similar tools are infrastructure. They do not give you a Truth Social profile card with lookupStatus. Buy them when you need proxies; look elsewhere when you need one JSON schema across networks. 6. RapidAPI listings Best for weekend discovery of niche endpoints. Marketplace listings help you find something fast. They stop helping when you need three vendors, three schemas, and three billing accounts for one dashboard. Keep RapidAPI for exploration. See Social Fetch vs RapidAPI when you outgrow the marketplace model. Official app vs public enrichment | Need | Prefer | | --- | --- | | Publish a status, DM, manage an account | Truth Social first-party | | Resolve @handle to a public profile card from your backend | Social Fetch (or DIY if you own it) | | Page a public profile's posts on a schedule | Social Fetch profile-posts route | | Hydrate one status from a public URL | Social Fetch posts route | | Custom HTML field nobody documents | Actor / DIY scrape | Social Fetch does not replace Truth Social's product for write workflows. Truth Social's product does not replace a metered enrichment API for multi-network backends. Which option fits which job | Job | Pick | | --- | --- | | Political / news monitor that already uses Social Fetch for X and Telegram | Social Fetch Truth Social routes | | Creator posting from a mobile app | Truth Social first-party | | One-off research dump with odd fields | Apify or DIY | | Agent tool call with the same MCP key as Instagram | Social Fetch MCP / REST | | Raw page archive for compliance evidence | Proxy + browser, then your parser | Questions before you buy 1. Do you need to write to Truth Social, or only read public pages? That fork decides first-party vs enrichment first. 2. Will Truth Social sit beside other networks? If yes, prioritize one schema and one key. 3. Sync or batch? Product handlers prefer sync. Overnight dumps can live on actors. 4. Do credits expire? Spiky research sprints hate monthly resets. 5. Can you preview without shipping? Use the playground or free credits before you lock a vendor. 6. What happens on a missing handle? Prefer typed not_found over empty HTML. Frequently asked questions Is there a Truth Social API for public profiles? Yes. Social Fetch provides GET /v1/truthsocial/profiles/ , profile posts, and post-by-URL under /v1/truthsocial. Authenticate with a Social Fetch API key. Details: /platforms/truthsocial. How do I use Truth Social data in a product? Call the typed REST routes (or MCP tools) for public enrichment, branch on data.lookupStatus, and store meta.requestId for support. For a step-by-step with curl and the SDK, see How to scrape Truth Social data. Does Social Fetch require a Truth Social login? No. You need a Social Fetch API key. Coverage is public profiles and statuses only. Can I access private or locked Truth Social accounts? No on Social Fetch. Restricted or missing targets resolve through data.lookupStatus (for example not_found) rather than inventing empty post lists. Truth Social scraper vs official app — which should I use? Use the official app when you need to post or manage an account. Use a managed public-data API when you need enrichment without Truth Social session cookies in your product path, or when multi-platform schema and sync REST matter more than first-party write scopes. Smoke-test a handle in the playground, or start with 100 free credits on pricing. Platform hub: /platforms/truthsocial. Broader roundup: Best social media scraping APIs in 2026.
---
# Best Twitter API alternatives in 2026
Source: https://www.socialfetch.dev/blog/best-twitter-x-data-apis-2026
# Best Twitter API alternatives in 2026
Compare Twitter / X APIs for profiles, tweets, and search — official X pricing vs scrapers and sync REST (Social Fetch, Apify, and more).
**Read on the site:** https://www.socialfetch.dev/blog/best-twitter-x-data-apis-2026
"Twitter API," "X API," and "Twitter scraper" get used for the same shopping trip, but they usually mean three different products: write access and elevated tiers under X's contracts, public enrichment without an X developer app, or bulk scrapes that ignore first-party packaging. Mixing those up is how you end up paying enterprise rates for a follower count, or wiring a marketplace Actor when you needed posting scopes. For the official meter vs public-data credit math, see Twitter / X API pricing. This is a pricing and coverage comparison for June 2026. Re-check each vendor's site before you commit budget. Social Fetch is my pick for sync REST over public X profiles, tweets, replies, search, hashtags, communities, and tweet transcripts, especially if you already normalize creators across TikTok and Instagram. Prefer the official X API when you need posting, DMs, OAuth-on-behalf-of, or a first-party compliance path. Prefer Apify when you need a custom Actor or a scheduled batch dump. Prefer EnsembleData or SociaVault when you want another sync social API and X is one of a few platforms you care about. The short list 1. Social Fetch — sync REST for public X data, same envelope as other platforms 2. X API (official) — first-party route for write access, elevated products, and X-signed contracts 3. Apify Twitter/X Actors — marketplace scrapers when you need custom fields or scheduled runs 4. EnsembleData — sync social API with monthly unit plans that include X 5. SociaVault — pay-as-you-go social API with X in the mix 6. RapidAPI Twitter listings — discovery marketplace, not one production contract | Option | Best for | Sync REST | Search | Starting cost | | --- | --- | --- | --- | --- | | Social Fetch | Public enrichment + multi-platform apps | Yes | Yes | 100 free credits, then PAYG | | X API | Posting, OAuth, elevated access | Yes | Yes (tiered) | Free tier, then paid X plans | | Apify Actors | Custom scrapes, batch schedules | Poll runs | Via Actors | ~$5/mo free credit, then plans | | EnsembleData | Sync social with daily unit caps | Yes | Yes | Monthly plans | | SociaVault | Simple PAYG social lookups | Yes | Varies | Paid packs + small free taste | | RapidAPI listings | Prototyping niche endpoints | Varies | Varies | Per listing | Full X route list and examples: Twitter / X platform page. Cost fork: Twitter / X API pricing. How I rank Twitter/X data APIs I rank on production behavior: 1. What you can actually call — profiles, tweets, replies, user timelines, keyword search, hashtags, communities, transcripts. Count real paths, not "Twitter support" on a marketing grid. 2. Official vs public enrichment — write scopes and elevated access belong on X's API. Public cards and keyword alerts often do not need an X developer app. 3. Quota vs credits — X sells tiered access that changes packaging often. Credit APIs trade that for prepaid lookups; know which meter you are buying. 4. Sync vs async — one HTTP response you can await in a product request, or start-a-run / poll-a-dataset. 5. Error shape — typed outcomes and a requestId beat silent empty HTML when a handle is protected or search returns nothing. 6. Multi-platform tax — if your app already pulls TikTok and Instagram, does X force a second schema and a second vendor? 7. Compliance fit — official API when your contract with X requires it; third-party public-data APIs for enrichment. Read X's Terms for your use case. I am not your lawyer. Twitter / X pricing compared Every figure below is indicative for June 2026. Re-check before you buy. | Provider | Entry price | Billing shape | Free tier | Charge on completed lookup? | | --- | --- | --- | --- | --- | | Social Fetch | $14 / 1,000 credits | PAYG packs never expire | 100 credits, no card | Yes — bill from meta.creditsCharged; no charge on lookup_failed / 503 | | X API | Free and paid developer tiers | Monthly / credit tiers (packaging moves) | Small free allowance | X's meter — not prepaid social credits | | Apify | $29/mo + compute | Monthly plan credits expire | ~$5/mo platform credit | Per Actor; run + compute + events | | EnsembleData | ~$100+/mo plans | Daily units reset at 00:00 UTC | Verify on site | Yes for successful calls; internal errors not billed | | SociaVault | $29 / 6,000 credits | PAYG packs never expire | 50 credits | Credit-based; route weights vary | | RapidAPI | Per listing | Publisher-dependent | Varies | Varies by listing | Sticker price is not the whole decision. Credit expiry, daily unit resets, and whether failed infrastructure errors bill change real cost more than a few cents per thousand on a pricing table. For Social Fetch's billing rules (including private / not-found outcomes that still complete a lookup), see Credits. Ranked picks 1. Social Fetch — public X over one REST key _Best for: product teams and agents that need public profile cards, tweets, replies, search, communities, and tweet transcripts without an X developer app, and that already (or soon will) pull other social platforms._ Social Fetch exposes first-party X routes under /v1/twitter/*: profile by handle, profile tweets, tweet detail, replies, tweet transcript, keyword search, hashtag search, community detail, and community tweets. Responses use the shared envelope. Follower counts land in the same metrics conventions as other platforms, so cross-network creator scores do not fork on field names. Sync GET routes cover the common path without Actor run polling. Search sits next to profile and tweet detail (see Twitter search API for filters and pagination). Every response carries meta.requestId and meta.creditsCharged. One API key covers TikTok, Instagram, YouTube, and the rest of the catalog. Signup includes 100 free credits with no card; PAYG packs do not expire. Limits to know: this is public enrichment, not X's posting API, DMs, or elevated analytics products. Search and heavier routes can cost more than a simple profile GET; trust meta.creditsCharged and the operation docs. Empty search results still complete a lookup and can bill; lookup_failed and 503 temporarily_unavailable do not. Model that before you poll hourly. Protected accounts are not returned as fake public data; expect typed lookup outcomes, not invented timelines. Pricing: free (100 credits) → Starter $14 (1,000) → higher packs on pricing. Credits charge on completed lookups. See Credits for the full policy. Default pick when X is one surface in a multi-platform product, or when you want keyword search and profile cards without negotiating an X enterprise seat. See the X (Twitter) hub for the full route list. 2. X API (official) — first-party when you need first-party _Best for: apps that post or reply as users, need OAuth scopes, DMs, elevated access, or must stay inside X's own access model and contracts._ The official X API is the correct product for write paths and anything procurement insists must come from X. Tiers, rate limits, and product packaging change often enough that teams treat access as a procurement problem, not an engineering one. That works when ownership and compliance require it. It is expensive friction when you only need a public profile card or a keyword alert cron. First-party ToS path. Write access and OAuth-on-behalf-of. Good for products that already run on X developer apps and need posting or elevated products third parties cannot honestly sell. Pricing and tier names move. Free and low tiers surprise people who treat "API access" as unlimited search for a monitoring cron. Commercial scrapers that ignore the official API are a different risk category than calling X's endpoints with a project key. Pricing: free and paid X developer tiers; packaging changes. Read current X developer pricing before you promise volume, or start with our walkthrough: Twitter / X API pricing. This is not prepaid social credits that charge only on completed public lookups. Use it when write scopes, OAuth-on-behalf-of, or an X-signed contract are requirements. Supplement or replace it for public enrichment and multi-platform apps if the tier math fails your product. 3. Apify — Twitter/X Actors for custom and batch work _Best for: scheduled handle dumps, niche field extraction, and scrapers you want to configure as Actors rather than maintain as a fleet of browsers._ Apify hosts many Twitter/X Actors (profiles, tweets, search, followers lists depending on the Actor). You start a run, poll, download a dataset. Schemas differ by Actor author. Billing mixes platform subscription, compute, and per-event fees; monthly plan credits expire. Per-result costs vary widely by Actor. Model the specific Actor's pricing, not a generic "Apify is cheap" assumption. Marketplace breadth helps when no managed REST route exposes the field you need. Scheduling and dataset export are built into the platform. You are buying a runtime, not one X schema. Actor quality varies. Sync product UIs that need a single HTTP round trip fit poorly. X anti-bot pressure hits Actor authors unevenly. Pricing: free (~$5/mo platform credit) → Starter and higher monthly plans. See Social Fetch vs Apify. Right for batch and custom scrapes. Wrong as your only integration if you want one typed client for profile + search in a request handler. 4. EnsembleData — sync social with daily unit resets _Best for: teams that want sync GET social JSON (including X) and are fine with monthly plans that reset units daily._ EnsembleData sits in the same lane as Social Fetch: synchronous requests, JSON responses, one token. Coverage includes X among other social networks. The purchase model is monthly plans with a daily unit allowance that resets at 00:00 UTC. That differs from prepaid packs that never expire and charge only on completed lookups. Real sync REST competitor. Failed internal errors are not billed (similar honesty bar to our lookup_failed / 503 policy). Straightforward for steady daily volume that fits the unit cap. Spiky workloads hate daily resets. A launch-day burst can burn the day early and stall until UTC midnight. Platform breadth is narrower than Social Fetch's catalog. Compare your mix before the logo wins: Social Fetch vs EnsembleData. Reasonable if X is one of a few networks and monthly unit math fits. Prefer prepaid credits if your traffic is bursty. 5. SociaVault — simple PAYG for a smaller social set _Best for: pay-as-you-go social lookups when you want another first-party REST option and X is in scope._ SociaVault overlaps Social Fetch on several networks, including Twitter/X. Credits are prepaid and do not expire. Docs publish complexity multipliers on some routes (comments, demographics), so profile-only math can understate a comments-heavy product. Entry packs are commonly cited around $29 for 6,000 credits. Confirm live on sociavault.com before you budget. Same product category. Self-serve. No Actor polling for the common path. PAYG shape that does not force a monthly seat. Verify credit weights for the routes you will actually call. Tooling and envelope differ. Catalog is smaller than Social Fetch's matrix. Side-by-side: Social Fetch vs SociaVault. Fine shortlist peer. Pick on price-at-your-mix, docs, and whether you need the wider Social Fetch surface. 6. RapidAPI Twitter listings — browse, then graduate _Best for: finding a niche X endpoint over a weekend without signing an enterprise contract or committing to one vendor's schema._ RapidAPI is a marketplace of third-party Twitter/X scrapers, not one production contract. Billing and discovery sit on the platform; the actual API comes from an independent publisher. Search the catalog and you will find several "Twitter API" listings with different JSON shapes, rate caps, and maintenance habits. The test console makes weekend prototypes easy. That speed stops helping once X is load-bearing. Multi-platform products usually need a second listing for Instagram and a third for YouTube, each with its own key, schema, and support path. When a publisher changes fields or abandons a listing after an X UI change, tickets often bounce through RapidAPI to someone you never onboarded. Typical marketplace social scrapers land around $2.50–$4+ per 1,000 requests depending on the listing; confirm the publisher's meter before you budget. Fast discovery across many scrapers. Cheap Basic tiers for throwaway experiments. Works if you already centralize unrelated APIs on one RapidAPI invoice. No shared envelope. Publisher churn. Per-minute caps on popular Pro tiers that throttle live product traffic. Fragmentation tax when X is only one of several networks. Keep it for exploration and hackathons. Graduate to a first-party sync API when profile + search sit in a request handler, or when you need the same parser as TikTok and Instagram. Longer take: Social Fetch vs RapidAPI. Profile lookup is often enough A lot of "we need the Twitter API" tickets are really "confirm this handle exists and pull follower count." That job does not require write scopes, search pagination, or an Actor. For a one-off paste-and-read check in the browser, use the free tool instead of wiring keys: Free Twitter / X profile viewer — handle or x.com / twitter.com URL → bio, followers, verification signals Same production path as GET /v1/twitter/profiles/ behind Turnstile and fair-use caps (1/min · 3/hour · 10/day per IP) Tweet lists, replies, and search stay on the paid API Protected accounts may return limited fields. The free tool is for spot checks, not screening a spreadsheet. When you need volume, move to an API key and the X platform routes. Which API fits which job Multi-platform creator product, sync JSON → Social Fetch (X hub) Posting / OAuth / elevated X products → Official X API Nightly handle scrape with custom fields → Apify Actor Sync social with daily unit caps → EnsembleData Simple PAYG peer on a smaller catalog → SociaVault One-off public profile in the browser → /tools/twitter-profile-viewer Keyword alerts without an X developer app → Social Fetch search (guide) If you only need X today but Instagram next quarter, pick the option whose envelope you can reuse. Rewriting parsers per platform is where most "cheap" APIs get expensive. Questions before you buy 1. Do you need write scopes, or public enrichment? That fork decides official X vs third-party first. 2. Will search volume fit your tier or credit budget? Model polls × credits (or X rate limits) before you promise real-time alerts in a UI. 3. Is profile card enough? If yes, try /tools/twitter-profile-viewer before you design around search. 4. Sync or batch? Product request handlers prefer sync. Overnight dumps can live on Actors. 5. One schema across platforms? Call X and TikTok with the same parser. If you need if (platform === "twitter"), you do not have unification. 6. Do credits or units expire / reset? Spiky workloads hate monthly or daily resets. 7. Can you preview without shipping? Use a playground, free credits, or the free profile viewer before you lock a vendor. Frequently asked questions What is the best Twitter/X Data API in 2026? For public sync REST with profiles, tweets, replies, search, communities, and transcripts, and the same envelope as other social platforms, Social Fetch is my pick. I built it. The official X API wins for write access and first-party contracts. Apify wins for custom Actors. EnsembleData and SociaVault are real sync peers with different billing shapes. Is the official X API free? X publishes free and paid tiers; packaging changes. Treat free access as a small allowance with rate limits, not unlimited production search. Read current X developer pricing before you promise volume. Do I need an X developer account for Social Fetch? No. You need a Social Fetch API key. Details and route list: /platforms/twitter. Twitter scraper API vs X API — which should I use? Use the official API when you need X's auth model, posting, or elevated products. Use a managed public-data API when you need enrichment without an X developer app, or when tier math and multi-platform schemas fail your product. Scrapers and Actors fill gaps neither covers; they also shift maintenance and compliance risk onto you. Can I look up an X profile without an API key? Yes, for spot checks: /tools/twitter-profile-viewer. Rate-limited. For product volume, use GET /v1/twitter/profiles/ with a key. When does Social Fetch charge credits on X routes? On completed lookup attempts, as documented per endpoint. That includes 200 responses where data.lookupStatus is private or not_found, and empty search pages that still resolved. lookup_failed and 503 temporarily_unavailable are not charged on metered lookup routes. Always read meta.creditsCharged. Full policy: Credits. Smoke-test a profile or search in the playground, or start with 100 free credits on pricing. For one public handle without an API key, open the free Twitter / X profile viewer. Official vs public-data cost models: Twitter / X API pricing.
---
# Best YouTube transcript & data APIs in 2026
Source: https://www.socialfetch.dev/blog/best-youtube-data-apis-2026
# Best YouTube transcript & data APIs in 2026
Compare YouTube transcript and data APIs for channels, videos, comments, and captions — Google Data API v3 vs Social Fetch, Apify, and more.
**Read on the site:** https://www.socialfetch.dev/blog/best-youtube-data-apis-2026
"YouTube Data API" and "YouTube transcript API" usually mean Google's official product. Most teams shopping those phrases need something else: owned-channel operations under Google Cloud quotas, public enrichment on arbitrary watch URLs (including captions), or bulk scrapes that blow past the free daily unit budget. Those are different products. Mixing them up is how you end up with a scraper billed like an API, or an official key that dies on search volume before lunch. This is a pricing and coverage comparison for April 2026. Re-check each vendor's pricing page before you commit budget. Social Fetch is my pick for sync REST over public YouTube channels, videos, comments, search, and transcripts, especially if you already pull TikTok or Instagram on the same key. Use Google's YouTube Data API v3 when you need official quotas, uploads, or partner tools. Use Apify when you need a custom Actor or a scheduled batch dump. Use SerpApi when search SERP shape is the whole product. The short list 1. Social Fetch — sync REST for public YouTube data, same envelope as other platforms 2. YouTube Data API v3 (Google) — official route for owned channels, compliant metadata, and Google Cloud quotas 3. Apify YouTube Actors — marketplace scrapers when you need custom fields or scheduled runs 4. SerpApi YouTube — search-engine-style results without building a scraper 5. RapidAPI YouTube listings — discovery marketplace, not one production contract 6. yt-dlp — open-source CLI/library you host yourself for media and metadata | Option | Best for | Sync REST | Transcripts | Starting cost | | --- | --- | --- | --- | --- | | Social Fetch | Public enrichment + multi-platform apps | Yes | Yes | 100 free credits, then PAYG | | YouTube Data API v3 | Owned channels, official quotas | Yes | Limited / awkward | Free tier, then Google Cloud | | Apify Actors | Custom scrapes, batch schedules | Poll runs | Via Actors | ~$5/mo free credit, then plans | | SerpApi | Search SERPs | Yes | No (search focus) | Free ~250 searches/mo, then from $25/mo | | RapidAPI listings | Prototyping niche endpoints | Varies | Varies | Per listing / publisher | | yt-dlp | Self-hosted media/metadata | No (you wrap it) | Yes (local) | Infra + ops you run | Full YouTube route list and examples live on the YouTube platform page. How I rank YouTube data APIs I rank on production behavior, not landing-page adjectives: 1. What you can actually call — channels, videos, Shorts, playlists, comments, search, transcripts. Count real paths in a docs index, not "YouTube support" on a marketing grid. 2. Quota vs credits — Google's default free quota is 10,000 units/day (YouTube Data API quota). A search.list call costs 100 units. Credit APIs trade that for prepaid lookups; know which meter you are buying. 3. Sync vs async — one HTTP response you can await in a product request, or start-a-run / poll-a-dataset. 4. Transcript path — spoken text is often the reason people leave the official API. Either the provider has a first-class transcript route, or you glue something else on. 5. Error shape — typed outcomes and a requestId beat silent empty HTML. 6. Multi-platform tax — if your app already pulls TikTok and Instagram, does YouTube force a second schema and a second vendor? 7. Compliance fit — official API for channels you control; third-party public-data APIs for enrichment. Read YouTube's Terms of Service for your use case. I am not your lawyer. Ranked picks 1. Social Fetch — public YouTube over one REST key _Best for: product teams and agents that need public channel cards, uploads, comments, search, and transcripts without a Google Cloud project, and that already (or soon will) pull other social platforms._ Social Fetch exposes 12 YouTube routes under /v1/youtube/*: channel lookup, channel videos and Shorts, playlists, community posts, search, hashtag search, trending Shorts, video detail, comments, replies, and transcripts. Responses use the shared envelope. Subscriber counts use the same metrics conventions as followers on other platforms, so cross-network creator scores do not fork on field names. Sync GET routes cover the common path. No Actor run polling. Transcripts sit next to video detail at GET /v1/youtube/videos/transcript. Every response includes meta.requestId and meta.creditsCharged. The same API key works for TikTok, Instagram, and the rest of the catalog. Signup includes 100 free credits with no card; PAYG packs do not expire. This is public enrichment, not Google's upload API or partner analytics. Heavier routes can cost more than a simple channel GET. YouTube can return lookupStatus: "found" with transcript: null when the video exists but has no caption track. That is a real outcome, not a broken call. Pricing: Free (100 credits) → Starter $14 (1,000) → higher packs on pricing. Most YouTube lookups are 1 credit per completed request. Credits charge on completed lookups. Trust meta.creditsCharged and the capability matrix. Verdict: Default pick when YouTube is one surface in a multi-platform product, or when you want transcripts and comments without burning Google search quota. See the YouTube hub for the full route list. 2. YouTube Data API v3 (Google) — official when you need official _Best for: apps that manage channels you own, need OAuth scopes, uploads, playlists you control, or must stay inside Google's access model._ Google's Data API is the correct product for partner and owned-channel work. Quotas are unit-based. The default free project allowance is 10,000 units/day; search.list alone costs 100 units, so "free" is a small prototype budget, not unlimited production search. Caption endpoints exist but are awkward for "give me spoken text for any public URL" research jobs. That is where most teams bolt on a third-party transcript path. The first-party ToS path is stable and documented. It fits Channel Analytics integrations you already run on Google Cloud. Write and upload surfaces third-party enrichment APIs will not (and should not) pretend to replace. Daily unit caps surprise people who treat free quota as infinite. Extending quota is a Google Cloud / quota-request problem, not a credit pack purchase. Commercial scrapers that ignore the official API are a different risk category than calling Google's endpoints with a project key. Pricing: Free daily unit quota on a Google Cloud project, then billed Google Cloud usage / higher quota as approved. There is no Social Fetch-style prepaid credit pack that never expires, and no charge-on-completed-lookup meter for public enrichment. Verdict: Use it when ownership and compliance require Google. Supplement or replace it for public enrichment and transcript volume if the quota math fails your product. 3. Apify — YouTube Actors for custom and batch work _Best for: scheduled channel dumps, niche field extraction, and scrapers you want to configure as Actors rather than maintain as a fleet of browsers._ Apify hosts many YouTube Actors (search, comments, transcripts, all-in-one scrapers). You start a run, poll, download a dataset. Schemas differ by Actor author. Billing mixes platform subscription, compute, and per-event fees; monthly plan credits expire. Popular YouTube Actors often land in a few dollars per 1,000 results band on top of platform fees. Verify the specific Actor's pricing page before you model a nightly dump. Marketplace breadth is the draw when no managed REST route exposes the field you need. Scheduling and dataset export are built into the platform. You are buying a runtime, not one YouTube schema. Actor quality and patch speed vary by maintainer. Sync product UIs that need a single HTTP round trip fit poorly. When YouTube changes internals, you depend on that Actor's author. Pricing: Free (~$5/mo platform credit) → Starter and higher monthly plans. See Social Fetch vs Apify. Verdict: Right for batch and custom scrapes. Wrong as your only integration if you want one typed client for channel + transcript in a request handler. 4. SerpApi — when search results are the product _Best for: YouTube search SERPs (and video-detail SERP pages) with filters, without operating residential proxies yourself, especially if you already buy SerpApi for Google or Bing._ SerpApi is a multi-engine search results API. The YouTube engines (engine=youtube, engine=youtube_video) return search-shaped and video-page-shaped JSON: result cards, related videos, and some comment-adjacent fields depending on the engine. That is a SERP product with a YouTube mode, not a channel/video/comment/transcript platform. Teams that already meter monthly SerpApi searches often add YouTube here so SEO and creator discovery share one vendor. Public plans (serpapi.com/pricing, April 2026) run Free (~250 searches/mo), Starter $25/mo (1,000), Developer $75/mo (5,000), Production $150/mo (15,000), Big Data $275/mo (30,000), then Enterprise. Successful searches count against the monthly allotment; cached hits in their model are typically free. Unused searches on standard plans do not roll over the way prepaid social credits do. SERP parsing is mature. Docs and playground are clear. The product sells search JSON, not a fake "full YouTube API" marketing grid. No first-class transcript route for RAG pipelines. Channel feeds, Shorts catalogs, and deep comment trees are not the center of the product. Monthly search seats punish spiky traffic the same way other subscription SERP meters do. A $25 SerpApi Starter (1,000 searches that month) is not the same unit as a $25 Social Fetch credit pack. Verdict: Buy it when YouTube search SERP shape is the job, or when you already live in SerpApi for other engines. Do not expect it to replace a YouTube data platform. Category split: Social Fetch vs SerpApi. 5. RapidAPI YouTube listings — browse, then graduate _Best for: finding a niche YouTube endpoint over a weekend without signing an enterprise contract or committing to one vendor's schema._ RapidAPI is a marketplace. It hosts third-party YouTube APIs the way an app store hosts apps: billing and discovery sit on the platform, the scraper itself comes from an independent publisher. Search "YouTube API" and you get a shelf of listings with different response shapes, rate limits, and uptime records. Prototypes move fast because the test console will call anything. Production usually stalls on three listings, three schemas, and three support queues for one dashboard. YouTube next to Instagram next to TikTok means separate subscriptions and separate adapters. When a listing breaks after a YouTube UI change, your ticket often routes through RapidAPI to a publisher you never met. Marketplace scrapers commonly price in the rough $2.50–$4+ per 1,000 range depending on the listing. Verify the specific publisher before you model unit economics. Fast discovery and cheap Basic tiers help throwaway experiments. Fine if social data is one line item among many unrelated marketplace APIs you already bill through RapidAPI. No shared envelope across publishers. Schema drift without notice. Multi-platform products pay a fragmentation tax that never appears on a single listing's pricing page. Verdict: Keep it for exploration and hackathons. Graduate to a first-party API when YouTube is load-bearing or you need the same parser as other networks. Longer take: Social Fetch vs RapidAPI. 6. yt-dlp — self-hosted when you want the binary _Best for: local research, media download adjacent to metadata, internal scripts, and teams willing to run and patch open-source tooling (and optionally wrap it behind their own HTTP service)._ yt-dlp is not a hosted API. It is a widely used open-source CLI/library for format selection, metadata extraction, and subtitle/caption pulls. Transcripts and formats work well for scripts and offline pipelines. You wrap it, host workers, handle rate limits, cookies, IP blocks, and YouTube JS challenge churn. Product SLAs, retries, and customer-facing latency are yours. There is no sticker price. Cost is engineer time, compute, proxies if you need them, and the ongoing patch cycle when YouTube changes extraction. Community wrappers exist that expose REST around yt-dlp; those still leave you operating the binary and the infra. That is a fair choice for an internal research box. It is a poor substitute for a managed sync route when an onboarding flow awaits a channel card or transcript in one HTTP round trip. Depth on formats and captions for people who live in shells. No vendor lock-in on the extractor itself. Fine next to a managed API when you need media files the API does not ship. You own breakage. Datacenter IPs get blocked. There is no multi-platform envelope, no requestId for support, and no charge-on-completed-lookup credit meter. You invent all of that yourself. Verdict: Keep it for internal tooling and media-adjacent jobs. Prefer a managed API when customers wait on your HTTP response. Transcripts are a separate problem Most "YouTube API" comparisons bury captions. In 2026, research agents and RAG pipelines often care more about spoken text than subscriber counts. Social Fetch treats transcripts as a first-class route. For a one-off paste-and-copy job, use the free browser tools instead of wiring keys: Free YouTube Transcript Extractor — watch URLs, youtu.be, Shorts, embeds Free YouTube channel viewer — public channel card before you buy search volume Free TikTok Transcript Generator — when the same workflow spans short-form too Background on limits and when to move to the API: Free TikTok and YouTube transcript tools Deeper pipeline patterns: How to get YouTube, TikTok, and Instagram transcripts Edge cases: no "manual captions only" switch; you get the track the platform exposes. Music uploads and caption-disabled videos can resolve as found with empty transcript text. Check lookupStatus and the transcript fields before you index nulls into a vector store. Which API fits which job Multi-platform creator product, sync JSON → Social Fetch (YouTube hub) Owned channel uploads / official Google quotas → YouTube Data API v3 Nightly channel scrape with custom fields → Apify Actor YouTube search SERPs only → SerpApi One-off transcript on a clipboard → /tools/youtube-transcript Self-hosted media + metadata → yt-dlp If you only need YouTube today but Instagram next quarter, pick the option whose envelope you can reuse. Rewriting parsers per platform is where most "cheap" APIs get expensive. Questions before you buy 1. Do you need owned-channel scopes, or public enrichment? That fork decides official vs third-party first. 2. Will search volume fit Google's unit budget? Model units before you promise real-time search in a UI. 3. Is transcript a hard requirement? If yes, test the transcript path on day one, not after channel lookup ships. 4. Sync or batch? Product request handlers prefer sync. Overnight dumps can live on Actors. 5. One schema across platforms? Call YouTube and TikTok with the same parser. If you need if (platform === "youtube"), you do not have unification. 6. Do credits expire? Spiky workloads hate monthly resets. 7. Can you preview without shipping? Use a playground, free credits, or the free transcript tool before you lock a vendor. Frequently asked questions What is the best YouTube Data API in 2026? For public sync REST with channels, videos, comments, search, and transcripts, and the same envelope as other social platforms, Social Fetch is my pick. I built it. Google's Data API v3 wins for official owned-channel work. Apify wins for custom Actors. SerpApi wins for search SERPs. Is the official YouTube Data API free? There is a free daily quota (10,000 units/day on the default project). Search and other methods cost many units each. Treat "free" as a small allowance, not unlimited production capacity. Can I get YouTube transcripts via API? Yes. Social Fetch: GET /v1/youtube/videos/transcript with a public video URL. For a single URL in the browser, use /tools/youtube-transcript. Google's caption endpoints exist but are a poor fit for arbitrary public-URL research jobs. YouTube scraper API vs YouTube Data API — which should I use? Use the official API when you need Google's auth model and owned-channel tools. Use a managed public-data API when you need enrichment without Google Cloud setup, or when quota and transcript ergonomics fail your product. Scrapers and Actors fill gaps neither covers; they also shift maintenance and compliance risk onto you. Does Social Fetch require a Google Cloud project? No. You need a Social Fetch API key. Details and route list: /platforms/youtube. Smoke-test a channel or transcript in the playground, or start with 100 free credits on pricing. For one video's captions without an API key, open the free YouTube transcript tool.
---
# Free TikTok and YouTube transcript tools
Source: https://www.socialfetch.dev/blog/free-tiktok-youtube-transcript-tools
# Free TikTok and YouTube transcript tools
Paste a TikTok or YouTube URL and copy caption text in the browser. Free transcript tools — no API key required for spot checks.
**Read on the site:** https://www.socialfetch.dev/blog/free-tiktok-youtube-transcript-tools
You need the spoken text from one video: a quote for a doc, a sanity check on what a creator said, a chunk for an LLM prompt. You do not need a batch worker, a database, or an API key for that. We run a free tools hub with browser helpers for TikTok and YouTube transcripts. Paste a URL, click a button, copy plain text. No account needed for a spot check. That is the whole product for a spot check. The rest of this post covers when that is enough, when it is not, and what the tools will not do. When the browser tool is enough Use the free pages when the job is narrow and human: one URL on your clipboard right now, a quick check that a video has captions before you spend credits in a script, or a handful of links for a slide deck rather than a nightly cron over ten thousand URLs. Start from the hub at /tools, or go straight to the tool you need: Free TikTok transcript generator accepts standard /@user/video/… links, vm.tiktok.com short links, and embed URLs. Free YouTube transcript extractor accepts watch URLs, youtu.be links, Shorts, and embed links. Both pages use the production transcript routes. Your browser is the caller instead of a server with an API key. You get the same caption resolution logic. You do not get unlimited throughput. If you would not put the job on a cron schedule, the browser tool is probably fine. If your product depends on the output, move to the API before you promise a ship date. When you need the API The free pages are rate-limited by design. Move to programmatic calls when you need volume (dozens or hundreds of URLs in one sitting), automation (nightly pulls, webhook handlers, agent loops), or structured output (WebVTT timing cues, millisecond segments, lookupStatus in your warehouse instead of pasted plain text). The browser tools only read existing caption tracks on TikTok. The API accepts useAiFallback=true to transcribe audio when no captions exist (+10 credits on a completed lookup). Instagram Reels transcripts are API-only at GET /v1/instagram/posts/transcript, with the same auth header and billing model as TikTok and YouTube. New accounts get 100 free API credits (no card). That is enough to prototype a batch job before you buy a credit pack. For TikTok with AI fallback when captions are missing: Full parameter lists: YouTube transcript, TikTok transcript. Auth and error shapes: Quickstart. Caption limits and free lookup caps We would rather tell you the edge cases upfront than have you discover them mid-demo. Manual vs auto captions Neither YouTube nor TikTok labels tracks as "manual" or "auto" in the response. You get whatever caption file the platform exposes, creator-uploaded or platform speech-to-text. On the API, pass language=en when several tracks exist and you need a specific one. There is no "manual only" switch. YouTube can return lookupStatus: "found" with transcript: null. The video resolved, but no caption track exists. Common on music-only uploads or when the creator disabled captions. That is "no text available," not a broken lookup. TikTok is stricter. A large share of videos never had captions enabled. Without AI fallback, those come back as not_found. AI fallback is API-only The free browser tools do not run AI transcription. They read existing tracks and return plain text for copying. If you need text from uncaptioned TikToks, call the API with useAiFallback=true. That costs 11 credits on a completed lookup (1 base + 10 for fallback). Use it when you need every video in a batch. Skip it when you would rather drop clips without captions. Turnstile and per-IP caps Free lookups are capped per IP address and gated behind Cloudflare Turnstile so the pages stay fast for everyone. That works for a spot check or a dozen URLs. It is not a batch worker. Scripts, browser extensions, and rapid-fire submits will hit the cap quickly. If you are automating, use an API key from your backend. Paid routes have no request quotas — credits are the only limit. Under extreme concurrency you may get 503 with Retry-After (not charged). For large backfills we suggest staying under ~500 concurrent requests. Billing on the API path Credits charge on completed lookups. Reconcile against meta.creditsCharged, not your request count. Full rules: Credits. | Outcome | Charged? | | --- | --- | | Pre-send validation error (malformed URL) | No | | lookup_failed / HTTP 503 | No | | HTTP 200 + lookupStatus: "not_found" | Yes | | HTTP 200 + lookupStatus: "found" | Yes | Branch on data.lookupStatus in code. HTTP 200 does not mean you got text. We have seen production bugs from teams who assumed it did. Browser tool vs API The free pages and the API use the same transcript routes. When you outgrow pasting URLs in a browser, you do not learn a second system. Add an x-api-key header and call those paths from a worker. Next steps: 1. TikTok transcript API: WebVTT in transcript.content, optional AI fallback. 2. YouTube transcript API: plainText plus segments with startMs / endMs. 3. Quickstart: auth headers, error envelope, meta.requestId for support tickets. 4. Pricing: model credit usage before you parallelize a big backfill. For a full walkthrough across YouTube, TikTok, and Instagram (caption quirks, batch patterns, RAG chunking), see How to Get YouTube, TikTok & Instagram Transcripts with One API. Try a URL in the browser first if you want to see what comes back. When the job needs to run on its own, call the API from your backend.
---
# Reddit API pricing in 2026 (what you pay)
Source: https://www.socialfetch.dev/blog/reddit-api-pricing
# Reddit API pricing in 2026 (what you pay)
How Reddit API pricing works for free vs commercial access, and when a public-data API is cheaper for research and monitoring.
**Read on the site:** https://www.socialfetch.dev/blog/reddit-api-pricing
"Reddit API pricing" is the question teams ask when a research cron, brand monitor, or product-feedback workflow needs public subreddits, posts, and comments. Then they hit Reddit's access model: free non-commercial quotas, a manual commercial path, and third-party credit APIs that meter a different unit of work. Use the official Reddit Data API when you need first-party compliance, Reddit-native scopes, or a contract that says "Reddit." Use Social Fetch when you need public search, subreddit feeds, comment trees, and transcripts without a Reddit OAuth app: prepaid credits, same envelope as TikTok and Instagram, charge only on completed lookups (not on our infrastructure failures). Reddit does not publish a self-serve commercial rate card; teams often cite about $0.24 per 1,000 calls when commercial access is granted. Confirm live terms on Reddit's help center before you forecast. Which path fits your job | Job | Prefer | | --- | --- | | Reddit client, mod tools, user-scoped actions | Official Reddit Data API | | Public keyword search, subreddit feeds, comment trees for research | Official (if approved) or public-data API | | Same schema as TikTok / Instagram in one product | Public-data API (Social Fetch Reddit hub) | | Custom batch scrape / Actor dump | Marketplace runtime (vs Apify) | If your ticket says "Reddit API" but the acceptance criteria are "pull the last month of posts for these three subreddits," you are not buying a Reddit client. You are buying search pages and comment pages. Vendor shortlist: Best Reddit Data APIs in 2026. Keys and rate limits: How to get a Reddit API key. What "Reddit API pricing" usually means Three different products get collapsed into one phrase: 1. Official Reddit Data API — OAuth apps, scopes, QPM quotas, and whatever commercial contract Reddit grants after review. Source of truth: Developer Platform & Accessing Reddit Data and the Reddit Data API Wiki. 2. Public enrichment APIs — third-party REST for publicly visible subreddits, posts, comments, and search. No Reddit client ID. You pay the vendor's credit or unit meter. 3. Scrapers and Actors — run-based or browser automation. Useful for custom fields; a different ops and compliance model than sync REST. Mixing (1) and (2) is how budgets blow up. Official access is priced and gated for Reddit's product surface. Public enrichment is priced for "lookup this subreddit / query and return JSON." Glossary shorthand if someone on your team still asks whether Reddit has an API at all: Does Reddit have an API?. Why official Reddit pricing hurts for enrichment A few structural reasons show up in almost every evaluation, regardless of the exact dollars on Reddit's page today: Free non-commercial is not a commercial monitoring plan. Approved non-commercial access is commonly rate-limited around 100 queries per minute per OAuth client. Listing pages often top out near 100 items. That is a personal or research-style allowance, not unlimited production monitoring for a paid product. Reddit's Responsible Builder Policy treats commercial use as a separate approval path. Commercial access is a sales process, not a checkout button. If your use is commercial, Reddit expects permission and a contract. Self-serve app registration has tightened. Treat calendar time, eligibility risk, and rejection as part of the cost, not an edge case in the appendix. Search and comment volume dominate enrichment bills. Brand monitors and product-research crons care about keyword search and comment trees. Those paths burn QPM fast on the official API, especially when each thread needs multiple paginated comment calls. Multi-platform tax. If Instagram and TikTok already live on one vendor key, bolting on a separate Reddit OAuth stack means a second auth model, a second error shape, and a second invoice, even when the product only needed public posts. None of that means the official API is wrong. It means the meter is aimed at a different buyer. PRAW and other official wrappers inherit the same pricing and access gates. A Python library does not create a free commercial entitlement. Social Fetch as a public-data alternative Social Fetch exposes public Reddit data under /v1/reddit/...: global search, subreddit metadata, subreddit feeds, subreddit-scoped search, post comments, and post transcripts. Same envelope as the rest of the catalog. Same x-api-key. What you get on the billing side (verified on our pricing page and Credits doc, not invented for this post): 100 free credits on signup, no card Pay-as-you-go packs that do not expire (Starter is $14 for 1,000 credits; larger packs are on pricing) Most Reddit routes are 1 credit per completed lookup (see the credit badge on each API reference operation) Charge on completed lookups. Trust meta.creditsCharged. Validation errors and our infrastructure failures (lookup_failed, 503 temporarily_unavailable) do not debit. A completed empty search or not_found did run upstream and can bill No required subscription for PAYG; optional monthly plans if volume is steady No hard QPM cap on paid metered routes. Your credit balance is the practical limit You do not get private subreddits, inbox access, or Reddit-native write scopes. That is intentional. Those belong on Reddit's API. Full route list: Reddit platform hub. Listening sprint patterns: Reddit research recipe. Product workflow: Reddit product research guide. Rough cost shape (not a fake rate card) Do not paste a third-party blog's Reddit dollar table into your spreadsheet and call it current. Read Reddit's developer access page and confirm what they charge for the access tier you actually need. For official Reddit, teams often quote about $0.24 per 1,000 API calls when commercial access is granted. Reddit does not publish a standard self-serve rate card beyond that figure in third-party reporting. Packaging (minimum spend, bundled call volumes) varies by contract. For Social Fetch, model from known pack math: | Monthly volume (mostly 1-credit pages) | Credit sketch | Pack sketch | | --- | --- | --- | | Prototype / QA | tens to hundreds | Free 100 credits, then Starter $14 / 1k | | Light monitoring | ~1k to 5k | Starter or next pack on /pricing | | Steady enrichment | tens of thousands | Growth / Scale packs; optional subscription if you want a fixed bill | Example research sprint from our Reddit research recipe: 12 query variants x 2 pages + 20 comment pulls is about 44 credits before dedupe. Empty completed searches still bill. For a one-off query before any of those meters matter, use the free Reddit research tool (IP-capped, first page only). Side-by-side with sync peers who also cover Reddit: Social Fetch vs EnsembleData (daily unit resets) and Social Fetch vs SociaVault (PAYG peer). Marketplace discovery path: vs RapidAPI. When to stay on the official Reddit API Stay (or go) official when any of these are true: Legal or partner requirements say you need Reddit's Data API You are shipping a Reddit client, mod tooling, or user-scoped features Private or authenticated surfaces are in scope Your product is Reddit-native and the official meter already fits the P&L In those cases, Social Fetch is a complement for public enrichment elsewhere in the stack, not a substitute for Reddit OAuth scopes. Do not treat a public-data API as ToS advice or a way around Reddit's rules for Reddit-native products. Public enrichment and official compliance are different jobs. Read Reddit's terms for your use case; this is not legal advice. Use case framing once you pick a meter: Reddit research API. Alternatives worth comparing | Option | Pricing shape | Best when | | --- | --- | --- | | Official Reddit Data API | QPM quota + commercial contract (confirm live) | First-party compliance, Reddit-native products | | Social Fetch | Prepaid credits; charge on completed lookup | Public enrichment + multi-platform | | EnsembleData | Monthly plans, daily unit caps | Steady daily sync volume including Reddit | | SociaVault | Prepaid credits | Simple PAYG peer on a smaller catalog | | Apify | Platform + compute + Actor events | Custom / scheduled scrapes | | RapidAPI listings | Per publisher | Weekend discovery, not one production contract | Frequently asked questions How much does the Reddit API cost in 2026? Free for approved non-commercial use under rate limits (commonly about 100 QPM per OAuth client). Commercial access is separately priced through Reddit's review process. Teams often cite about $0.24 per 1,000 calls when access is granted. Verify against Reddit's current terms before you forecast. For public enrichment on Social Fetch, start from pricing: 100 free credits, packs from $14 / 1k, most Reddit routes at 1 credit per completed lookup. Is Reddit API pricing cheaper than scrapers? Per-call list prices are the wrong comparison. Add approval time, QPM engineering, and multi-platform adapters for the official path; add proxy and breakage time for DIY scrapers. Credit APIs trade that for a known charge per completed page. Model the job (search pages + comment pages), not a generic "API vs scrape" slogan. Do empty Reddit searches cost money on Social Fetch? Yes if the lookup completed. Zero posts is still a finished upstream search. Failures that never complete (lookup_failed, 503 temporarily_unavailable) do not charge. Check meta.creditsCharged. Where do I see per-route Reddit credit prices? On each operation in the API reference and on the endpoint cards under /platforms/reddit. The registry is source of truth. Can I use the free Reddit API for brand monitoring? Free non-commercial Reddit access is not a commercial brand-monitoring entitlement by default. If your product sells monitoring or enrichment, read Reddit's commercial terms and pick either their approved commercial path or a public-data API that fits your compliance posture. --- Smoke-test a search in the playground, or start with 100 free credits on pricing. Route docs and examples: Reddit hub. For keys and rate limits, read How to get a Reddit API key.
---
# Why social media APIs should be boring
Source: https://www.socialfetch.dev/blog/social-data-should-be-boring
# Why social media APIs should be boring
If your product relies on social data, stop building brittle scrapers. Predictable JSON APIs are how you scale social pipelines.
**Read on the site:** https://www.socialfetch.dev/blog/social-data-should-be-boring
If your product touches social networks (marketing analytics, creator CRM, brand safety, AI research), you have probably watched "fetch public posts" turn into a permanent side project. A CSS selector moves on Instagram and your ingestion job returns empty arrays. A platform renames a field inside a script tag and your TypeScript types lie for a week before anyone notices. You get paged at 2 a.m. for a parser you wrote six months ago and forgot existed. We built Social Fetch because that maintenance work belongs in an API layer, not on your product roadmap forever. One REST surface covering 20 platforms. Stable JSON shapes. A requestId on every response so support can trace a call without guessing which worker ran it. The boring API manifesto "Exciting" social integrations usually mean headless browsers, proxy rotation, and schema drift you discover in production. What teams actually need is the opposite: field names that stay put, HTTP errors you can map to retries, API keys you rotate from a script, and billing that matches how lookups actually finish. Product teams should ship features. They should not babysit scrapers. One integration path beats five slightly different hacks, especially when someone asks for a second platform by Friday. If we cannot debug a failed call from a request ID, the API is not finished. > The best social data pipeline is the one your future self does not recognize in git blame, because it has not needed a fix in two years. Smoke test before you spend credits Before you hit a metered route, call GET /v1/whoami. It checks your API key and costs nothing. Same smoke test as the Quickstart. TypeScript version. Keys go in the x-api-key header (server-side only, not a browser token): Metered routes bill differently. Credits charge when a lookup completes, including not_found and private outcomes that come back as HTTP 200 with a lookupStatus in the body. Pre-send validation errors, lookup_failed, and 503 temporarily_unavailable do not bill the same way. Reconcile your ledger against meta.creditsCharged, not your request count. Full rules: Credits. One envelope for success and errors Successful responses wrap payloads in . meta carries requestId, creditsCharged, and the API version. Errors use the same shape so you always know what to paste into a support ticket. Log meta.requestId on every call. We learned that the hard way; see The Scrape Job That Never Timed Out. Typed error bodies live in the Errors guide. Per-route credit costs are in the API reference; plan volume on Pricing. API keys use the sfk_ prefix and travel in the x-api-key header. Details: Quickstart — authentication. Browser bundles and mobile apps are the wrong place for API secrets. Call Social Fetch from your backend, edge worker, or cron job. When a custom scraper still makes sense Sometimes a one-off script is the right tool. You need one obscure page, or you are proving something over a weekend. Fine. Narrow, human scope: a custom script is fine. Core product on a schedule across platforms: you want versioning, SLAs, and someone else on pager duty when upstream HTML changes. Where to go next Check Pricing before you commit to a ship date. Wire auth and error handling before you parallelize heavy fetches (Quickstart, Errors). Skim route coverage in the API reference before you lock a database schema. } /> } /> } /> } /> Boring plumbing. Interesting products on top. That is the split we want.
---
# The Scrape Job That Never Timed Out
Source: https://www.socialfetch.dev/blog/social-media-scraper-api-reliability
# The Scrape Job That Never Timed Out
Early in Social Fetch, LinkedIn scrapers ran for hours without failing — and the invoice arrived before the error did. A post-mortem on silent failure.
**Read on the site:** https://www.socialfetch.dev/blog/social-media-scraper-api-reliability
I have been writing scrapers for years. They break loudly. Selectors move, blocks tighten, auth flows change. You learn to expect that. The incident that shaped Social Fetch was quieter. Early in development, before we had a polished public API and before every response carried a requestId, 37 in-house scraper jobs against LinkedIn company pages did not finish and did not fail. They ran for hours. CPU and memory climbed. Sessions stayed open. Nothing returned a terminal HTTP status, because from the worker's point of view the work was still in flight. So I waited. Then I worked on something else. Scraping is slow sometimes; that felt normal. It was not slow. It was stuck. I did not find out from logs or alerts. I found out from billing: a line item north of $4,000 for compute that produced no useful JSON for anyone. No error code to grep. Nothing to paste into a support ticket. Just success-shaped silence with an invoice attached. That week hurt. It also taught me what a production social media scraper API has to guarantee before platform names or parsed JSON matter. Thirty-seven jobs that would not die LinkedIn is a hard platform. Strong blocks, flaky page shapes, constant churn. We were wiring up company-page routes, the unglamorous work before you have docs and a marketing site, and running real lookups against live pages to see if the parsers held. Somewhere in that batch, 37 jobs never reached a done state. Not 37 failures. Thirty-seven processes that kept chewing resources because nothing told them to stop. I only know the count because I traced back through job IDs after the bill landed. During the run itself, the dashboard looked boring. No spike in 5xx errors. No red banner. Just work that never quite finished, which is easy to misread as "LinkedIn being LinkedIn." An outage is embarrassing but legible: users see errors, you roll back, you explain in Slack. This was quiet spend with no failure signal. Three states, one invoice Afterward I kept thinking about a dumb taxonomy that turned out to be useful: | State | What your app thinks | What your wallet feels | | --- | --- | --- | | Succeeded | Got JSON, shipped the feature | Expected cost | | Failed loud | Error code, retry or stop | Often cheap or zero | | Failed quiet | Still "running" | Keeps ticking | Most engineering effort goes to the first two rows. The third row is where scraper projects bleed money while dashboards stay calm. If your integration cannot tell "running" from "broken" inside a bounded time, you do not have a data pipeline. You have a meter in another room. That was us, early on. What we changed We did the unsexy things you would expect after a four-figure surprise, then shipped them as product surface, not internal trivia. Hard timeouts, documented publicly Every route class got a maximum duration. If a LinkedIn company lookup cannot finish in a bounded window, it fails with a typed error instead of chewing RAM all afternoon. Timeout behavior is part of the contract now, not a hope. Terminal states only A request is done when the client gets a response with meta.requestId and a known outcome: data, not_found, lookup_failed, or a documented HTTP error. "Still thinking" is not a production state. Charge on completed lookups Metered routes bill when a lookup completes, not when you send the request. A finished call returns meta.creditsCharged, whether the outcome is found data, not_found, or private on HTTP 200. Pre-send validation errors, upstream lookup_failed, and 503 temporarily_unavailable do not bill the same way. Reconcile your ledger against meta.creditsCharged, not your request count. Full rules: Credits. The stuck-job version of this problem is worse: no JSON, no clear debit line, just compute ticking in the background. The envelope before the payload Same JSON shape on success and failure. Credits visible on metered routes. Error codes you can branch on. We wrote the design essay in The Envelope is the Product. The post-mortem version is simpler: if support cannot debug your call from one ID, the API is unfinished. Thorough testing before parallel runs Smoke-test with GET /v1/whoami (free, no credits) before you fan out real lookups. The Quickstart and boring API post walk through the pattern. I wish I had treated "one stuck job in staging" as a release blocker instead of a shrug. Redundant passes when something smells wrong If a lookup looks unhealthy, we spin up another attempt at the same task. The first pass might have died in a ditch; the second often succeeds. That choreography is our problem, not the customer's. None of this is novel computer science. It is what you build after you pay tuition on row three of the table. The stupid assumption The embarrassing part: I assumed "no errors" meant "fine." I had scripts and workers. I had tests that passed on happy paths. I did not have a habit of asking, every time I kicked off a batch, what happens if this never returns. Timeouts felt like pessimism. They were insurance. I also treated manual review as optional: glance at dashboards when I remembered, trust that loud failures would find me. Stuck jobs do not always show up as error spikes. CPU creep does not always move the HTTP graph. The invoice moved it. I already knew scraping is hard. The lesson was narrower: silent failure costs more than loud failure, and your observability has to hunt for silence on purpose, not just count 500s. We are more thorough now. That bill bought the boring stuff. What customers actually ask Fixing the plumbing changed the conversations we have. I thought eval calls would open with "Do you support Pinterest?" or "How many rows per dollar?" They still do sometimes. What closes deals, especially with high-volume teams running serious throughput, is duller: "What happens when it breaks, and how will I know?" Retry mechanics. When data is temporarily off versus wrong. What to log. When to retry 503 temporarily_unavailable versus email support@socialfetch.dev. One larger client walked through that in detail before they pointed production traffic at us. Same question as the invoice lesson, just in customer clothes: they are outsourcing failure modes. They want the boring ones handled. We publish ~3.2s average latency on live fetches and 99.8% uptime over the last 90 days. Those numbers are table stakes. The product is what happens on the bad requests, and whether you can name a single requestId when something looks wrong. Our support inbox is on alert like any other on-call surface. Acknowledge quickly, fix fast, close the loop with a short breakdown. For incidents that matter, we write them up. Where to read more For the "boring social data" philosophy, see Why Social Media APIs Should Be Boring. For integration and retries, Quickstart and Errors. For platform comparisons, Bright Data and Apify. For the founder story in someone else's words, read Takanari's AI Plaza interview . I am still making sure nothing runs for hours without telling anyone. Once was enough.
---
# The envelope is the product (API design)
Source: https://www.socialfetch.dev/blog/the-envelope-is-the-product
# The envelope is the product (API design)
Why stable response wrappers (request IDs, credits, typed errors) matter as much as the payload when you integrate social APIs.
**Read on the site:** https://www.socialfetch.dev/blog/the-envelope-is-the-product
When you evaluate a new API, the demo sells you on the payload: the parsed TikTok post, the YouTube transcript, the nested creator profile. In production, you spend most of your time on the envelope, the wrapper around that payload. The envelope is the meta object with your request ID, credit usage, and API version. It is the typed error body that mirrors the happy path. It is what keeps a pipeline running for a year instead of paging you at 2 a.m. when upstream HTML shifts. The quiet contract of API design Raw platform JSON mirrors whatever a social network shipped last Tuesday. Your app should not have to reverse-engineer field renames to learn what happened. A quiet contract is boring on purpose: the same top-level shape on success and failure, one place to read requestId and what the call cost, and errors you can branch on instead of scraping HTML to guess the failure mode. That predictability is the gap between "we wired up an Instagram integration" and "we can run this job every night without babysitting parsers." What a production API envelope carries A good envelope answers four questions without opening a support thread: which request was this, what did it cost, what broke, and which API version answered. On Social Fetch, successful responses pair data with meta. The meta object carries requestId, creditsCharged on metered routes, and version. Errors use the same envelope shape documented in Errors, so handler logic stays in one code path. Example metered call, using the same x-api-key header from the Quickstart: GET https://api.socialfetch.dev/v1/tiktok/profiles/charlidamelio (data is trimmed for readability. Log and paste meta into support tickets.) Follower counts above illustrate response shape, not a live scrape from this article's publish date. Branch on data.lookupStatus before you write rows. Credits bill on completed lookups Metered routes charge when a lookup completes, as documented per endpoint. That includes HTTP 200 outcomes like not_found or private where the body still carries a lookupStatus. Pre-send validation errors, lookup_failed, and 503 temporarily_unavailable do not bill the same way. Reconcile your ledger against meta.creditsCharged, not your request count. Per-route costs live in the API reference. Full billing rules: Credits. API debuggability in production The envelope turns "something in the app broke" into a bounded incident. You get one requestId to log and paste, not a user trying to explain which button they clicked. Log meta.requestId on every call, success or failure. Surface it in internal logs or your own error UI when you re-wrap responses. That is how you trace a Tuesday pipeline miss without guessing proxy health. Why social data APIs need this more Social platforms change HTML layouts, rate limits, and edge cases on their own schedule. Your fetch layer will fail in ways outside your control. When that happens, you need honest domain data when the fetch works and honest operational data when it does not. The envelope is where the operational data lives. It moves connection maintenance off your team and onto the API provider. Where to go next Start with the Quickstart for auth headers and a free GET /v1/whoami smoke test. Keep Errors open while you wire retry logic. Plan volume from meta.creditsCharged on Pricing.
---
# Twitter Search API — Keyword Filters on X
Source: https://www.socialfetch.dev/blog/twitter-search-api
# Twitter Search API — Keyword Filters on X
Search public X/Twitter posts by keyword with filters and cursor pagination. REST API for alerts and research — prepaid credits, charge on completed lookup.
**Read on the site:** https://www.socialfetch.dev/blog/twitter-search-api
Brand alerts, financial research, and competitive dashboards usually need the same primitive: keyword search over public X posts, returned as JSON you can log, dedupe, and ship to Slack without running a headless browser. Social Fetch exposes GET /v1/twitter/search for that job. Pass a query string, optional filters, engagement floors, and a cursor for the next page. Every response uses the same envelope as the rest of the API, with meta.requestId on every call. Two credits per completed lookup. Charge on completed lookup: HTTP 200 with zero tweets still bills; lookup_failed and HTTP 503 do not. Same auth header and envelope as TikTok, YouTube, Reddit, and Instagram. Full parameter list in the API reference. Why DIY X search breaks Rolling your own X search works in a notebook. In production it turns into maintenance. Search pages expect a logged-in or guest session with valid cookies and CSRF tokens. Tokens expire. The cron that worked Tuesday can return an empty DOM on Wednesday. X ships UI changes without a changelog. The article selectors and __NEXT_DATA__ blobs you parsed last month move or shrink. Silent partial HTML is worse than a hard error: your dashboard shows zero mentions while a browser shows plenty. Residential proxies, fingerprint rotation, and backoff logic eat engineering time. Success rates drop when a subnet gets flagged. You still pay for the proxy round trip when the page loads a challenge instead of results. Infinite scroll on the web does not map cleanly to page two. Cursor tokens are opaque, short-lived, and tied to the search context. Replaying them from a stale session fails in ways that look like "no more results." DIY also means your IP addresses hit X directly. You own logging, retention, and incident response when a scrape breaks during a demo. A data API does not remove your obligations around lawful use of public data. It moves session handling, upstream breakage, and normalized output to infrastructure that is supposed to be boring. What GET /v1/twitter/search gives you Pass a query string and optional filters. The endpoint supports the operators users expect from the native search box: OR, quoted phrases, negation with -. section accepts top, latest, people, photos, or videos. Use latest for crisis watches and hourly polls; use top for weekly recap dashboards. Engagement floors (minLikes, minRetweets, minReplies) drop low-signal noise before your warehouse insert. startDate and endDate use YYYY-MM-DD; language (for example en) narrows the corpus for sentiment work. Successful responses match every other Social Fetch route: The people array fills when section=people. For tweet sections, expect tweets in data.tweets. Log meta.requestId and meta.creditsCharged on every poll. When a customer asks why Tuesday's alert missed a post, you want a support trail, not a guess about proxy health. Pagination and billing Responses include data.page.nextCursor and data.page.hasMore. Pass the cursor back as the cursor query parameter on the next request. Do not invent scroll tokens. Use exactly what the previous response returned. Search costs 2 credits per completed lookup. Confirm on every response via meta.creditsCharged. That follows the charge-on-completed-lookup rule documented in Credits: we bill when the upstream fetch completes and we return HTTP 200. Search routes do not expose lookupStatus the way profile lookups do, but the billing shape is the same. An empty data.tweets array still means the lookup ran and bills. | Outcome | Charged? | | --- | --- | | Pre-send validation error (bad query format, invalid cursor) | No | | lookup_failed / HTTP 503 | No | | HTTP 200 with zero tweets in data.tweets | Yes (completed lookup) | | HTTP 200 with tweets returned | Yes | Empty results still cost credits because the upstream search still ran. That matches DIY scraping too: you paid for the proxy round trip when the page loaded but the index had nothing new. Here the cost shows up as prepaid credits with a requestId, not a mystery AWS line item. Retry lookup_failed and HTTP 503 with exponential backoff. Those outcomes are not charged. Do not retry validation errors. Fix the query. For high-volume polling, model credits before you turn on aggressive cadences: keywords × polls_per_day × 2 credits. Three brand terms polled hourly on X alone is about 144 credits per day before pagination. Cron polling pattern Most search integrations are cron jobs: load watch terms, call the API, upsert new posts, alert on spikes. Keep audit metadata on every run. Tune minLikes per watch group. Crisis terms can run with no floor; brand terms can use a higher bar. Store requestId on poll_runs, not only on individual mentions. You will need it when reconciling credit burn against finance. Dedupe on post ID, not poll timestamp. The same tweet can match multiple watch terms. Paginate until hasMore is false or your credit budget stops you. Deep pagination multiplies the 2-credit cost per poll. Split cadence by severity: crisis terms every 5–15 minutes, brand terms hourly or daily. Alert fatigue is a product bug. Fan out per watch term (QStash, a queue, or one serverless invocation per term) so a slow Reddit poll does not block your X crisis watch. For a full multi-platform listening stack (schema, spike detection, troubleshooting), see Build a Social Listening Dashboard. Official X API vs Social Fetch Use the official X API when you need write access (posting, replying, DMs, OAuth on behalf of users), when your volume fits a published tier and you accept X's rate limits, or when compliance or procurement requires a first-party vendor relationship. Use Social Fetch when you need read-only search JSON without negotiating enterprise contracts: keyword alerts, brand monitoring, and research dashboards that poll public posts, with the same auth header and envelope you already use for TikTok, YouTube, Reddit, and Instagram. We are not claiming parity with every X API tier or every private field behind login. Check route coverage in the API reference before you design around an endpoint. When an official route exists and is affordable for your volume, use it. This guide is for the gap where browser-parity search matters and first-party pricing does not. For the pricing fork (official X meter vs public-data credits), see Twitter / X API pricing. API keys use the sfk_ prefix and travel in the x-api-key header. Call Social Fetch from your backend, edge worker, or cron, not from a browser bundle. Get started If you need a Twitter keyword search API you can call from a backend cron or a live product feature, start here: API reference for parameters and response shapes Quickstart for auth and the success envelope Playground to try queries in the browser Pricing to model volume New accounts get 100 free credits. Run your watch list for a week, log success rate and credit burn, then decide whether to keep DIY on life support or ship the boring API path.
---
# Twitter/X API pricing in 2026 (what you pay)
Source: https://www.socialfetch.dev/blog/twitter-x-api-pricing
# Twitter/X API pricing in 2026 (what you pay)
How X API pricing works for new developers, when official access is worth it, and when a public-data API is cheaper.
**Read on the site:** https://www.socialfetch.dev/blog/twitter-x-api-pricing
"Twitter API pricing" and "X API pricing" are the same question with two brand names. Teams search it when a monitoring cron, creator scorecard, or research agent needs public profiles and posts. Then they land in X's developer console, which prices first-party access for a bigger product than "pull this handle." Use the official X API when you need posting, OAuth-on-behalf-of, elevated first-party products, or a contract that must say "X." Use Social Fetch when you need public profiles, tweets, replies, search, communities, or transcripts without an X developer app. Prepaid credits, same envelope as TikTok and Instagram, charge only on completed lookups (not on our infrastructure failures). Confirm live X rates in the developer console; packaging has moved more than once. Which path fits your job | Job | Prefer | | --- | --- | | Post or DM as a user, first-party compliance products | Official X API | | Public profile card, recent posts, keyword search for enrichment | Public-data API (Social Fetch X hub) | | Custom batch scrape / niche fields | Marketplace Actor (see vs Apify) | | Sync social peer with different billing shape | EnsembleData or SociaVault | If your ticket says "Twitter API" but the acceptance criteria are "confirm the handle exists and store follower count," you are not buying write scopes. You are buying a profile GET. What "Twitter API pricing" usually means Three different products get collapsed into one phrase: 1. Official X developer products: apps, scopes, rate limits, and whatever credit model X is selling this quarter. Source of truth: developer.x.com (pricing lives in the console and X's docs; it changes). 2. Public enrichment APIs: third-party REST for publicly visible profiles and posts. No X developer app. You pay the vendor's credit or unit meter. 3. Scrapers and Actors: run-based or browser automation. Useful for custom fields; a different ops and compliance model than sync REST. Mixing (1) and (2) is how budgets blow up. Official access is priced for X's product surface (writes and elevated reads). Public enrichment is priced for "lookup this URL / handle and return JSON." If someone on your team still asks whether X has an API at all, see Does Twitter (X) have an API?. Why official X pricing hurts enrichment jobs A few structural reasons show up in almost every evaluation, regardless of the exact dollars on X's page today. Official products assume apps, review, and scopes. That overhead is correct when you post as users. It is dead weight when you only enrich public handles. Packaging moves. X shifted from free allowances and fixed monthly tiers toward pay-per-use credits for new signups. Legacy plan names still float around in old blog posts and RFPs. Treat third-party "Basic is $X" screenshots as history until you confirm in the developer console. Search and read volume dominate enrichment bills. Brand monitors and research crons care about keyword search and profile reads. On X's pay-per-use meter, reads often bill per resource returned: a search that returns 20 posts can be 20 post reads, not one API call. Pay-per-use also carries a post-read cap (commonly cited at 2 million reads per month before Enterprise). That is exactly where official math hurts first, and where a public-data alternative is easiest to justify. Multi-platform tax. If Instagram and TikTok already live on one vendor key, adding a separate X developer stack means a second auth model, a second error shape, and a second invoice, even when the product only needed a public bio. The official API is aimed at a different buyer than a profile-card cron. That is a meter mismatch, not a quality judgment. Social Fetch credit math for public X data Social Fetch exposes public X data under /v1/twitter/...: profile by handle, profile tweets, tweet detail, replies, tweet transcript, keyword search, hashtag search, community detail, and community tweets. Same envelope as the rest of the catalog. Same x-api-key. Billing rules (from our pricing page and the Twitter API reference, not invented for this post): New accounts get 100 free credits, no card. Pay-as-you-go packs do not expire. Starter is $14 for 1,000 credits; larger packs are on pricing. Most Twitter routes cost 1 credit per completed lookup (profile GET, single tweet, transcript, community routes). Search, hashtag search, profile tweet pages, and reply pages are documented at 2 credits. Check the credit badge on each operation before you model a cron. Charge on completed lookups. Trust meta.creditsCharged on every response. Validation errors and our infrastructure failures (lookup_failed, 503 temporarily_unavailable) do not debit. A completed not_found still ran upstream and can bill. No required subscription for PAYG. Optional monthly plans if volume is steady. No enforced RPS cap on paid metered routes; your limit is credit balance. You do not get posting, DMs, or X's elevated first-party products. Those belong on X's API. Full route list: X (Twitter) platform hub. Search filters and pagination: Twitter search API. Vendor shortlist: Best Twitter/X data APIs in 2026. Rough cost shape (not a fake rate card) Do not paste a third-party blog's X dollar table into your spreadsheet and call it current. Open X's developer pricing (or the console) and read what they charge for the endpoints you will call. For new pay-per-use signups in 2026, X commonly bills per resource fetched (for example, post reads around $0.005 each and user reads around $0.010 each). Writes and URL-bearing posts cost more. Rates and caps change. The console is the source of truth. For Social Fetch, model from known pack math: | Monthly volume (mostly profile GETs) | Credit sketch | Pack sketch | | --- | --- | --- | | Prototype / QA | tens–hundreds | Free 100 credits, then Starter $14 / 1k | | Light monitoring | ~1k–5k | Starter or next pack on /pricing | | Steady enrichment | tens of thousands | Growth / Scale packs; optional subscription if you want a fixed bill | If half your calls are search or paginated tweet/reply pages, multiply by the documented 2-credit cost before you compare vendors. Empty result pages can still complete a lookup. Budget for that, or cache known-good queries. Side-by-side with sync peers who also cover X: Social Fetch vs EnsembleData (daily unit resets) and Social Fetch vs SociaVault (PAYG peer). Marketplace discovery path: vs RapidAPI. When to stay on the official X API Stay (or go) official when any of these are true: You need write paths (post, reply, like, follow) or member OAuth Procurement or counsel requires X-signed access and compliance products You need elevated first-party surfaces that third parties cannot honestly sell Your product is X-native and the official meter already fits the P&L In those cases, Social Fetch is a complement for public enrichment elsewhere in the stack. It is not a substitute for X's write API. Alternatives worth comparing | Option | Pricing shape | Best when | | --- | --- | --- | | Official X API | X's current credits / tiers (confirm live) | Writes, OAuth, first-party contracts | | Social Fetch | Prepaid credits; charge on completed lookup | Public enrichment + multi-platform | | EnsembleData | Monthly plans, daily unit caps | Steady daily sync volume including X | | SociaVault | Prepaid credits | Simple PAYG peer on a smaller catalog | | Apify | Platform + compute + Actor events | Custom / scheduled scrapes | | RapidAPI listings | Per publisher | Weekend discovery, not one production contract | Frequently asked questions How much does the Twitter / X API cost in 2026? Official prices live on X's developer site and console; they have changed more than once. New signups in 2026 typically land on pay-per-use credits, not the old fixed Basic / Pro tiers. Do not trust a screenshot from an old tier post without checking current packaging. For public enrichment on Social Fetch, start from pricing: 100 free credits, packs from $14 / 1k, search and other heavier Twitter routes at 2 credits per completed lookup. Is there a free Twitter API? X's free and low tiers have been restricted or reworked over time. Treat "free" as whatever X documents today, not as unlimited production search. Social Fetch gives 100 free credits with no card. That is enough to verify a profile GET and a search call, not a substitute for free infinite reads. Twitter API vs X API: different prices? Same platform. "Twitter API pricing" and "X API pricing" refer to the same official products under the rebrand. Public-data alternatives are a separate category. Do I pay when a handle is missing on Social Fetch? A completed lookup that returns not_found can charge. The upstream ran. You are not charged for lookup_failed or 503 temporarily_unavailable. Details: pricing billing FAQ and meta.creditsCharged on every response. Where do I compare vendors without rebuilding a spreadsheet? Start with Best Twitter/X data APIs in 2026, then the compare pages for EnsembleData, SociaVault, Apify, and RapidAPI. Smoke-test a profile or search in the playground, or start with 100 free credits on pricing. Route docs and examples: X (Twitter) hub.
---
# The official TypeScript SDK for Social Fetch
Source: https://www.socialfetch.dev/blog/typescript-sdk
# The official TypeScript SDK for Social Fetch
Install @socialfetch/sdk for typed API calls, Result-based errors, unwrap helpers, and route-aligned methods across every public platform.
**Read on the site:** https://www.socialfetch.dev/blog/typescript-sdk
If you are calling the Social Fetch API from Node.js or an edge worker, you can keep writing fetch wrappers. The SDK is for when you want method names that match the REST routes, typed response bodies, and one failure model you can branch on without re-reading the OpenAPI spec every week. The package is @socialfetch/sdk on npm. Install it, pass your API key, and call the same routes you would hit over HTTP: What the SDK gives you SocialFetchClient exposes a namespace per platform (tiktok, instagram, twitter, reddit, linkedin, and the rest), plus web for URL extraction, auth.whoami() and billing.getBalance() for free connectivity checks, and top-level health() and ask(). Method names map to HTTP routes: client.tiktok.getProfile( ) is GET /v1/tiktok/profiles/ , client.instagram.getPost( ) is GET /v1/instagram/posts, and so on. Expected API and runtime failures come back as instead of thrown exceptions. Successful calls return where value is the same envelope the REST API returns, including meta.requestId, meta.creditsCharged, and meta.version. The SDK is not a separate product with different rules. It is the documented API with TypeScript types on top. Run it from your backend, Cloudflare Worker, or cron job. API keys belong server-side, not in browser bundles. Result-based error handling SDK methods return a Result type. That keeps the failure path next to the call: Log error.requestId on failures. Branch on error.code to decide whether to retry, skip a record, or show a message upstream. The SDK normalizes API errors (unauthorized, insufficient_credits, lookup_failed) and client-side failures (network_error, parse_error) into the same shape. Prefer exceptions? Use unwrap Some codebases prefer try/catch. Import unwrap() and it throws SocialFetchUnwrapError when result.ok is false: Either pattern keeps the same normalized error details. Pick the one that matches how the rest of your app handles failures. Domain outcomes vs SDK failures The SDK preserves the API's outcome semantics. A route can return HTTP 200 with data.lookupStatus: "not_found", "private", or "restricted". That is a completed lookup with domain data, not an SDK failure. After result.ok is true, read result.value.data.lookupStatus (when the route provides it) before you touch profile or post fields. Log result.value.meta.requestId whenever you need to trace a call in support. Some list routes omit lookupStatus and can return empty arrays for more than one reason. See Errors for disambiguation patterns. Billing on completed lookups Metered routes charge credits when we complete a lookup attempt, same as raw HTTP. That includes not_found, private, and restricted outcomes that come back as HTTP 200 with a lookupStatus in the body. Pre-send validation errors, lookup_failed, and 503 temporarily_unavailable do not bill the same way. Reconcile your ledger against meta.creditsCharged on every response, not your request count. Per-route costs are in the API reference. Full rules: Credits. Before you hit metered routes in a new environment, call client.auth.whoami(). It checks your API key and costs nothing. Get started Start with the TypeScript SDK guide for install steps, Result handling, and unwrap() details. Keep the SDK reference open for the method inventory and route mapping. Use the API reference when you need exact params and schemas. If this is your first integration, read Quickstart for auth headers, Errors for retry rules, and Pricing to model volume. } /> } /> } /> } /> Same envelope as curl. Fewer hand-written wrappers.
---
# Web scraping API: markdown & HTML for LLMs
Source: https://www.socialfetch.dev/blog/web-extraction-api
# Web scraping API: markdown & HTML for LLMs
Pass a public URL and get markdown, HTML, or a grounded answer back. One Social Fetch key — one credit per completed lookup.
**Read on the site:** https://www.socialfetch.dev/blog/web-extraction-api
Teams already using Social Fetch kept hitting the same wall: the pipeline does not stay inside social platforms. You pull a TikTok profile and then need the Linktree in the bio. You monitor a competitor on X and then need the pricing page they linked. A research agent spends half its context on blog posts and docs, not Instagram posts. Every time, the fix was a second stack: a Puppeteer container to babysit, a generic scraping API with different auth and billing, or a /utils/scrape.ts that broke when a site moved a CSS class. Pass a public URL, get structured content back. Same x-api-key, same response shape, same credit wallet as TikTok and Instagram lookups. The problem with traditional web scraping Social Fetch already covered the social side. The painful part was everything linked from it: a creator's Shopify store, a competitor's pricing page, docs your agent needs to read, press releases attached to viral posts. Handling those URLs meant a second vendor, a second billing model, and usually headless browsers you did not want to operate. One integration path for "I need the text from this URL" is simpler than evaluating another scraping product every time a bio link shows up. How the web extraction API works Four routes live under /v1/web/, using the credentials and JSON envelope you already have: Extract to Markdown: page text with optional fit, raw, or bm25 filters Extract to HTML: sanitized HTML when downstream code expects markup Ask a Web Page: pass a URL and a question, get a grounded answer Crawl Multiple URLs: up to five URLs in one synchronous request, with per-page rows Each route is documented in the API reference. Pricing per operation is on that page; confirm what actually billed with meta.creditsCharged on every response. Markdown, HTML, and ask responses include data.lookupStatus. On found, content fields are populated. On restricted, the page hit bot or access protection and content fields come back null. That is still HTTP 200, not a retry signal. See Errors. fit (default): readability-oriented text, nav stripped out. raw: fuller DOM-to-markdown conversion. bm25: passages ranked against a query you pass (required when filter=bm25). Crawl takes one or more url query parameters (repeat the param for each page, max five). You get data.results with a row per URL plus data.summary counts. It does not follow links or spider a domain. Only the URLs you pass. Billing on completed lookups Credits are charged when we complete a lookup attempt, same as profile and post routes. Read Credits for the full model. For markdown, HTML, and ask: | Outcome | Charged? | | --- | --- | | Pre-send validation error (malformed URL, missing q) | No | | lookup_failed / HTTP 503 | No | | HTTP 200 + lookupStatus: "found" | Yes | | HTTP 200 + lookupStatus: "restricted" | Yes (lookup completed, page blocked) | restricted is not empty markdown you can ignore. Treat it as a hard stop for that URL. Do not retry it expecting a different outcome. Crawl bills 1 credit per URL requested (up to five per call). Check each row's success flag and data.summary. A batch can partially succeed. meta.creditsCharged is the billing source of truth, not your own URL count. Retry lookup_failed and HTTP 503 with backoff. Fix validation errors instead of retrying them. Use cases for LLM pipelines For RAG, GET /v1/web/markdown with filter=fit strips navigation chrome and returns text you can chunk and embed. If you only need passages about one topic, filter=bm25 with a query returns ranked sections from a single page without building a search index first. Product teams use crawl to fetch a pricing page, a features page, and an about page in one call. Three URLs requested means three credits and three markdown blobs you can diff weekly. The ask route takes a URL and a natural-language question and returns an answer grounded in what is on the page: return policies, plan tiers, feature lists. You can chain it beside social calls: pull a profile, read a bio URL, fetch the linked page with the same SDK client. To discover candidate URLs by keyword first, use GET /v1/web/search. Search finds pages; markdown, HTML, ask, and crawl extract them. What this API will not do Public pages only. If a human needs a login, session token, or cookie to see the page, this API will not see it either. Bot-protected sites return lookupStatus: "restricted" on markdown, HTML, and ask. That is not a transient error you should hammer with retries. Live fetch, not a long-lived cache. Expect seconds, not milliseconds. You get the page as it exists when the request runs. Crawl is bounded: five URLs max, synchronous, no link following. Built for a short list you already have, not mirroring an entire site. Ask reads what is publicly visible on the URL. It is not open-ended chat. It answers from page content. Get started If you already have a Social Fetch API key, these routes are live. No opt-in or waitlist. Open the playground under Web, paste a URL, and inspect the response. Wire it into your backend with client.web. from the TypeScript SDK. Estimate volume on Pricing. Flat credits per operation, same wallet as social lookups. } /> } /> Social Fetch covers 20 platforms in one integration. Web extraction applies the same API key and JSON discipline to the URLs outside those networks: pages linked from bios, tweets, and posts that the rest of your pipeline still has to read.
---
# Cross-Platform Creator Profiles with One API (2026)
Source: https://www.socialfetch.dev/guides/cross-platform-creator-profiles
# Cross-Platform Creator Profiles with One API (2026)
Look up the same creator on TikTok, YouTube, Instagram, and X with one schema and one API key — no per-platform scrapers, no drifting field names.
**Read on the site:** https://www.socialfetch.dev/guides/cross-platform-creator-profiles
Agency rosters and creator databases usually start as a spreadsheet column per network: TikTok handle here, YouTube there, Instagram somewhere else. The painful part is not fetching four pages — it is deciding whether @janesmith on TikTok is the same person as @jane.smith on Instagram, then normalizing follower counts that YouTube calls subscribers and everyone else calls followers. Product teams building creator intelligence need four things at once: discovery when the roster is empty, identity linking when handles disagree, comparable metrics for ranking, and fresh numbers before a client meeting. Home-grown scrapers tend to ship those one at a time, each with its own JSON shape and breakage schedule. This guide walks through an identity resolution pass: the same workflow intelligence teams run before a campaign shortlist, but with API calls you can schedule, log, and replay. Call /v1/tiktok/profiles/ , /v1/youtube/channel, /v1/instagram/profiles/ , and /v1/twitter/profiles/ with one API key. Every response shares the same envelope — branch on data.lookupStatus, merge into one warehouse row, and log meta.creditsCharged per platform. We use a fictional mid-tier fitness creator (sarahfit) as the running example; swap in your roster handles. You'll need an API key and the TypeScript SDK or curl. Try a live lookup in the Playground. Why same handle ≠ same person DIY scrapers force you to maintain four codepaths that break on different schedules. Social Fetch removes that maintenance, but it does not remove the identity problem: platforms do not share a global user ID you can join on. | Pitfall | What goes wrong | What to do instead | | --- | --- | --- | | Exact-handle fan-out | @nova on TikTok is a dancer; @nova on X is a game studio | Treat each platform lookup as a candidate edge, not ground truth | | Ignoring bio links | CRM says sarahfit everywhere; her YouTube is SarahFitOfficial | Parse profile.bio and channel.description for declared URLs first | | HTTP 200 = data | Private Instagram returns 200 with lookupStatus: "private" | Branch on lookupStatus, not status code | | Stale CSV imports | Follower count from last quarter wins the sort | Store capturedAt and re-pull before client deliverables | When a platform changes its HTML, we absorb it upstream. Your parser keeps reading metrics.followers (or the YouTube equivalent inside metrics) instead of re-mapping subscriberCount from a new JSON blob every month. | DIY per platform | Social Fetch | | --- | --- | | Four proxy stacks, four breakage schedules | One maintained API surface | | Field names differ (followers vs subscriberCount) | Normalized metrics + profile objects | | Auth and rate-limit logic duplicated | One x-api-key header on metered routes | The response envelope Every profile route returns the same top-level keys. Your ETL can treat TikTok and Instagram identically at the outer layer: YouTube swaps profile for channel and may include metrics.subscribers — still inside data.metrics. Branch on lookupStatus before reading counts; not_found responses often omit metrics entirely. Identity pipeline at a glance Phase 0: Sketch the creator row Before the first API call, decide what one person looks like in your database. A flat table works for agencies; graph products often use a parent creators row and child creator_platforms rows. Minimum columns worth defining upfront: | Column | Example | Source | | --- | --- | --- | | creatorId | crt_8f2a | your UUID | | platform | tiktok | enum per network | | handle | sarahfit | path param you queried | | lookupStatus | found | data.lookupStatus from that call | | followers | 284000 | metrics.followers or subscribers | | capturedAt | ISO timestamp | your clock at ingest | | requestId | req_01… | meta.requestId for support | Also reserve matchMethod (declared_link, exact_handle, fuzzy_name, manual) so analysts know why two handles were linked. You will thank yourself when a client disputes a merge. Phase 1: Anchor on one network Pick the network where your seed data is most trustworthy — usually whichever handle the client gave you first, or TikTok if you discovered the creator via search. TikTok profile lookup: Reference: Get TikTok profile. One credit per completed lookup, including not_found. Read the anchor response before fanning out: If the anchor is not_found, try common variants (sarah.fit, sarah_fit) before parallelizing the other networks. Each attempt is another credit. Phase 2: Mine declared links from bios Instagram and YouTube bios are where creators paste their “real” handles. Pull Instagram first when your CRM only has a first name or brand string — link-in-bio pages often list the TikTok @ explicitly. Reference: Get Instagram profile. YouTube channel lookup accepts handle, channel ID, or URL in one request: Reference: Get YouTube channel. Extract handles from bio text with boring string rules before fuzzy matching: Feed extractUrls output into YouTube's url query param when you see youtube.com/@… or youtu.be/… links. For Linktree-style domains, fetch the profile once, store the raw bio, and let a human confirm — do not auto-merge on a landing-page redirect alone. X/Twitter uses the same path-parameter pattern as Instagram: Reference: Get Twitter profile. Phase 3: Fan out profile lookups Once you have a handle list per platform (exact handle plus any bio-derived candidates), resolve them in parallel. Every platform returns the same top-level shape, so one loop handles all four. Production version with per-platform handle map and status logging: Each result carries its own meta.creditsCharged. A four-platform pass is typically four credits when all complete, even if two return not_found. Concurrency: metered routes have no published rate cap; your balance is the limit. For imports of 5,000 creators, batch Promise.all in chunks of 50–100 so a single failure does not stall the whole file. Phase 4: Disambiguate when handles diverge Exact-handle fan-out is step one, not the finish line. Use a short decision tree: 1. Declared link in bio — if Instagram bio contains youtube.com/@SarahFitOfficial, that edge outranks guessing sarahfit on YouTube. 2. Display name + avatar hash — weak signal alone; useful when handles differ by one character (sarahfit vs sarah.fit). 3. Follower magnitude — a 2M TikTok paired with a 200-subscriber YouTube is probably wrong unless the bio says "new channel." 4. Manual queue — anything below your confidence threshold gets matchMethod: "manual" and skips auto-merge. Store unresolved platforms as lookupStatus: "not_found" on the child row instead of copying the anchor's metrics. Empty cells in a vetting UI are honest; duplicated follower totals are not. Worked example — CRM says sarahfit everywhere, but Instagram bio says youtube.com/@SarahFitOfficial: | Step | Action | Outcome | | --- | --- | --- | | 1 | GET /v1/instagram/profiles/sarahfit | found, bio contains YouTube URL | | 2 | GET /v1/youtube/channel?handle=sarahfit | not_found — wrong handle | | 3 | GET /v1/youtube/channel?handle=SarahFitOfficial | found, 98k subscribers | | 4 | Merge with matchMethod: "declared_link" | YouTube row linked to parent crt_8f2a | That middle not_found call still costs a credit. Parse bios before guessing identical handles — it is cheaper than fanning out blind and cleaner for your audit log. Confidence scoring (optional, but teams ask for it): Send low rows to a human queue. Auto-merge only high in production pipelines. Phase 5: Normalize into one card Map platform responses into one UI card without if (youtube) subscriberCount else followers scattered through React components: Pull displayName from whichever found platform you trust most — often Instagram or TikTok. YouTube's channel.title can differ ("Sarah Fit - Workouts" vs @sarahfit); show per-platform names in a detail drawer if they disagree. Example merged JSON your dashboard API might return: totalReach is a business rule — sum only found platforms, or sum with a cap per network. Document the rule in code; the API will not pick for you. Phase 6: Recent posts for engagement checks Follower count gets you on a shortlist; median views tells you whether anyone watches. After profiles resolve, pull recent uploads for creators above your cutoff. TikTok videos for the anchor handle: Instagram posts paginate the same way: References: TikTok profile videos · Instagram profile posts. Compute engagement in your warehouse — the API returns per-item metrics, not a black-box score: Call GET /v1/tiktok/profiles/ before interpreting an empty video list; list routes do not always expose private the same way profile routes do. See the capability matrix for route-specific lookupStatus behavior. For spoken-content classification, pair post captions with transcript routes when hashtags are thin. TypeScript pagination for TikTok videos (same cursor pattern as Reddit search in our other guides): Stop after two or three pages unless you are building a forensic report — most vetting workflows only need the last 12–20 posts. Phase 7: Seed lists with discovery search Identity resolution assumes you already have a name. Discovery fills the top of the funnel — keyword search on TikTok users when you expand a vertical. Reference: Search TikTok users. Persist each handle with the query that found it so you can re-run the same list after a model refresh. Filter client-side on follower floors before spending four credits per person on full cross-platform enrichment. A search page plus 200 profile fan-outs is 201 credits — fine for a targeted import, expensive as a default loop. TikTok video search (GET /v1/tiktok/search) is an alternate seed when you care about content niche more than account name — pull handles from high-view videos, then run Phase 1–5 on the unique set. Deduplicate handles before enrichment; the same creator may appear in twenty search hits. Store rows your team can audit Flatten API responses into rows your ops team already uses (Airtable, Postgres, Google Sheets): | Column | Source | Why | | --- | --- | --- | | matchMethod | your resolver | Explains auto vs manual links | | lookupStatus | per platform | Drives UI badges (private, not_found) | | followers | metrics | Sort and filter | | verified | profile.verified | Contract eligibility | | requestId | meta.requestId | Support trail when a number looks wrong | | creditsCharged | meta.creditsCharged | Client-level cost allocation | Re-pull on a cron before QBRs or campaign reviews. Credits are prepaid and do not expire between quarterly bursts, so a quiet graph between agency reporting cycles does not run up a subscription. Weekly refresh job pattern (same idea as the social listening guide, but per creator row): Write meta.requestId on every upsert. When a client says "this number is wrong," you can trace the exact lookup without re-running the whole import. Troubleshooting YouTube not_found but the channel loads in a browser Pass the full channel URL: ?url=https://www.youtube.com/@SarahFitOfficial instead of a shortened handle. Handles are case-sensitive on some legacy channels — copy the @ from the address bar. @handle and /c/ChannelName URLs refer to different identifiers; use what the creator's bio declares. Instagram found but follower count is null private accounts may return identity fields without public metrics. Check lookupStatus before showing zeros. Re-fetch if the profile was public five minutes ago; creators flip privacy settings often. TikTok handle exists; fan-out returns mixed results Regional or banned accounts can return not_found on one network only. Log requestId and retry once before marking dead. Strip @ from path params — /v1/tiktok/profiles/@sarahfit is wrong; use sarahfit. Merged card shows impossible total reach Dedupe by person, not by handle string. Two different people named alex on TikTok and YouTube should stay two parent rows until bio links confirm a merge. Do not sum private or not_found platforms into totalReach unless your product spec explicitly says to. lookup_failed or HTTP 503 Not charged. Retry with exponential backoff; pass the failed meta.requestId to support if it persists. A burst of 10,000 parallel profile calls is unnecessary — chunk work. Empty video/post lists on a found profile Genuinely inactive creators exist. Compare against metrics.videos or post count on the profile object. Paginate — first page may be empty for sort windows; check data.page.hasMore. Rate limits No hard rate cap on metered routes; your credit balance is the practical limit. Chunk large backfills (50–100 concurrent profile calls) so retries stay manageable. SDK Result errors vs lookupStatus result.ok === false means transport or auth failed — check result.error.code and result.error.requestId. result.ok === true with lookupStatus: "not_found" is a successful, billable domain outcome. Do not retry those unless the handle string changed. Billing and credit budgeting Each profile lookup is typically 1 credit when the call completes, including not_found and private. You are not charged for validation errors, lookup_failed, or 503 temporarily_unavailable. Rough math for planning: | Step | Calls per creator | Credits (approx.) | | --- | --- | --- | | Anchor TikTok profile | 1 | 1 | | Bio-driven Instagram + YouTube + X fan-out | 3 | 3 | | Recent TikTok videos (1 page) | 1 | 1 | | Recent Instagram posts (1 page) | 1 | 1 | | Enriched creator row | 6 | 6 | Import 500 creators with full enrichment: ~3,000 credits. Discovery search adds 1 credit per results page before you filter. Agency tip: log meta.creditsCharged per creatorId and bill clients per import job using your own ledger. Public data only — lawful use is on you under Terms. Full matrix: Credits. Batch import spreadsheet (500 rows, enrich everyone): | Stage | Calculation | Credits | | --- | --- | --- | | Profile fan-out (4 networks × 500) | 2,000 | 2,000 | | Skip not_found anchors (~8%) | −160 × 3 remaining calls | −480 | | Video/post page for top 200 by followers | 200 × 2 | 400 | | Net estimate | | ~1,920 | Run anchor lookup first and short-circuit dead rows — most savings come from not fanning out when TikTok returns not_found on a typoed handle. What you can build Influencer vetting — reconcile CRM handles against live follower counts and flag private accounts before outreach. Cross-platform leaderboards — rank by summed reach with per-platform drill-down when totals tie. Agency reporting — one dashboard template; platform tabs read the same JSON parser. Creator graph products — parent/child rows with matchMethod provenance for merge audits. Engagement benchmarks — median views per post across TikTok and Instagram for the same resolved person. For a product-level overview of discovery, scoring, and refresh cadence, see the creator intelligence use case. --- Next steps: Playground · Creator intelligence use case · TikTok scraping guide · API reference · Pricing
---
# How to Pull Facebook Group Posts with an API (2026)
Source: https://www.socialfetch.dev/guides/facebook-group-posts
# How to Pull Facebook Group Posts with an API (2026)
List posts from a public Facebook group as paginated JSON — sorted feeds, cursors, comments, and cron-friendly workflows.
**Read on the site:** https://www.socialfetch.dev/guides/facebook-group-posts
Facebook groups hold the conversations brand pages miss — ISO requests in a city buy/sell group, franchise operators comparing vendors, parents trading daycare waitlist tips. Meta does not ship a clean export for any of it, and the Graph API was never built for polling arbitrary public groups on a schedule. This guide walks through a monitoring sprint — the same steps a local ops analyst runs manually, but with API calls you can cron, dedupe, and route to Slack. GET /v1/facebook/groups/posts?url= returns a page of posts. Pass sortBy for feed ordering, cursor for pagination, and GET /v1/facebook/posts/comments when replies carry more signal than the post body. We use Austin-area buy/sell and local services groups as the running example; swap in your metro and vertical. You'll need an API key. Test with a public group URL in the Playground. Why groups beat brand pages for local intel Official pages show what a business wants you to see. Groups show what people ask each other when no one is selling. Three patterns show up in local and vertical monitoring: Intent in plain language — "ISO queen mattress, pickup only" or "anyone know a good plumber in Round Rock?" beats a branded lead form for understanding demand. Geography baked into membership — a group named after a suburb or metro already scopes your territory. You do not need geocoding on every row. Negotiation in comments — the post might be one line; price talk, vendor names, and complaint details often sit in replies. Franchise ops, real estate investors, home services, and resale marketplaces use group feeds for territory scans. The API work is collection and dedupe — your rules still decide which posts warrant a human. Only collect public data and respect group rules and Terms. Private groups are out of scope. Phase 0: Define the job before the URL list Before touching code, write one sentence the sprint must answer. Vague goals produce noisy alerts. | Monitoring job | Example question | Bad default | Better default | | --- | --- | --- | --- | | Buy/sell inventory | What moved under $500 this week? | sortBy=top | chronologicalListings, hourly poll | | Service requests | Who asked for a plumber today? | scrape one page once | chronological, keyword plumber OR recommend | | Brand complaints | Did anyone mention our franchise? | read the group manually | recentActivity, brand name in client filter | | Vendor research | Which suppliers get named in trade groups? | top only | recentActivity + comment pulls on short posts | Tag each group in your spreadsheet with: 1. Sort order — marketplace groups usually want chronologicalListings; debate threads want recentActivity. 2. Poll cadence — hourly for buy/sell, daily for slow vertical groups. 3. Page depth — how many cursor pages per run (see Phase 4 for credit math). 4. Comment policy — pull comments when commentCount exceeds a threshold or when the post text is under 80 characters. You will wire these tags into Phase 6. First, build the group catalog. Phase 1: Find and catalog public groups Social Fetch does not expose a "search all Facebook groups" endpoint. Discovery is manual — same as it would be without an API. Practical sources: | Source | What you get | Caveat | | --- | --- | --- | | Facebook group search | Name, member count, public/closed badge | Confirm the group is Public before adding to cron | | Competitor or partner lists | Groups your sales team already watches | URLs go stale when groups rename slugs | | City + category queries | "Austin buy sell trade", "Round Rock moms" | Duplicate metro groups — dedupe by URL, not name | | Customer interviews | "Where do you post when you move?" | High-signal but slow to collect | Store one row per group: Validate a URL before scheduling it. A single probe call costs one credit and tells you whether the group resolves: Check data.lookupStatus: found — safe to schedule. posts may still be empty if the group has no recent public activity. not_found — wrong URL, private group, or deleted community. Fix the row before burning credits on cron. Reference: Facebook group posts. Phase 2: Poll a group feed Once the catalog is validated, hit the feed on your cadence. One group, one sort order, one page per request. The preset uses sortBy=recentActivity — good for threads with fresh comments. Buy/sell groups often need chronologicalListings instead (Phase 3). TypeScript with the SDK: Each post includes id, url, text, publishedAt, reactionCount, commentCount, and author (name, url when available). Video posts may include video with thumbnail and duration fields — useful when you filter out pure image listings. There is no server-side keyword parameter. Match in your worker: Phase 3: Pick the right sortBy The sortBy query parameter maps to Facebook's feed tabs. Wrong sort wastes credits — you page through posts your job does not care about. | Value | Feed behavior | Typical monitoring job | | --- | --- | --- | | chronologicalListings | Marketplace-style listing order | Buy/sell, ISO, furniture, vehicles | | chronological | Newest-first timeline | Service requests, same-day alerts | | recentActivity | Threads with fresh comments | Vendor recommendations, complaint threads | | top | High-engagement posts in the window | Weekly digest, "what dominated this group" | Buy/sell example — listing sort surfaces inventory order, not comment heat: Local services example — chronological catches "need a plumber today" before it accumulates comments: Vendor intel example — recent activity bumps threads where the answer arrived yesterday: If you are unsure, run two probe calls with different sortBy values on the same group and compare the first five post.id values. Pick the sort that surfaces posts your analyst would have opened first. Phase 4: Paginate without blowing the budget Responses include data.page.nextCursor and data.page.hasMore. Pass nextCursor verbatim on the next request — do not parse or construct cursors yourself. Stop when: data.page.hasMore is false nextCursor is null You hit maxPagesPerRun from your catalog For incremental monitoring, store the newest post.id or publishedAt from each run. On the next poll, stop paging when you reach a post you already ingested — even if hasMore is still true. That pattern cuts credits on busy groups. Dedupe across groups and runs on post.id before writing to your warehouse or firing webhooks. The same listing sometimes gets cross-posted; url is the better dedupe key if you want one row per discussion. Phase 5: Pull comment threads Group post text is often thin. "Anyone know a good electrician?" might be twelve words; the thread names three businesses, two price ranges, and a warning about one of them. Pass the post permalink to the comments endpoint: Paginate comment pages the same way as the feed: Reference: Facebook post comments. For scoring comment text at scale, see the sentiment guide. Pull comments selectively — not every feed row deserves another credit. Heuristics that work in production: commentCount above 5 for local service requests commentCount above 15 for buy/sell (price negotiation lives in replies) Post text under 80 characters (headline-only posts) Keyword hit on the post body for your brand or competitor list Optional: pass feedbackId when you have it from a prior response — can speed up repeat lookups on the same thread. Phase 6: Local intel workflows Wire Phases 1–5 into jobs your team already runs. Hourly buy/sell watch 1. Poll each buy/sell group with sortBy=chronologicalListings, maxPages=2. 2. Filter text for ISO, price patterns ($, obo, firm), and category keywords. 3. Dedupe on post.id, compare against yesterday's IDs. 4. Slack or email new rows with url, text, publishedAt, and author.name. Daily service-request digest 1. Poll homeowner or city groups with sortBy=chronological, one page per group. 2. Match recommend, looking for, anyone know, plus trade terms (plumber, HVAC, roofer). 3. Pull comments on matches with commentCount >= 5. 4. Aggregate vendor names from comment text into a frequency table by metro. Weekly brand mention scan 1. Poll brand-adjacent or franchise groups with sortBy=recentActivity, three pages. 2. Client-side match on brand strings and common misspellings. 3. Pull full comment threads on negative-sentiment keywords (scam, refund, never again). 4. Archive rows with requestId for support escalation. Multi-group batch worker Loop your catalog JSON and respect per-group sortBy and maxPages: Schedule the batch with cron or a queue worker — same pattern as the social listening guide, but scoped to a group URL list instead of platform-wide search. To link post authors to a business page, follow up with GET /v1/facebook/profiles when author.url is present. Reference: Facebook profiles. Store rows your ops team can filter Normalize API responses into flat rows — Airtable, Postgres, Google Sheets: Suggested columns: | Column | Source | Why | | --- | --- | --- | | Intent | your taxonomy | "ISO", "recommend", "complaint" — manual or rule-tagged | | Evidence | url | Link back for quotes in ops decks | | Weight | commentCount, reactionCount | Rank threads with replies over lone posts | | Freshness | publishedAt | Deprioritize stale listings unless buy/sell | | Metro | catalog tag | Groups already encode geography | Keep requestId on every row. If a post looks wrong in your dashboard, support can trace the exact lookup. Troubleshooting not_found on a group that opens in your browser Confirm the group is Public, not closed or private. Closed groups often fail for logged-out-style lookups. Copy the URL from the address bar — slug renames break bookmarked links. m.facebook.com and www.facebook.com variants usually work; avoid share links that redirect through login walls. found but empty posts array The group resolved; there may simply be no recent public posts in the feed window. Try a different sortBy — top on a quiet group can look empty while chronological returns rows. New groups with low activity are common; empty is not a billing bug. Duplicate posts across runs Dedupe on post.id before alerting. Incremental polling should stop paging when you hit a known ID, not only when the cursor ends. Comments return not_found Pass the full group post permalink (.../groups/ /posts/ /), not just the group URL. Very new posts may not have comment threads indexed yet — retry on the next poll. Reaction and comment counts look stale Each response is a point-in-time snapshot. Re-fetch before quoting counts in a report. Store capturedAt next to commentCount. lookup_failed or HTTP 503 Not charged. Retry with backoff; include meta.requestId from the failed attempt if you contact support. Rate limits No request quotas on metered routes — credits are the only limit. Under extreme concurrency you may get 503 with Retry-After (not charged). Staying under ~500 concurrent requests is a courtesy, not a ceiling. Billing and boundaries Each group feed page and each comment page is one credit (typically 1 per successful request). A completed lookup with zero posts still ran upstream and is billed. You are not charged for pre-send validation errors, lookup_failed, or 503 temporarily_unavailable. Rough weekly math: | Step | Calls | Credits (approx.) | | --- | --- | --- | | 12 groups × 2 pages, chronologicalListings | 24 | 24 | | 8 groups × 1 page, chronological | 8 | 8 | | 20 comment pulls on high-signal posts | 20 | 20 | | Total | 52 | 52 | Public data only — you remain responsible for lawful use under Terms. See Credits. What you can build Territory inventory feeds — hourly chronologicalListings pull with price parsing on post text. Service lead digests — daily chronological scan with comment enrichment on recommendation threads. Franchise complaint routing — recentActivity pass with brand keywords and comment pulls for escalation. Vendor scorecards — count how often supplier names appear in comment text across trade groups. Moderation pre-filter — flag new posts against policy rules before a human opens Facebook. --- Next steps: Playground · Facebook API reference · Facebook group data API use case · Pricing
---
# How to get a Reddit API key (2026)
Source: https://www.socialfetch.dev/guides/how-to-get-a-reddit-api-key
# How to get a Reddit API key (2026)
How Reddit API keys work in 2026: free vs commercial access, OAuth apps, rate limits, and when a public-data API is simpler.
**Read on the site:** https://www.socialfetch.dev/guides/how-to-get-a-reddit-api-key
"Reddit API key" search usually means one of two things: Reddit's official OAuth credentials for a client under Reddit's terms, or a third-party key that returns public subreddits, posts, comments, and search as JSON. Mixing those up is how teams wait weeks on an approval ticket for a research cron that only needed public search. Need a Reddit-native client, mod tools, or first-party compliance? Register a Reddit app and follow Reddit's Data API process. Need public research or multi-platform monitoring without OAuth? Create a Social Fetch sfk_… key and call /v1/reddit/. Smoke-test a query first with the free Reddit research tool. This guide covers both paths — how official keys work, what "free" and rate limits actually mean in 2026, and when a Social Fetch key is the shorter path for public enrichment. Two different products named "Reddit API" | Need | Official Reddit Data API | Social Fetch Reddit routes | | --- | --- | --- | | Reddit client / bots under Reddit ToS | Yes | Wrong product | | Public subreddit cards, search, comments | Yes (with access) | Yes | | Instant self-serve key for enrichment | Often no | Yes | | Same envelope as TikTok / Instagram | No | Yes | | Private subreddits / user inbox | Per Reddit scopes | No — public only | | Cost model | QPM + commercial contract | Credits per completed lookup | Glossary context: Does Reddit have an API?. Platform routes and examples: Reddit hub. How to get an official Reddit API key Reddit's developer flow still starts with an account and an app registration. High level: 1. Create or use a Reddit account that will own the app. 2. Open Reddit's app preferences / developer settings and register an application (script, web app, or installed app — pick the type that matches how you will call OAuth). 3. Note the client id and secret Reddit issues for that app. 4. Implement OAuth for the scopes your product needs. Read-only public data still uses Reddit's auth model for the official API. 5. If your use is commercial (selling monitoring, enrichment, or a customer-facing Reddit feature under Reddit's commercial rules), treat approval and contract terms as part of onboarding — not a checkbox after you ship. Self-serve registration has tightened over the last few years. Expect delays, rejection risk, and policy changes. For personal scripts and approved non-commercial bots, PRAW is still a common Python wrapper on top of the same official endpoints — it does not unlock a free commercial entitlement. This is not a ToS-bypass guide. If Reddit's rules say you need their commercial path, use it. If you only need public posts that anyone can open in a browser, a public-data API is a different product category — see the Social Fetch section below. Is the Reddit API free? Yes — and a few production details matter: Approved non-commercial use often has a free tier. Teams commonly cite about 100 queries per minute per OAuth client. That is a rate ceiling, not "unlimited research for a SaaS." Commercial use is a separate approval and pricing path. Published figures teams quote for commercial access are often around $0.24 per 1,000 API calls when access is granted — verify against Reddit's current commercial terms before you model a budget. Free ≠ commercial monitoring. Brand-listening products, customer-facing enrichment, and paid research tools usually fall outside the free non-commercial story. Deeper cost math and vendor alternatives: Reddit API pricing and the Best Reddit Data APIs roundup. Reddit API rate limits On the official API, architecture follows Reddit's quotas: Free / non-commercial access is commonly rate-limited around 100 QPM per OAuth client. Listing endpoints often return on the order of 100 items per page, so deep comment trees and long search backfills burn quota fast. Hitting the ceiling means backoff, queues, and product delays — not a soft warning in the JSON. Social Fetch's metered /v1/reddit/ routes work differently: there are no request quotas on paid metered lookups — credits are the only limit. Under extreme concurrency you may receive 503 with Retry-After (not charged; not a paid-route 429). Stay under roughly 500 concurrent requests as a courtesy for reliability. Free dashboard helpers (whoami, balance) have their own per-key limits — see Credits and Errors. Billing rule that trips people up: Social Fetch charges on completed lookups. An empty search that finished upstream still bills. lookup_failed and 503 temporarily_unavailable do not. Trust meta.creditsCharged on every response. When Social Fetch is the simpler key Use Social Fetch when: Reddit is one source next to TikTok, Instagram, YouTube, or X in the same product. You need sync REST (GET /v1/reddit/search, comments, subreddit feeds) without standing up Reddit OAuth. You want prepaid credits that do not reset on a monthly free-tier clock. Public data is enough — you are not building mod tools, inbox access, or a Reddit client. Create a key at API Keys (starts with sfk_). Full route list: Reddit platform page. Research sprint patterns: Reddit product research. Listening recipe: Reddit research recipe. Stay on public content. Private or banned communities return documented miss outcomes — we do not help you reach content Reddit keeps gated. Try a search before you wire OAuth Before you commit to an official app or a credit pack: 1. Run one query in the free Reddit research tool (Turnstile + IP caps; first page only). 2. Or spend signup credits in the playground against GET /v1/reddit/search. 3. Decide whether you need Reddit-native scopes or public enrichment. That fork decides the key you register next. --- Next steps: Reddit hub · Reddit API pricing · Credits · Pricing
---
# How to Get TikTok Audience Demographics with an API (2026)
Source: https://www.socialfetch.dev/guides/how-to-get-tiktok-audience-demographics
# How to Get TikTok Audience Demographics with an API (2026)
Pull followers, US audience share, engagement rate, and median views for a public TikTok handle — three GETs into one research row.
**Read on the site:** https://www.socialfetch.dev/guides/how-to-get-tiktok-audience-demographics
Creator research usually starts the same way: open a TikTok profile, note the follower count, guess whether the audience is in your market, scroll recent videos, and punch numbers into a spreadsheet. That works for five handles. It falls apart for fifty. This guide shows how to pull the four numbers most shortlists actually need — followers, US audience %, engagement rate, and median video views — with three Social Fetch requests and one research row per handle. Profile and videos are 1 credit each; audience is 30. Budget about 32 credits per creator on completed lookups. You'll need an API key and curl or the TypeScript SDK. New here? Start with the Quickstart. The research brief | Metric | Where it comes from | | --- | --- | | Followers | GET /v1/tiktok/profiles/ → data.metrics.followers | | US audience % | GET /v1/tiktok/profiles/ /audience → row with countryCode === "US" | | Median video views | GET /v1/tiktok/profiles/ /videos → median of last 20 stats.views | | Engagement rate | Same videos + followers → avg(likes + comments + shares) ÷ followers × 100 | The audience call is the piece most teams are missing — country-level demographics for a public handle without owning the account. Full reference: Get TikTok profile audience. Why manual creator research breaks Hand-rolled shortlists fail in predictable ways: Followers are vanity. A million followers with almost none in your shipping markets is a bad buy for a US-focused brand. Geo is owner-only in TikTok Studio. Third parties cannot open another creator's analytics panel. Guessing from comments or language is noisy. Engagement math drifts. Some tools divide by views, some by followers, some include saves. Without a fixed formula, agencies cannot compare creators. Means lie. One breakout video inflates "average views." Median over a fixed recent window is stabler for vetting. An API does not remove judgment — it removes the copy-paste loop so your team can apply the same brief to every handle. Metric 1: Followers Start with the profile. data.metrics.followers is the denominator for engagement and the size signal on every shortlist. | What | Cost | | --- | --- | | Profile lookup | 1 credit | Check data.lookupStatus before trusting metrics. found means you have a public profile; private or not_found means skip or flag the row. Details: Get TikTok profile. Metric 2: US audience share Audience location is the new piece. Pass the same handle and read country rows under audienceLocations: | What | Cost | | --- | --- | | Audience lookup | 30 credits | Today this endpoint returns audience countries — not age or gender. Each row has country, countryCode, count, and percentage. Treat percentage as a string (for example "6.00%") and parse it for math. The count field is an upstream sample size, not total followers. For a US-focused brief, find the row where countryCode is US and parse the percentage: Swap US for any ISO code when the brief targets another market. Reading the audience response A trimmed successful response looks like this: Fields that matter: data.lookupStatus — found or not_found. HTTP 200 alone is not enough. data.audienceLocations — country rows when found; null when the profile could not be resolved. meta.creditsCharged — 30 on a completed audience lookup. meta.requestId — keep this for support if a row looks wrong. Metrics 3 and 4: Median views and engagement rate List recent videos, then derive reach and engagement from stats: | What | Cost | | --- | --- | | Videos page | 1 credit | Pass sortBy=latest when you want a chronological window (recommended for the median). Each video includes stats.views, likes, comments, and shares. Reference: List TikTok profile videos. The formulas Median video views — take the last 20 videos (or fewer if the page is shorter), collect stats.views, sort ascending, take the median. Prefer median over mean so one viral outlier does not dominate the shortlist score. Engagement rate — for those same videos, average likes + comments + shares, divide by followers, multiply by 100: Worked example with 3 videos and 100,000 followers: | Video | Likes | Comments | Shares | Sum | | --- | ---: | ---: | ---: | ---: | | A | 1,200 | 80 | 40 | 1,320 | | B | 900 | 50 | 30 | 980 | | C | 1,500 | 100 | 60 | 1,660 | Average engagement = (1,320 + 980 + 1,660) / 3 = 1,320. Engagement rate = 1,320 / 100,000 × 100 = 1.32%. One script, one research row Parallel-fetch all three routes and print the four fields: That is the whole brief: same inputs every time, same formulas, meta.creditsCharged summed so you can budget a roster run. Batching tips Loop handles, fail soft. Check lookupStatus per creator; write not_found into the sheet instead of aborting the batch. Cache audience. At 30 credits it is the expensive call — re-use it when you only refresh views and engagement weekly. Do not confuse count with followers. Audience count is a sample segment size; size the creator with metrics.followers. Keep the window fixed. Always use the same N (20) so engagement and median views stay comparable across the roster. Preflight private accounts. Videos has no lookupStatus — call profile first when empty lists would mislead a client. For broader TikTok scraping patterns (pagination, DIY tradeoffs), see How to scrape TikTok data. For multi-network identity before you spend, see Cross-platform creator profiles. What you can build Influencer shortlist exporter — CSV or Notion row per handle with the four metrics and a geo threshold filter (for example US audience ≥ 40%). Agency pre-brief — auto-fill the research section of a pitch deck before a human reviews creative fit. CRM enrichment — attach followers, US %, median views, and engagement to every TikTok handle in your pipeline. Scheduled re-score — cron the same three calls weekly; flag creators whose US share or engagement drifts past a threshold. FAQ How is engagement rate calculated? Average likes + comments + shares across the last N videos (we use 20), divided by follower count, multiplied by 100. That matches how most creator-research tools compute profile-level engagement. Saves are not included in this formula. Why median video views instead of the mean? One viral outlier can pull the average far above what a typical post reaches. The median of the last 20 videos is a stabler estimate of "usual" reach for shortlisting. Does this include age or gender demographics? Not yet. The audience endpoint returns country-level location rows only (country, countryCode, count, percentage). Age and gender splits are not in the response today. How many credits does a full research row cost? About 32 credits per creator on completed lookups: 1 for profile, 30 for audience, 1 for a page of videos. Audience is the expensive call — cache it when you re-score the same handles often. See the capability matrix. Is this the same as TikTok Studio audience analytics? No. TikTok Studio shows the account owner first-party age, gender, and location panels. This API returns third-party country-level audience signals for any public handle you pass — useful for vetting creators you do not control. Can I use a country other than the US? Yes. Find the row whose countryCode matches the market you care about (for example BR, GB, or DE) and parse that percentage the same way. --- Next steps: Audience endpoint reference · Scrape TikTok profiles & videos · Cross-platform creator profiles · Quickstart · Pricing
---
# How to Get a TikTok Video Transcript with an API (2026)
Source: https://www.socialfetch.dev/guides/how-to-get-tiktok-transcript
# How to Get a TikTok Video Transcript with an API (2026)
Pull spoken text from any public TikTok as JSON — caption tracks, optional AI fallback for uncaptioned videos, and WebVTT timestamps.
**Read on the site:** https://www.socialfetch.dev/guides/how-to-get-tiktok-transcript
TikTok has no "Show transcript" button. Unlike YouTube, there's no panel to open and nothing to copy — the auto-captions are built for watching, not exporting — and a large share of videos have no captions at all. So if you need the spoken text of a TikTok video in your product (hook research, repurposing, search, an AI pipeline), you have to extract it. The reliable way — even from uncaptioned videos — is an API that falls back to AI transcription when there's no caption track. The shortest path is one request: You'll need an API key and curl or the TypeScript SDK. New here? Start with the Quickstart. Why TikTok transcripts are hard to get YouTube hands you a transcript panel. TikTok doesn't. What you're actually up against: No export. Auto-captions have existed since 2021, but there's no copy-all and no download. You can watch them on screen — that's it. Mobile-only captions. The toggle isn't reliable on desktop web, so even manual copying is clumsy. Captions are optional. A huge share of videos have none — so caption-scraping returns nothing, and the only way to get text is to transcribe the audio. Formatted for viewing, not reuse. Inconsistent punctuation, broken sentence boundaries, and mangled proper nouns are normal. That third point is why this is harder than it looks: getting a transcript means handling both the "captions exist" case and the "no captions, transcribe the audio" case. Most tools — free caption scrapers especially — only do the first. You can build the DIY caption-scraper path yourself with open-source libraries, but it carries the same maintenance burden as any TikTok scraper (proxies, bot detection, breakage on every internal change) — see how to scrape TikTok data for why. This guide stays focused on getting clean text out fast. Transcript vs captions vs subtitles These three words get used interchangeably, but they mean different things — and which one you want changes what you do with the output: | Term | Typical format | What it is | Best for | | --- | --- | --- | --- | | Transcript | Plain text (often untimed) | The spoken audio as readable text | Repurposing, SEO drafts, search, quoting | | Captions | SRT / VTT | Time-synced text matching the audio | Accessibility, on-video text, watch-time | | Subtitles | SRT / VTT | Captions, often translated into another language | Multilingual publishing | A transcript is not the on-screen text overlays, the hashtags, or the description — it's the spoken words. The endpoint returns timestamped WebVTT, which gives you both: keep the timings for captions, or strip them for a clean plain-text transcript (shown below). Get a transcript Pass a TikTok video URL, get the spoken transcript back in the same data + meta envelope as the rest of the API: The same lookup across cURL, the TypeScript SDK, Python, and more: The only required parameter is url — the full link to a public video. Both the long share URL and vm.tiktok.com short links work. Full details are in the endpoint reference. | What | Cost | | --- | --- | | Base transcript lookup | 1 credit | | With useAiFallback=true (AI transcribes audio when no caption exists) | +10 credits (11 total on a completed lookup) | When a video has no captions This is the case the manual and DIY routes can't handle: if a creator never enabled captions, there's nothing to scrape. Set useAiFallback=true and the audio is transcribed with speech-to-text instead, so you get text either way: The fallback adds 10 credits and only charges on a completed lookup. Leave it off when you only want existing captions and would rather skip videos without them; turn it on when you need a transcript for every video regardless of whether the creator captioned it — usually the case for research and repurposing pipelines. Requesting a specific language Pass an optional two-letter language code to request a specific language when one is available: If the requested language isn't available, the lookup resolves to what TikTok has. Check data.transcript to see what came back. Reading the response A successful response wraps the transcript alongside the video identity and billing metadata: The fields that matter: data.lookupStatus — found or not_found. A 200 does not guarantee found; a missing or private video returns 200 with not_found. Handle it in application logic. data.video — the resolved video's id and canonical url, so you can reconcile the transcript to its source. data.transcript.content — the raw WebVTT text (data.transcript.format is webvtt). meta.creditsCharged — exactly what this call cost (1, or 11 with the AI fallback), so you can budget batch jobs. meta.requestId — trace identifier if a transcript ever looks wrong. From WebVTT to plain text data.transcript.content is WebVTT, which keeps the timestamps. Use it as-is for captions; for a clean plain-text transcript — blog drafts, prompts, search indexing — strip the timing cues: That gives you both outputs from a single request: the timed version for video, the flat text for everything else. What you can build Hook research — transcribe a set of viral videos in a niche, pull the first line of each, and study what's actually getting watched. Content repurposing — turn one TikTok into a thread, newsletter section, or blog draft without rewatching it, as a "video → text → distribution" pipeline. AI and RAG pipelines — feed transcripts into summarization, sentiment, or retrieval. Text is searchable and composable in ways raw video never is. Accessibility and indexing — generate captions for your own reposts, or index spoken content so it's findable in a knowledge base. FAQ Does TikTok have a built-in transcript feature? Not for export. TikTok shows auto-generated captions on screen during playback (mobile, and only if the creator enabled them), but there's no copy-all, no download, and no transcript panel like YouTube's. To get reusable text you need a tool or an API. What if the video has no captions? Set useAiFallback=true. The audio is transcribed with speech-to-text and you get text even when no caption track exists — the main reason an API beats DIY caption scrapers, which return nothing for uncaptioned videos. The fallback adds 10 credits on a completed lookup. What format is the transcript returned in? WebVTT — timestamped text. Use it directly as captions, or strip the timing cues for plain text. See From WebVTT to plain text. Can I get transcripts in other languages? Pass the optional two-letter language parameter when a specific language is available. If it isn't, the lookup resolves to what TikTok has — check data.transcript. Is getting TikTok transcripts legal? Transcribing publicly available video for analysis and repurposing is a common, widely-practiced pattern, and courts (e.g. hiQ v. LinkedIn) have generally treated public-web data as fair game in several jurisdictions. You remain responsible for TikTok's terms, copyright and privacy law, and your own contracts — a transcript is the creator's spoken words, so attribution and fair-use considerations apply when you republish. This is a technical guide, not legal advice. How does this compare to other providers? See the side-by-side comparisons: vs Apify, vs Bright Data, vs EnsembleData, and the full compare hub. --- Next steps: Transcript endpoint reference · Scrape TikTok profiles & videos · Quickstart · Pricing
---
# YouTube & TikTok transcripts with one API
Source: https://www.socialfetch.dev/guides/how-to-get-youtube-and-tiktok-transcripts
# YouTube & TikTok transcripts with one API
Pull YouTube, TikTok, and Instagram Reel transcripts as JSON — caption tracks, optional TikTok AI fallback, and batch/RAG patterns.
**Read on the site:** https://www.socialfetch.dev/guides/how-to-get-youtube-and-tiktok-transcripts
Video does not embed well. Search engines cannot index spoken words inside a Reel, and most LLM context windows are wasted if you paste a URL and hope the model watched the clip. Transcripts fix that: they turn audio into text you can quote, grep, chunk, and score. The catch is that YouTube, TikTok, and Instagram each store captions differently — different formats, different fallbacks, different empty states. Social Fetch gives you three GET endpoints behind one auth header: GET /v1/youtube/videos/transcript, GET /v1/tiktok/videos/transcript, and GET /v1/instagram/posts/transcript. Pass a public video URL, read data.lookupStatus, extract text. TikTok supports useAiFallback=true when no caption track exists. Your job is picking the right one per URL and normalizing the output for whatever comes next (a spreadsheet, a vector index, a summarization job). You'll need an API key and curl or the TypeScript SDK. New here? Start with the Quickstart or try lookups in the Playground. What each platform actually gives you Before you wire a pipeline, know what comes back — the shapes are not identical: | Platform | Endpoint | Transcript shape | Timestamps | No-speech fallback | | --- | --- | --- | --- | --- | | YouTube | /v1/youtube/videos/transcript | segments[] + plainText + language | Millisecond offsets per segment | None — transcript may be null | | TikTok | /v1/tiktok/videos/transcript | WebVTT string in transcript.content | In the VTT cues | useAiFallback=true (+10 credits) | | Instagram | /v1/instagram/posts/transcript | Plain text per row in transcripts[] | None in the response | None — text: null when no speech detected | All three share data.lookupStatus, meta.creditsCharged, and meta.requestId. That is enough to build one batch worker; you just need a thin normalization layer on top (covered below). YouTube transcript YouTube is the easy case. The UI has a transcript panel; the API returns structured segments you can use as-is or flatten. Pass a public watch URL: Full parameters: YouTube transcript reference. A successful lookup with captions looks like this: Fields worth remembering: transcript.plainText — ready for embeddings or summarization without parsing. transcript.segments — use when you need clip boundaries ("quote the section at 2:14"). transcript.language — human-readable label from the lookup; pair with the language query param when you request a specific track. YouTube can also return lookupStatus: "found" with transcript: null — the video resolved, but no caption track exists (common on music-only uploads or videos where the creator disabled captions). Treat that as "no text available," not as an error. | What | Cost | | --- | --- | | Base YouTube transcript lookup | 1 credit | TikTok transcript TikTok has no transcript export in the app. Auto-captions show on screen during playback, but there is nothing to copy — and a large share of videos have no captions at all. The API returns WebVTT when a caption track exists. See the dedicated TikTok transcript guide for a full walkthrough (WebVTT parsing, screenshots, legal notes). Reference: TikTok transcript. | What | Cost | | --- | --- | | Base TikTok transcript lookup | 1 credit | | With useAiFallback=true | +10 credits (11 total on a completed lookup) | When TikTok has no captions If the creator never enabled captions, there is nothing to scrape. Enable AI fallback and the audio is transcribed instead: Use fallback when you need text from every video in a batch. Skip it when you only want existing caption tracks and would rather drop uncaptioned clips. Reading the TikTok response Strip WebVTT timing cues when you need flat text: Instagram Reels transcript Instagram Reels and video posts expose speech as plain text — no WebVTT, no segment array. Carousel posts can return multiple transcripts[] rows (one per video item in the carousel). Reference: Instagram post transcript. For carousels, loop data.transcripts and concatenate non-null text values. When text is null, the video resolved but no speech was detected (silent Reel, music-only, or very short clip). | What | Cost | | --- | --- | | Base Instagram transcript lookup | 1 credit | Instagram has no useAiFallback flag — you get whatever speech detection returns. Captions vs auto-generated speech These terms get mixed up constantly. Here is how they map to API behavior: | Term | What it means on the platform | What you get from the API | | --- | --- | --- | | Manual captions | Creator-uploaded or edited SRT/VTT | Returned like any other track — YouTube/TikTok do not label "manual" vs "auto" in the response | | Auto-generated captions | Platform speech-to-text (YouTube "auto", TikTok on-screen captions) | Same endpoints — you receive the best available track | | No captions | Creator disabled them, or TikTok never generated them | YouTube: transcript: null. TikTok: not_found unless AI fallback. Instagram: text: null | You cannot request "manual only" or "auto only." Pass language when multiple tracks exist and inspect transcript.language on YouTube. For quality-sensitive workflows (legal review, quote verification), spot-check a sample against the source video — auto-generated tracks mishear proper nouns and punctuation routinely. Language handling YouTube and TikTok accept an optional two-letter language query parameter (ISO 639-1) to prefer a specific track: TikTok language selection: If the requested language is not available, the lookup returns whatever track exists — check the response body rather than assuming the parameter was honored. Instagram has no language parameter; the returned text is in whatever language was spoken. For multilingual RAG indexes, store language (from YouTube's field or your own detector) on every document chunk so retrievers can filter by locale. Normalize to one document shape Production pipelines rarely want three different parsers in every downstream job. Map each platform response to an internal TranscriptDoc: One normalizer per platform, one schema for everything downstream. Batch processing Research and repurposing jobs usually start with a list of URLs — a CSV export, a search result, a creator's recent uploads. Fetch them with bounded concurrency so you do not hammer the API or your own rate limits: Practical batch tips: Budget credits upfront. TikTok with AI fallback costs 11 credits per completed lookup. A thousand-video batch is not a rounding error — multiply before you run. Persist requestId on every row. When a transcript looks wrong, support can trace the exact lookup. Skip empty text, not failed HTTP. lookupStatus: "not_found" still returns HTTP 200 and is charged. Filter in application logic. Discover URLs first. Pair transcript fetches with profile/video listing endpoints (TikTok profile videos, YouTube channel) so you are not hand-curating links. Chunking for RAG and LLMs Once you have plainText, the embedding step is standard — but video transcripts benefit from a few conventions: 1. Chunk by sentence, not arbitrary character count. Caption segments often break mid-phrase; rejoin into sentences before splitting. 2. Target 300–600 tokens per chunk with ~50-token overlap. Short-form video (TikTok, Reels) may fit in one chunk; long YouTube uploads need many. 3. Attach metadata on every chunk: platform, url, videoId, language, startMs/endMs when you have segments. 4. Store the raw timed version separately. Retrieval uses plain text; clip generation and citation UI need timestamps from YouTube segments or TikTok WebVTT. For summarization (not retrieval), skip chunking — pass the full plainText in one prompt, or summarize per-chunk and merge. Agent workflows can call transcript endpoints via MCP while building; see Social Fetch with Cursor & Claude. Billing and lookup status Every response includes data.lookupStatus and meta.creditsCharged. Branch on status in code — HTTP 200 does not mean you got text. | Status | Meaning | Charged? | | --- | --- | --- | | found | Lookup resolved; check transcript fields for actual content | Yes | | not_found | Video/post not reachable or no transcript path (platform-dependent) | Yes — upstream ran | | lookup_failed | Infrastructure could not complete the lookup | No | | 503 | Temporary unavailability | No | YouTube-specific edge case: found + transcript: null means the video exists but has no captions — you are charged, and you need another source for text. TikTok-specific: useAiFallback adds 10 credits only on completed lookups where fallback ran. Pre-send validation errors are free. Details: Credits & billing. What you can build Cross-platform repurposing — pull a YouTube long-form script, three TikTok hooks, and an Instagram Reel caption block in one nightly job. Creator hook research — batch-transcribe top videos in a niche, extract the first sentence of each, compare what is actually getting watched. Brand monitoring — transcript + comments on the same URL for full conversation context. Knowledge bases — chunk, embed, and retrieve spoken content from webinars, tutorials, and competitor explainers. Accessibility — generate on-video captions from WebVTT or segment data for reposts and internal archives. --- Next steps: Playground · TikTok transcript deep-dive · Transcript API use case · API reference · Pricing
---
# How to scrape Hacker News data with an API
Source: https://www.socialfetch.dev/guides/how-to-scrape-hacker-news-data
# How to scrape Hacker News data with an API
DIY public HN APIs vs a managed Hacker News data API for search, stories, comments, and hiring — tradeoffs and runnable code.
**Read on the site:** https://www.socialfetch.dev/guides/how-to-scrape-hacker-news-data
Hacker News concentrates technical reality in a way product teams keep rediscovering: a Show HN can make a project, Ask HN threads are candid tooling research, and Who is Hiring is still where a surprising amount of recruiting signal lives. Getting that into a product means choosing between assembling HN's public read surfaces yourself, scraping HTML for the gaps, or calling a Hacker News data API that returns assembled JSON under one key. This guide compares those paths with real job scenarios — mention watches, digests, comment pulls, hiring parses — and shows runnable Social Fetch examples for search, stories, and users. The shortest path is a search: You'll need an API key and curl or the TypeScript SDK. New to the API? Start with the Quickstart. The three ways to get Hacker News data | Approach | Best when | The real cost | | --- | --- | --- | | DIY public APIs | HN-only scripts; you want to own every hop | Feed id fan-out, comment walks, search/schema glue, HTML favorites | | DIY HTML / browser | One-off research or fields not in public JSON | Markup drift, proxies, session babysitting | | Data API (Social Fetch) | Search, stories, users, hiring in product code now — ideally beside Reddit or Web | Metered per completed lookup; provider keeps routes working | For most production apps that need HN on demand beside other networks, the data API is the fastest route to reliable JSON — one REST surface with the same data + meta envelope as Reddit or Instagram. DIY public APIs are genuinely worth it when HN is the only network and a staff engineer already owns the quirks. Why DIY HN clients turn into a maintenance project Public HN read APIs are more stable than Instagram GraphQL. The maintenance tax is the assembly: Feeds return ids. Digests need titles, scores, URLs, and comment counts — so every cron tick fans out item lookups. Comments are trees. Busy Show HN threads need paging strategy, not a single recursive dump that times out. Search ≠ story schema. Keyword monitors map hit fields into the same model you use for story gets, or you maintain two parsers. Favorites and hiring. Public favorites live on HTML pages. Who is Hiring is a monthly comment thread you discover and structure yourself. For a personal script that's fine. For a customer-facing monitor, you've signed up to own glue code forever. Broader build-vs-buy: Social Fetch vs DIY scraping. Why "just call the public APIs" is incomplete for products HN's public surfaces are the right answer when you want first-party public JSON and can wire multiple clients. They leave gaps that product tickets keep rediscovering: Hydrated front-page / show / ask / jobs digests without id fan-out. One envelope for search hits and story cards. Cursor-friendly comment pages for long threads. Public favorites with a typed outcome when the list is private. Structured Who is Hiring rows instead of one blob of top-level comments. So if you need one key and one error shape across networks, DIY leaves a glue gap by design. Reach for public APIs when HN is standalone infrastructure; reach for a data API when HN is one enrichment source beside Reddit or Web. Using the Social Fetch API Social Fetch exposes Hacker News under documented /v1/hackernews/ routes — search, feeds, stories, comments, items, users, favorites, Who is Hiring, and thin update helpers. One header authenticates every call. Search mentions Brand and launch monitors start here — query the product name, optionally narrow with author, domain, or minPoints, then hydrate only the ids you keep: Docs: Search Hacker News. Credit-metered per completed page — trust meta.creditsCharged. An empty hits array with no further pages is a completed empty result, not a transport failure. Get a story Classic Show HN Dropbox (8863) is a good smoke-test id: Branch on data.lookupStatus (found, not_found, not_story). Comment trees are a separate paginated route: story comments. Get a user Author analysis starts with the user card, then siblings for submissions, comments, or public favorites: Reading the response Search returns hits plus page metadata: Story gets return a typed card: The one gotcha: HTTP 200 does not always mean "persist this row." Empty search hits are a completed empty result; story/user routes expose lookupStatus for misses and wrong item types. Every response carries meta.requestId. See Errors and Credits. What you can build Launch and brand monitors — search product names, then pull stories and comments for the hits that matter. Front-page digests — ranked feeds with hydrated items for Slack/email roundups. Hiring intel — structured Who is Hiring rows with best-effort company/role/location fields (plain text remains source of truth). Author analysis — user cards plus submissions, comments, and public favorites. Vendor shopping: Best Hacker News APIs & scrapers in 2026. Related: Reddit product research. FAQ Is scraping Hacker News legal? It depends on your jurisdiction, what you collect, and how you use it. HN publishes public read surfaces and public HTML. You remain responsible for Y Combinator's terms and applicable law. This is not legal advice. Can't I just use Hacker News's public APIs myself? Yes for HN-only scripts. You still assemble hydration, comment paging, search mapping, and HTML-only surfaces. For multi-platform enrichment, a managed data API is often shorter. See Why "just call the public APIs" is incomplete for products. How fresh is the data? Each request fetches live at call time. meta.requestId traces a specific lookup. What happens if a story or user doesn't exist? Check data.lookupStatus where present. Don't treat 200 alone as found. How are credits charged? Credits charge when a lookup completes**, including empty search pages and typed misses. Each HN request or cursor page is credit-metered. Always reconcile against meta.creditsCharged. How does this compare to other providers? See Best Hacker News APIs & scrapers in 2026, vs Apify, and the compare hub. --- Ready to try it? Get an API key — new accounts include 100 free credits. Platform hub: /platforms/hackernews.
---
# How to Scrape Instagram Data with an API (2026)
Source: https://www.socialfetch.dev/guides/how-to-scrape-instagram-data
# How to Scrape Instagram Data with an API (2026)
DIY browser scraping vs Meta Graph API vs a data API for public Instagram profiles, posts, and reels — tradeoffs and runnable code.
**Read on the site:** https://www.socialfetch.dev/guides/how-to-scrape-instagram-data
There are three ways to pull public Instagram data into a product: drive your own headless browser, use Meta's Instagram Graph API, or call an Instagram data API that hands back normalized JSON. Meta's Graph API only covers accounts you own or that grant your app access. A DIY Instagram scraper is a maintenance treadmill of GraphQL churn and login walls. For most teams, a data API is the pragmatic way to get public profiles, posts, and reels as clean JSON. This guide compares all three — what each one really costs, where it breaks, and which one fits your project — with runnable code for every path, including the ones we don't sell. The shortest path is a single request: You'll need an API key and curl or the TypeScript SDK. New to the API? Start with the Quickstart. The three ways to get Instagram data Every approach is some version of these three. The right one depends on volume, who's using the data, and how much maintenance you want to own. | Approach | Best when | The real cost | | --- | --- | --- | | DIY (Puppeteer / Playwright) | A one-off research pull, internal tooling, or you specifically want to own the pipeline | Residential proxies, session babysitting, GraphQL doc-id churn — and re-fixing it every time Instagram ships a web change | | Instagram Graph API | You already have app review and your need maps to accounts you manage | Business verification, review, and a hard ownership wall — arbitrary public creators are out of scope by design | | Data API (Social Fetch) | You need profiles, posts, reels, search, or transcripts in product code now, ideally across more than one platform | Metered per completed lookup; you depend on a provider to keep the scrapers working | For most production apps that need public creator data on demand, the data API is the fastest route to reliable JSON — one REST surface across Instagram, TikTok, YouTube, and X, with the same auth header and the same data + meta envelope. DIY is genuinely worth it for a weekend research scrape or to learn the internals. Graph is the right call when you're already inside Meta's partner programs for owned accounts. The rest of this guide covers each path, starting with the one most teams try first. Why DIY scraping turns into a maintenance project A plain fetch() to instagram.com gets blocked almost immediately — Instagram's bot defenses inspect TLS fingerprints, cookies, and request patterns that a stock HTTP client does not match. So a working scraper isn't a script; it's a small system you build and then maintain indefinitely. Here's roughly what the browser-driven version looks like: That snippet only gets you raw HTML. The numbers you care about usually sit in embedded GraphQL / shared-data JSON blobs you still have to locate and parse. And around it you're standing up: A residential or mobile proxy pool. Datacenter IPs are flagged within a few hits, so you need real ones with sticky, region-matched rotation. Session and login-wall handling. Public pages often redirect into login or challenge flows mid-cron. You patch around it, then Instagram changes the wall and your overnight job returns empty grids. GraphQL document churn. Query hashes and doc_id values move without a changelog. A parser that worked Tuesday returns empty arrays Friday — and you hear it from a customer, not a test. Behavioral pacing. Fixed intervals read as a bot, so you add randomized delays and cap concurrency — slowing the whole thing down. The build is the easy part. The maintenance is worse: Instagram quietly renames internal fields and reshapes media objects, so a scraper that looked solid in staging drifts in production. For a one-off pull that's a fine weekend. For anything customer-facing, you've signed up for a maintenance subscription paid in your own evenings. For the broader build-vs-buy math, see Social Fetch vs DIY scraping. Why Meta's Graph API won't cover it Meta's Instagram developer products are the right answer when your app lives inside Meta's ecosystem — publishing on a Business or Creator account you manage, reading insights for assets that granted access, or messaging with approved permissions. None of these are a general "look up this public handle" tool: Instagram Graph API exposes profiles, media, insights, and comments for accounts you own or that authorize your app. App review and Business verification sit in front of most production scopes. Basic Display / consumer login paths (where still relevant to your stack) are for user-authorized personal data in your app — not bulk competitor enrichment. Marketing / ads APIs cover campaigns and ad accounts, not arbitrary public creator lookups. So if you need web-parity public data in a generic backend, Graph leaves a gap by design — the ownership wall is intentional. Reach for Graph when your use case maps to owned assets; reach for a data API when it doesn't. Terms and product names change often — check Meta for Developers before building against any of them. Using the Social Fetch API Social Fetch exposes Instagram under documented /v1/instagram/ routes — profiles, posts, reels, stories/highlights, search, comments, transcripts, and more. One header authenticates every call, and responses share the same data + meta envelope across platforms, so your Instagram code looks identical to your TikTok or YouTube code. Get a profile The same lookup in cURL, the TypeScript SDK, Python, and more — switch tabs to match your stack: Most Instagram profile lookups are 1 credit when the lookup completes (including private / not_found outcomes that still return HTTP 200). Trust meta.creditsCharged on every response. List a profile's posts Full parameters live in the reference: Get Instagram profile and Profile posts. Reels, highlights, search, and transcripts sit next to them in the API reference. Profile post and reel list routes are also 1 credit per completed page. Paginate through everything Post and reel list endpoints return one page plus a cursor. To pull a full history, pass the cursor back verbatim until it's gone — no decoding, no arithmetic: Stop when data.page.nextCursor is null. Don't loop on a total count — upstream totals are estimates and often disagree with what's actually paginatable. The cursor is the source of truth. Each page is a separate completed lookup for billing. Reading the response A successful response wraps the payload alongside billing metadata, so you always know what a call cost: The one gotcha: an HTTP 200 does not guarantee lookupStatus: "found". A private or non-existent account can return 200 with a status field telling you what actually happened — handle it in application logic, not by trusting the status code. Every response also carries meta.requestId, so if a number ever looks wrong, support can trace the exact lookup. See Errors and Credits. Post detail with downloadMedia=true is the common surcharge case: 11 credits on success (1 base + 10 for hosted media download). Leave downloadMedia off unless you need the files. What you can build Influencer vetting — pull profile metrics and recent posts before outreach, and reconcile CRM handles against live numbers so you're not paying creators on stale stats. Competitive content monitoring — snapshot competitor profiles, posts, and reels on a schedule without running a scraper per brand. Brand-safety and topic pipelines* — pair captions with post/reel transcripts when on-screen text is thin. For the same identity pattern across Instagram, TikTok, and YouTube, see Cross-platform creator profiles. FAQ Is scraping Instagram legal? It depends on your jurisdiction, what you collect, and how you use it. Collecting public, business-level metrics for B2B analytics is a common pattern, and courts (e.g. hiQ v. LinkedIn*) have generally treated public-web data as fair game in several jurisdictions. You remain responsible for Instagram's terms, applicable privacy law, and your own contracts. This is a technical guide, not legal advice — talk to counsel if you're collecting at scale. Can't I just use the Instagram Graph API? Not for arbitrary public creator lookups. Graph covers accounts you manage or that grant your app access. For web-parity public data in a generic backend, a data API is the usual fit. See Why Meta's Graph API won't cover it. How fresh is the data? Each request fetches live from Instagram at call time — there's no cache returning an hour-old snapshot. If a number looks off, meta.requestId lets support trace that specific lookup. What happens if a profile is private or doesn't exist? Check data.lookupStatus. Don't treat a 200 alone as "data is present" — a private or missing account returns 200 with a status field. Details in Errors. How are credits charged? Credits charge when a lookup completes, including 200 outcomes like private or not_found. Most Instagram profile, post-list, reel-list, search, highlight, and transcript routes are 1 credit per completed request. Post detail with downloadMedia=true is 11 credits on success. Validation failures and upstream lookup_failed / temporary unavailability do not bill the same way — see Credits. Always reconcile against meta.creditsCharged. How does this compare to other providers? See the side-by-side comparisons: vs Apify, vs Bright Data, vs EnsembleData, the full compare hub, and Best Instagram data APIs in 2026. --- Next steps: Quickstart · Instagram platform hub · Instagram API reference · Pricing
---
# How to Scrape LinkedIn Data with an API
Source: https://www.socialfetch.dev/guides/how-to-scrape-linkedin-data
# How to Scrape LinkedIn Data with an API
DIY browsers vs LinkedIn partner/MDP APIs vs a data API for public people and company pages — tradeoffs and runnable code.
**Read on the site:** https://www.socialfetch.dev/guides/how-to-scrape-linkedin-data
There are three ways to pull public LinkedIn data into a product: drive your own headless browser, use LinkedIn's partner / Marketing Developer Platform APIs, or call a LinkedIn data API that hands back normalized JSON. LinkedIn's official APIs are partner- and member-authorized. A DIY LinkedIn scraper is a maintenance treadmill of auth walls and checkpoint challenges. For most enrichment pipelines, a data API is the pragmatic way to get public people and company pages as clean JSON. This guide compares all three — what each one really costs, where it breaks, and which one fits your project — with runnable code for every path, including the ones we don't sell. The shortest path is a single request: You'll need an API key and curl or the TypeScript SDK. New to the API? Start with the Quickstart. The three ways to get LinkedIn data Every approach is some version of these three. The right one depends on volume, whether you need member OAuth, and how much maintenance you want to own. | Approach | Best when | The real cost | | --- | --- | --- | | DIY (Puppeteer / Playwright) | A one-off research pull, internal tooling, or you specifically want to own the pipeline | Residential proxies, reused sessions, auth checkpoints — and re-fixing it every time LinkedIn tightens the wall | | LinkedIn partner / MDP APIs | You already have approved access and your need maps to member-authorized scopes | Partner process, app review, and product constraints — arbitrary public enrichment is usually not the contract | | Data API (Social Fetch) | You need public /in/… and /company/… cards, posts, or search in product code now, ideally across more than one platform | Metered per completed lookup (and per returned record on some list routes); you depend on a provider to keep the scrapers working | For most production apps that need public enrichment on demand, the data API is the fastest route to reliable JSON — one REST surface across LinkedIn, Instagram, TikTok, and the rest, with the same auth header and the same data + meta envelope. DIY is genuinely worth it for a weekend research scrape or to learn the internals. Official APIs are the right call when you're already inside LinkedIn's partner programs for member-authorized experiences. The rest of this guide covers each path, starting with the one most teams try first. Why DIY scraping turns into a maintenance project A plain fetch() to linkedin.com gets blocked almost immediately — LinkedIn's defenses inspect TLS fingerprints, cookies, and session state that a stock HTTP client does not match. So a working scraper isn't a script; it's a small system you build and then maintain indefinitely. Here's roughly what the browser-driven version looks like: That snippet only gets you raw HTML. Public cards often sit behind auth walls or challenge pages, and the structured fields live in Voyager-style JSON that changes without notice. And around it you're standing up: A residential or mobile proxy pool. Datacenter IPs are flagged within a few hits, so you need real ones with sticky, region-matched rotation. Session reuse and checkpoint recovery. Teams that inject cookies to look "logged in" inherit auth challenges, CAPTCHA loops, and account risk. Every checkpoint sends you back to babysit a browser. Page-type traps. /in/…, /company/…, and school/organization URLs are different entities. A single "LinkedIn scrape" selector that ignores page type forces your code to guess. Behavioral pacing. Fixed intervals read as a bot, so you add randomized delays and cap concurrency — slowing the whole thing down. The build is the easy part. The maintenance is worse: LinkedIn quietly reshapes cards and tightens walls, so a scraper that worked Tuesday returns challenge HTML Friday — and you hear it from a customer, not a test. For a one-off pull that's a fine weekend. For anything customer-facing, you've signed up for a maintenance subscription paid in your own evenings. For the broader build-vs-buy math, see Social Fetch vs DIY scraping. Why LinkedIn's official APIs won't cover it LinkedIn's developer platform is the right answer when your app lives inside LinkedIn's ecosystem — member login, partner features LinkedIn has approved, or Marketing Developer Platform products with the matching scopes. None of these are a general "look up this public /in/… URL" enrichment tool: Partner / member-authorized APIs expose data LinkedIn grants your app for approved use cases and members who authorize access. Marketing Developer Platform (MDP) covers LinkedIn-approved marketing and advertising workflows — not arbitrary public CRM enrichment without that relationship. Official products do not magically unlock "any profile on the internet." They unlock what LinkedIn authorizes for your app and members. So if you need public-page enrichment in a generic backend without partner access, official APIs leave a gap by design. Reach for them when your use case maps to LinkedIn-approved, member-authorized work; reach for a data API when you need publicly visible people and company cards without that process. Terms change often — check LinkedIn Developers before building against any of them. Using the Social Fetch API Social Fetch exposes LinkedIn under documented /v1/linkedin/ routes — people profiles, companies, organizations/schools, posts, people search, jobs, Ad Library, and transcripts where supported. One header authenticates every call, and responses share the same data + meta envelope across platforms. Get a person profile The same lookup in cURL, the TypeScript SDK, Python, and more — switch tabs to match your stack: Person profiles are 2 credits per URL requested (batch up to 50 URLs in one call). Charge is per URL in the request, not only per found result — check each item's lookupStatus. Pass a company URL into the person route and you will not get a company card; use the company endpoint below instead. Get a company page Company page lookups are 1 credit on a completed request. Schools and mixed organization page types use GET /v1/linkedin/organizations. Full parameters: Get LinkedIn profiles and Get LinkedIn company page. Every LinkedIn operation is in the API reference. People search and metered lists Some LinkedIn routes are flat credits; others are metered by returned records. Read the operation page before you wire a loop: | Route | Billing shape (completed lookup) | | --- | --- | | Person profiles | 2 credits per URL requested | | Company page | 1 credit | | Company posts | 1 credit flat per page | | People search | 2 attempt fee + 2 per returned person | | Profile posts list | 2 attempt fee + 2 per returned post | People search (GET /v1/linkedin/people/search) takes firstName and/or lastName — at least one is required. Empty result sets still pay the attempt fee when the lookup completes. Preflight reserves for the documented worst case; meta.creditsCharged is what actually billed. Details: Search LinkedIn people and Credits. Reading the response HTTP responses for person profiles are a batch envelope: one results[] entry per requested URL, plus a summary. A successful single-URL call looks like this: The TypeScript SDK's getProfile unwraps the first result so data.lookupStatus sits at the top level of that helper's return value. Either way: an HTTP 200 does not guarantee lookupStatus: "found". Branch before you upsert. Every response also carries meta.requestId, so if a number ever looks wrong, support can trace the exact lookup. See Errors. Social Fetch only returns publicly visible data. Content gated beyond public visibility is out of scope — you get a typed status, not invented private fields. What you can build CRM enrichment — resolve public /in/… and /company/… cards into structured rows before a sales or CS handoff. Account research — pull company pages and recent company posts for pipeline notes without running a residential browser farm. Go-to-market discovery* — use people search when you need name-based discovery, with eyes open on metered pricing and latency. For the same identity pattern across LinkedIn and creator networks, see Cross-platform creator profiles. FAQ Is scraping LinkedIn legal? It depends on your jurisdiction, what you collect, and how you use it. Collecting public, business-level metrics for B2B analytics is a common pattern, and courts (e.g. hiQ v. LinkedIn*) have generally treated public-web data as fair game in several jurisdictions. You remain responsible for LinkedIn's terms, applicable privacy law, and your own contracts. This is a technical guide, not legal advice — talk to counsel if you're collecting at scale. Can't I just use LinkedIn's official API? Not for arbitrary public /in/… or /company/… enrichment. Partner and MDP products are for LinkedIn-approved, member-authorized apps. For public-page enrichment without that access, a data API is the usual fit. See Why LinkedIn's official APIs won't cover it. How fresh is the data? Each request fetches live from LinkedIn at call time — there's no cache returning an hour-old snapshot. If a number looks off, meta.requestId lets support trace that specific lookup. What happens if a profile is missing or gated? Check lookupStatus on each result. Don't treat a 200 alone as "data is present." Content beyond public visibility is out of scope. Details in Errors. How are credits charged? Credits charge when a lookup completes. Person profiles are 2 credits per URL requested. Company pages are 1 credit. People search and profile-post lists are metered (2 attempt fee + 2 per returned record). Validation failures and upstream failures that never complete a lookup do not bill the same way — see Credits. Always reconcile against meta.creditsCharged. How does this compare to other providers? See the side-by-side comparisons: vs Apify, vs Bright Data, vs Proxycurl, the full compare hub, and Best LinkedIn data APIs in 2026. --- Next steps: Quickstart · LinkedIn platform hub · LinkedIn API reference · Pricing
---
# How to scrape TikTok with an API (2026)
Source: https://www.socialfetch.dev/guides/how-to-scrape-tiktok-data
# How to scrape TikTok with an API (2026)
Pull TikTok profiles, videos, and search as JSON — or compare DIY browsers and TikTok's official APIs. Tradeoffs and code.
**Read on the site:** https://www.socialfetch.dev/guides/how-to-scrape-tiktok-data
There are three ways to pull public TikTok data into a product: drive your own headless browser, use TikTok's official developer APIs, or call a TikTok data API that hands back normalized JSON. TikTok's official APIs don't expose the public data you see in a browser, and a DIY scraper is a maintenance treadmill. For most teams, a data API is the pragmatic way to get public profiles, videos, and search as clean JSON. This guide compares all three — what each one really costs, where it breaks, and which one fits your project — with runnable code for every path, including the ones we don't sell. The shortest path is a single request: You'll need an API key and curl or the TypeScript SDK. New to the API? Start with the Quickstart. The three ways to get TikTok data Every approach is some version of these three. The right one depends on volume, who's using the data, and how much maintenance you want to own. | Approach | Best when | The real cost | | --- | --- | --- | | DIY (Puppeteer / Playwright) | A one-off research pull, internal tooling, or you specifically want to own the pipeline | Residential proxies, fingerprint patching, token refresh — and re-fixing it every time TikTok changes | | Official TikTok APIs | You already have approved access and your need maps to an existing scope | An application and approval process; most public profile and video fields simply aren't exposed | | Data API (Social Fetch) | You need profiles, videos, search, or comments in product code now, ideally across more than one platform | Metered per request; you depend on a provider to keep the scrapers working | For most production apps that need public creator data on demand, the data API is the fastest route to reliable JSON — one REST surface across TikTok, Instagram, YouTube, and X, with the same auth header and the same data + meta envelope. DIY is genuinely worth it for a weekend research scrape or to learn the internals. Official APIs are the right call when you're already inside TikTok's partner programs. The rest of this guide covers each path, starting with the one most teams try first. Why DIY scraping turns into a maintenance project A plain fetch() to tiktok.com gets blocked almost immediately — TikTok's WAF inspects your TLS fingerprint (JA3/JA4) and a stock HTTP client doesn't match a real browser. So a working scraper isn't a script; it's a small system you build and then maintain indefinitely. Here's roughly what the browser-driven version looks like: That snippet only gets you raw HTML — the profile data isn't in the DOM, it's buried in a __UNIVERSAL_DATA_FOR_REHYDRATION__ blob you still have to locate and parse. And around it you're standing up: A residential or mobile proxy pool. Datacenter IPs are flagged within a few hits, so you need real ones with sticky, region-matched rotation. Fingerprint patching. Headless Chrome has tell-tale canvas and WebGL signatures — you patch them, then Chrome ships an update and your spoofed profile stops matching. Token plumbing. The faster hybrid approach (bootstrap cookies, then replay TikTok's internal JSON endpoints) means babysitting an msToken that expires every few minutes. Every 403 sends you back to launch a browser. Behavioral pacing. Fixed intervals read as a bot, so you add randomized delays and cap concurrency — slowing the whole thing down. The build is the easy part. The maintenance is worse: TikTok quietly renames internal endpoints and moves fields between JSON blobs, so a scraper that worked Tuesday returns empty arrays Friday — and you hear it from a customer, not a test. For a one-off pull that's a fine weekend. For anything customer-facing, you've signed up for a maintenance subscription paid in your own evenings. Why TikTok's official APIs won't cover it TikTok's developer platform is the right answer when your app lives inside TikTok's ecosystem — user login, publishing on a user's behalf, ads, or approved academic research. None of these are a general "look up this public profile" tool: Display API / Embed SDK renders videos and profiles on your site with TikTok's branding intact — not bulk metadata, comments, or search. Research API exposes more (content metadata, public account data, sometimes comments) but is restricted to academic and non-profit researchers in eligible regions, takes weeks to approve, and prohibits commercial use — so you can't build a product on it. Marketing / Commercial APIs cover ads and business accounts, not arbitrary public creator lookups. So if you need web-parity public data in a generic backend, official APIs leave a gap by design. Reach for them when your use case maps to one; reach for a data API when it doesn't. Terms change often — check TikTok for Developers before building against any of them. Using the Social Fetch API Social Fetch exposes TikTok under documented /v1/tiktok/ routes — profiles, videos, search, comments, transcripts, shop products, and more. One header authenticates every call, and responses share the same data + meta envelope across platforms, so your TikTok code looks identical to your Instagram or YouTube code. Get a profile The same lookup in cURL, the TypeScript SDK, Python, and more — switch tabs to match your stack: List a profile's videos Full parameters live in the reference: Get TikTok profile and Profile videos. Every TikTok operation is in the API reference. Paginate through everything Video and comment endpoints return one page plus a cursor. To pull a full history, pass the cursor back verbatim until it's gone — no decoding, no arithmetic: Stop when data.page.nextCursor is null. Don't loop on a total count — upstream totals are estimates and often disagree with what's actually paginatable. The cursor is the source of truth. Reading the response A successful response wraps the payload alongside billing metadata, so you always know what a call cost: The one gotcha: an HTTP 200 does not guarantee lookupStatus: "found". A private or non-existent account can return 200 with a status field telling you what actually happened — handle it in application logic, not by trusting the status code. Every response also carries meta.requestId, so if a number ever looks wrong, support can trace the exact lookup. See Errors. What you can build Influencer vetting — pull profile metrics and recent videos before outreach, and reconcile CRM handles against live numbers so you're not paying creators on stale stats. Trend monitoring — combine TikTok search with hashtag endpoints to surface emerging topics for a content team, refreshed on a schedule. Competitive intelligence* — snapshot competitor profiles and video performance weekly, across every brand you track, without running a scraper per brand. FAQ Is scraping TikTok legal? It depends on your jurisdiction, what you collect, and how you use it. Collecting public, business-level metrics for B2B analytics is a common pattern, and courts (e.g. hiQ v. LinkedIn*) have generally treated public-web data as fair game in several jurisdictions. You remain responsible for TikTok's terms, applicable privacy law, and your own contracts. This is a technical guide, not legal advice — talk to counsel if you're collecting at scale. Can't I just use TikTok's official API? Not for public profile and video lookups. The Research API exposes more data but is academic/non-profit only and bars commercial use; the Display and Commercial APIs handle embedding, login, publishing, and ads. For web-parity public data in a generic backend, a data API is the usual fit. See Why TikTok's official APIs won't cover it. How fresh is the data? Each request fetches live from TikTok at call time — there's no cache returning an hour-old snapshot. If a number looks off, meta.requestId lets support trace that specific lookup. What happens if a profile is private or doesn't exist? Check data.lookupStatus. Don't treat a 200 alone as "data is present" — a private or missing account returns 200 with a status field. Details in Errors. How does this compare to other providers? See the side-by-side comparisons: vs Apify, vs Bright Data, vs EnsembleData, and the full compare hub. --- Next steps: Quickstart · TikTok API reference · Get a video transcript · Pricing
---
# How to scrape Truth Social data with an API
Source: https://www.socialfetch.dev/guides/how-to-scrape-truth-social-data
# How to scrape Truth Social data with an API
DIY scrapers vs Truth Social's app vs a data API for public profiles and posts — tradeoffs and runnable code.
**Read on the site:** https://www.socialfetch.dev/guides/how-to-scrape-truth-social-data
There are three ways to pull public Truth Social data into a product: run your own HTTP or browser scraper, use Truth Social's first-party app for account workflows, or call a Truth Social data API that hands back normalized JSON. Truth Social's app is for posting and account management — not a general "look up this public handle from my backend" tool. A DIY client is a maintenance treadmill of auth, pagination, and field drift. For most teams, a data API is the pragmatic way to get public profiles and posts as clean JSON. This guide compares all three — what each one really costs, where it breaks, and which one fits your project — with runnable code for the Social Fetch path. The shortest path is a single request: You'll need an API key and curl or the TypeScript SDK. New to the API? Start with the Quickstart. The three ways to get Truth Social data Every approach is some version of these three. The right one depends on volume, who's using the data, and how much maintenance you want to own. | Approach | Best when | The real cost | | --- | --- | --- | | DIY (HTTP / Playwright) | A one-off research pull, internal tooling, or you specifically want to own the pipeline | Session babysitting, field drift, and re-fixing every time public pages change | | Truth Social first-party | You need to publish, DM, or manage an account | App UX only — not a metered enrichment API for arbitrary public handles | | Data API (Social Fetch) | You need profiles and posts in product code now, ideally across more than one platform | Metered per completed lookup; you depend on a provider to keep the scrapers working | For most production apps that need public Truth Social data on demand, the data API is the fastest route to reliable JSON — one REST surface across Truth Social, Instagram, X, and Telegram, with the same auth header and the same data + meta envelope. DIY is genuinely worth it for a weekend research scrape or to learn the internals. First-party is the right call when you're posting or managing an account. Why DIY clients turn into a maintenance project A plain fetch() to a public Truth Social URL can work until it doesn't — login walls, rate limits, and response shape changes show up without a changelog. Homegrown clients can get you through a weekend research pull, but your product still needs typed misses, a stable error envelope, and a support id when a customer files a ticket. Around a DIY client you're standing up: Auth and session handling if you lean on logged-in surfaces instead of public pages. Pagination quirks that differ from the rest of your marketplace parsers. Field drift when presentation or metrics keys move. A second vendor story if everything else already runs through one Social Fetch key. The build is the easy part. The maintenance is worse: a scraper that looked solid in staging drifts in production. For a one-off pull that's a fine weekend. For anything customer-facing, you've signed up for a maintenance subscription paid in your own evenings. For the broader build-vs-buy math, see Social Fetch vs DIY scraping. Why the official app won't cover enrichment Truth Social's own product is the right answer when your workflow lives inside the app — publishing, notifications, DMs, or account settings. None of these are a general "look up this public handle from my CRM" tool: Posting and account management require a user session and Truth Social's product surface. Partner or first-party APIs (when available) are for authorized write and account flows — not arbitrary public enrichment for every handle in your database. Browser automation against the logged-in UI reintroduces the DIY maintenance tax. So if you need web-parity public data in a generic backend, the official app leaves a gap by design. Reach for first-party tools when your use case maps to writing or owning an account; reach for a data API when it doesn't. Using the Social Fetch API Social Fetch exposes Truth Social under documented /v1/truthsocial/ routes — profile by handle, cursor-paginated profile posts, and a single post by public status URL. One header authenticates every call, and responses share the same data + meta envelope across platforms, so your Truth Social code looks identical to your Instagram or Telegram code. Get a profile The same lookup in cURL, the TypeScript SDK, Python, and more — switch tabs to match your stack: Truth Social profile lookups are credit-metered when the lookup completes (including not_found outcomes that still return HTTP 200). Trust meta.creditsCharged on every response. Pass the public username with or without @. List a profile's posts Full parameters live in the reference: Get Truth Social profile and Profile posts. Each completed page is a separate credit charge. Get a single post by URL When you already have a public status permalink, hydrate it directly: Docs: Get Truth Social post. Paginate through posts Profile post list endpoints return one page plus an opaque cursor. To pull older posts, pass the cursor back verbatim until hasMore is false — no decoding, no arithmetic: Stop when data.hasMore is false or data.cursor is null. Don't invent page numbers. The cursor is the source of truth. Each page is a separate completed lookup for billing. Reading the response A successful response wraps the payload alongside billing metadata, so you always know what a call cost: The one gotcha: an HTTP 200 does not guarantee lookupStatus: "found". A missing handle or deleted status can return 200 with not_found — handle it in application logic, not by trusting the status code. Every response also carries meta.requestId, so if a number ever looks wrong, support can trace the exact lookup. See Errors and Credits. What you can build Political and news monitors — hydrate high-signal Truth Social accounts that often do not mirror the same text on X or Facebook. CRM / enrichment jobs — resolve handles before outreach or brand-safety review, then page posts only for accounts you still care about. Agent and MCP workflows — call the same typed tools from Cursor or Claude with the same credit metering as REST. For vendor shopping without implementation detail, see Best Truth Social APIs & scrapers in 2026. For listening dashboards across networks, see Social listening dashboard. FAQ Is scraping Truth Social legal? It depends on your jurisdiction, what you collect, and how you use it. Collecting publicly visible profile and status data for B2B analytics is a common pattern. You remain responsible for Truth Social's terms, applicable privacy law, and your own contracts. This is a technical guide, not legal advice — talk to counsel if you're collecting at scale. Can't I just use Truth Social's app or scrape the site myself? Use the official app for posting and account management. DIY HTTP or browser clients can work for personal scripts, but you own maintenance. For public enrichment in a multi-platform backend, a data API is the usual fit. See Why the official app won't cover enrichment. How fresh is the data? Each request fetches live at call time — there's no cache returning an hour-old snapshot. If a number looks off, meta.requestId lets support trace that specific lookup. What happens if a profile doesn't exist? Check data.lookupStatus. Don't treat a 200 alone as "data is present" — a missing handle returns 200 with not_found. Details in Errors. How are credits charged? Credits charge when a lookup completes**, including 200 outcomes like not_found. Each Truth Social profile, profile-posts page, and post lookup is credit-metered. Validation failures and upstream lookup_failed / temporary unavailability do not bill the same way — see Credits. Always reconcile against meta.creditsCharged. How does this compare to other providers? See Best Truth Social APIs & scrapers in 2026, plus vs Apify, vs Bright Data, and the full compare hub. --- Ready to try it? Get an API key — new accounts include 100 free credits. Platform hub: /platforms/truthsocial.
---
# LinkedIn partner API vs public data (2026)
Source: https://www.socialfetch.dev/guides/linkedin-partner-api-vs-public-data
# LinkedIn partner API vs public data (2026)
Why LinkedIn Marketing Developer Platform and partner APIs are hard to get, when you actually need them, and when a public-data enrichment API is enough.
**Read on the site:** https://www.socialfetch.dev/guides/linkedin-partner-api-vs-public-data
GTM and CRM teams ask for "LinkedIn API access" and mean: enrich this /in/… URL, pull the company page, list recent posts. LinkedIn's developer portal hears something else: build an approved experience with member OAuth, ads, or Marketing Developer Platform (MDP) scopes. Those are different products. Confusing them is why enrichment projects stall for months waiting on partner approval that was never going to cover arbitrary public profile GETs. Need sign-in, posting on behalf of a member, ads, or an experience LinkedIn has approved? Use LinkedIn's official APIs. Need public people, company, post, job, or Ad Library JSON for enrichment without a partner deal? Use a public-data API such as Social Fetch LinkedIn — credit-metered, same envelope as other platforms, charge on completed lookups. The access problem in one paragraph LinkedIn does not sell a self-serve "enrich any public profile" SKU the way you buy a credit pack elsewhere. Official developer products are gated around apps LinkedIn trusts and members who grant permission. If your feature is "prospect never connected to us; we only have their public LinkedIn URL," you are outside that model. Waiting on MDP approval will not invent a product LinkedIn did not ship. What LinkedIn's official APIs are for LinkedIn's developer surface (partner programs, member authorization, Marketing Developer Platform and related products) is built for: Sign-in and identity Publishing or managing content on behalf of a member who connected Ads and approved marketing integrations Partner features LinkedIn explicitly opens to a program That path is correct when your product sits inside LinkedIn's permission model. It is the wrong procurement ticket for CRM enrichment of cold /in/… URLs. Plain glossary answer: Does LinkedIn have an API?. Why partner access feels like a wall Teams that treat "apply for LinkedIn API" as a checkbox hit the same friction: Approval is not a pricing page. You are not picking Free / Pro. You are asking LinkedIn whether your use case fits a program. Many enrichment and scraping-shaped products never get (and may never need) that access. Scopes follow members, not public pages. Official reads and writes assume someone authorized your app. A spreadsheet of public URLs is not an authorized member graph. The sales and compliance process has its own calendar. Roadmaps that block on "when MDP lands" lose quarters. If the feature only needs public fields, that wait was optional. Vendor concentration risk is real. LinkedIn-only enrichment businesses can vanish (Proxycurl shut down in July 2025 after LinkedIn litigation). See Social Fetch vs Proxycurl for the migration framing — and prefer vendors that are not a single-network bet if your product already spans TikTok and Instagram. None of this is a complaint that LinkedIn should open unrestricted scrapes. It is a product classification: partner APIs and public enrichment solve different jobs. Public enrichment is a different product A public-data LinkedIn API accepts public identifiers (person /in/…, company pages, public post or job URLs) and returns structured JSON your pipeline can upsert. No LinkedIn partner app required for those lookups. No member OAuth for the prospect. Compliance and ToS still apply to your use of public data. A managed API moves fetch-layer maintenance off your team; it does not erase lawful-use obligations. Read LinkedIn's terms for your use case. I am not your lawyer. DIY browser farms, session reuse, and Sales Navigator automations are a third path — high maintenance, high breakage, often the wrong compliance story. Tradeoffs: Social Fetch vs DIY scraping. Outreach automation (not a profile schema API): vs PhantomBuster. Creator OAuth / connection-style products: vs Phyllo. Decision table | You need… | Prefer | | --- | --- | | Member login, posting, ads, LinkedIn-approved UX | Official LinkedIn partner / MDP APIs | | Enrich public /in/… or company pages in CRM / GTM | Public-data API (LinkedIn hub) | | Multi-platform creator or agency reporting | Public-data API with one schema across networks | | Custom Actor or scheduled HTML dump | Marketplace scrapers (e.g. Apify) — different ops model | | Cloud outreach playbooks | Automation tools, not enrichment REST | If counsel requires LinkedIn-approved access for a specific product surface, stay official for that surface. Enrichment of public pages can still live on a separate public-data key. What Social Fetch covers on LinkedIn Social Fetch exposes documented /v1/linkedin/... routes for public people profiles, company pages, organizations, posts, people search, jobs, Ad Library, and post transcripts where available. Responses use the shared envelope — lookupStatus, meta.requestId, meta.creditsCharged — next to TikTok, Instagram, and X. Typical path: 1. Sign up; spend free credits on one person URL and one company page 2. Call GET /v1/linkedin/profiles with public url params (batchable) 3. Branch on lookupStatus before upsert; keep requestId on failures Vendor shortlist and official-vs-enrichment ranking: Best LinkedIn data APIs in 2026. Cross-network creator cards: Cross-platform creator profiles. Billing for enrichment volume LinkedIn on Social Fetch is credit-metered. Do not assume every call is 1 credit. From our docs and pricing page: 100 free credits on signup, no card Profile GETs are typically 2 credits per URL (up to documented batch limits) Search and list routes (people search, profile posts, and similar) often cost more — attempt fees plus per-row charges appear on some operations. Read the operation page Charge on completed lookups — trust meta.creditsCharged. Pre-send validation errors and our infrastructure failures (lookup_failed, 503 temporarily_unavailable) do not debit. Completed not_found can bill because the lookup ran PAYG credits do not expire; optional subscriptions exist for steady volume That meter is simpler than waiting on partner approval: buy capacity, call public URLs, reconcile from meta. Related reading How to scrape LinkedIn data — DIY vs partner/MDP vs Social Fetch with runnable GETs LinkedIn platform hub — routes and examples Best LinkedIn data APIs in 2026 — ranked options Does LinkedIn have an API? — short glossary Social Fetch vs Proxycurl — post-shutdown LinkedIn enrichment Social Fetch vs Phyllo — connection / creator OAuth lane Social Fetch vs PhantomBuster — automation vs JSON enrichment Pricing — packs, charge-on-completed-lookup rules FAQ Does LinkedIn have an API? Yes. Official partner and member-authorized APIs exist. Public-data APIs cover public profiles, companies, posts, jobs, and search without MDP access. Details: glossary. Can I use LinkedIn's official API for any public /in/ URL? Generally no. Official access follows approved apps and member permissions. Arbitrary public enrichment is a different product category. Does Social Fetch replace LinkedIn partner APIs? No. Public page lookups only. Keep LinkedIn's APIs for posting, login, ads, and approved marketing features. Do LinkedIn lookups cost credits on Social Fetch? Yes. Profile GETs are typically 2 credits per URL; search and list routes can cost more. Always check meta.creditsCharged. Is LinkedIn scraping legal? You remain responsible for lawful use under LinkedIn's terms and local law. We return publicly visible data and do not give legal advice.
---
# Reddit Product Research with an API (2026)
Source: https://www.socialfetch.dev/guides/reddit-product-research
# Reddit Product Research with an API (2026)
Search public Reddit for competitor mentions, switching intent, and feature requests — JSON for spreadsheets, dashboards, or summaries.
**Read on the site:** https://www.socialfetch.dev/guides/reddit-product-research
Reddit threads surface unfiltered switching stories, competitor comparisons, and feature gaps that never make it into sales calls. The hard part is collecting those threads at scale without maintaining Reddit's auth and pagination quirks yourself. This guide walks through a research sprint — the same sequence product teams run manually, but with API calls you can schedule, dedupe, and hand to a PM spreadsheet. GET /v1/reddit/search with a query parameter returns public posts as JSON. Paginate with cursor, scope to subreddits when you know the community, pull comments on high-signal threads, and merge into the research tool you already use. We use a fictional competitor check on project-management tools as the running example; swap in your product name and subreddit list. You'll need an API key. Try a search in the Playground. New to Reddit access models? Start with How to get a Reddit API key or smoke-test a query in the free Reddit research tool. Why Reddit beats surveys for switching stories Surveys tell you what people think they would do. Reddit threads often describe what they did — including the messy middle: trial extensions, half-migrated teams, pricing surprises, integrations that broke on day three. Three patterns show up repeatedly in product research: Switching language — "moved from Asana to Linear because…" gives you the reason, not a 1–5 satisfaction score. Niche job context — r/sysadmin and r/selfhosted discuss the same category (monitoring, backups, auth) with completely different constraints than r/startups. Long-form self-posts — the post body plus top comments can read like a mini case study; worth archiving when you build battlecards. Product teams use Reddit for positioning checks, roadmap validation, and churn post-mortems. The API work is mostly collection — your judgment still picks which threads matter. Phase 0: Write the question before the query Before touching code, write one sentence your sprint must answer. Vague goals produce vague queries. | Research goal | Example question | Bad query | Better query | | --- | --- | --- | --- | | Competitive positioning | Why do teams leave Notion for Coda? | notion | switching from notion | | Feature gaps | What do users want that our roadmap lacks? | project management | wish notion had OR notion missing | | Pricing sensitivity | Are we expensive vs incumbents? | expensive | notion too expensive | | Launch monitoring | Did v2.4 change sentiment? | acme | acme v2.4 with timeframe=week | List 8–15 query variants per product. Group them: 1. Brand — product name, common misspellings. 2. Alternatives — alternative, best tool. 3. Switching — switching from , migrated from , leaving . 4. Pain — slow, pricing, support. You will run these in Phase 6. First, cast a wide net globally, then narrow to subreddits. Phase 1: Global keyword sweep Start with site-wide search. This finds threads you would not guess from subreddit names alone — cross-posts, niche communities, old threads that still rank. Parameters worth tuning: | Parameter | Values | When to use | | --- | --- | --- | | sortBy | relevance, new, top | top + timeframe=year for battlecard fodder; new for launch week | | timeframe | day, week, month, year, all | Pair with sortBy=top; skip on new | | cursor | opaque string from data.page.nextCursor | Next page — do not construct manually | Full spec: Reddit search. A single page is rarely enough. Paginate until data.page.hasMore is false or you hit your credit budget: Check data.page.hasMore — do not infer completion from data.totalResults alone; that field counts the current page. Phase 2: Map the subreddits that matter Global search is noisy. The second pass targets communities where your buyers actually post. | Category | Example subreddits | What you learn | | --- | --- | --- | | B2B SaaS | r/SaaS, r/startups, r/Entrepreneur | Pricing, churn, "what stack do you use" | | Role-specific | r/sysadmin, r/devops, r/productivity | Workflow constraints incumbents ignore | | Product-specific | r/Notion, r/ObsidianMD, r/selfhosted | Power-user feature requests, workarounds | | Vertical | r/realestate, r/ecommerce, r/legaltech | Industry-specific objections | Discovery trick: run global search once, tally post.subreddit frequencies, and promote the top five into your scoped list. A PM tool might surface r/Notion, r/productivity, and r/SaaS — but r/ADHD or r/GradSchool can dominate for certain personas. Validate a subreddit exists before building cron jobs: Reference: Get subreddit. Subscriber counts and descriptions help you prioritize where a thread's upvotes actually mean something. Phase 3: Search inside one community When you know the subreddit, scoped search cuts noise. Use GET /v1/reddit/subreddits/search — different route from global search, with sort options like comments for threads where the argument lives in replies. TypeScript equivalent: Reference: Subreddit search. Query tactics that work in practice: Drop the brand in pain threads — search frustrated or cancel inside r/YourProductSubreddit before searching your competitor's name globally. Category without brand — best crm for small team inside r/smallbusiness surfaces options your brand might not appear in yet. Sort by comments — sort=comments surfaces debate threads; pair with Phase 5 comment pulls. Phase 4: Browse a subreddit feed Sometimes you do not have a keyword — you want "what is hot in r/selfhosted this month." List the feed directly: | sort value | Typical research use | | --- | --- | | top | Highest-engagement posts in the timeframe window | | new | Fresh complaints right after a competitor launch | | hot | What the community is actively engaging with now | | rising | Early signal before a thread hits front page | Reference: Subreddit posts. Subreddit names must match Reddit's casing — SaaS not saas. The path parameter accepts r/ prefix or a full subreddit URL. Filter client-side: keep posts where title or text matches your keyword list, or where metrics.commentCount exceeds a threshold (debate threads tend to carry switching rationale). Phase 5: Pull comment threads Titles lie (or undersell). Comments hold objections, workarounds, and "we tried X and went back to Y." Pass a post URL to the comments endpoint: Paginate comment pages the same way as search — data.page.nextCursor until hasMore is false. Top-level comments often include nested replies; flatten or walk the tree depending on your analysis tool. Reference: Reddit post comments. For scoring comment text at scale, see the sentiment guide. Pull comments selectively — not every search hit deserves a comment page. Heuristics that save credits: metrics.commentCount above 20 metrics.score above 50 for niche subreddits (adjust per community size) Title matches a switching phrase from Phase 0 Phase 6: Batch the query matrix Run your query variants and merge results. Dedupe by post.id or canonical url before analysis. Extend the loop: add timeframe, paginate inner loops when hasMore is true, and write meta.requestId on every row. If a thread's score looks wrong in your spreadsheet, support can trace the exact lookup. For weekly monitoring, wrap the batch in a cron or QStash job — same pattern as the social listening guide, but with Reddit query matrices instead of brand keywords across platforms. Store rows your PM can sort Normalize API responses into flat rows your team already uses — Airtable, Postgres, Google Sheets, Notion database: Suggested columns for a research board: | Column | Source field | Why | | --- | --- | --- | | Theme | your taxonomy | "pricing", "performance", "missing feature" — manual or LLM-tagged | | Evidence | url | Link back to the thread for quotes in decks | | Weight | score, commentCount | Rank themes by engagement, not mention count alone | | Freshness | createdAt / publishedAt | Deprioritize stale threads unless evergreen | Export to CSV, or pipe title + bodyText + top comment texts into an LLM summary with the thread URL as citation. Keep requestId in the warehouse — it is your audit trail. Troubleshooting Empty results but the thread exists in a browser Global search may not surface every post. Try scoped subreddits/search with the subreddit from the URL. Check timeframe — day on a year-old thread returns nothing with sortBy=top. Query length maxes at 512 characters; shorten long boolean-style strings. not_found on subreddit or post lookups Casing: Reddit treats Fitness and fitness differently. Copy the exact name from the address bar. Deleted or quarantined content returns not_found at lookup time — not a billing bug. Pass the full https://www.reddit.com/r/.../comments/... URL to comments, not a short link or old.reddit redirect stripped of path segments. Duplicate threads in merged results The same post appears under multiple queries. Dedupe on post.id before counting mentions. Cross-posts share text but have different IDs — dedupe on url or normalized permalink if you want one row per discussion. Scores and counts look stale Each response is point-in-time. Re-fetch before quoting metrics in a board deck. Store capturedAt alongside score so analysts know the snapshot age. lookup_failed or HTTP 503 Not charged. Retry with backoff; include meta.requestId from the failed attempt if you contact support. Bursting hundreds of parallel requests is unnecessary — sequential pagination with modest concurrency is fine. Rate limits No request quotas on metered routes — credits are the only limit. Under extreme concurrency you may get 503 with Retry-After (not charged). Staying under ~500 concurrent requests is a courtesy, not a ceiling. Billing and boundaries Each search page, subreddit feed page, and comment page is a separate credit (typically 1 per successful request). A completed lookup with zero posts still ran upstream and is billed. You are never charged for pre-send validation errors, lookup_failed, or 503 temporarily_unavailable. Rough sprint math for planning: | Step | Calls | Credits (approx.) | | --- | --- | --- | | 10 queries × 2 pages global search | 20 | 20 | | 5 subreddits × 1 scoped search | 5 | 5 | | 15 high-signal comment pulls | 15 | 15 | | Total | 40 | 40 | Public data only — you remain responsible for lawful use under Terms. See Credits. Official Reddit commercial rates vs Social Fetch credits: Reddit API pricing. What you can build Competitive battlecards — weekly pull of alternative to and switching from with top comment quotes attached. Feature prioritization — rank request themes by upvote-weighted frequency inside product-specific subreddits. Launch monitoring — alert when mention volume spikes after a release (sortBy=new, timeframe=week). Churn autopsy feed — tag threads matching cancel, refund, moved to for CS and product sync. Persona research — same product name searched across r/sysadmin vs r/marketing to compare job-to-be-done language. --- Next steps: Playground · Reddit hub · Reddit research recipe · Reddit API pricing · Pricing
---
# Reddit Search API: how to search Reddit over HTTP (2026)
Source: https://www.socialfetch.dev/guides/reddit-search-api
# Reddit Search API: how to search Reddit over HTTP (2026)
How to search Reddit programmatically — global keyword search, subreddit-scoped search, pagination, and how it compares to Reddit's own search.
**Read on the site:** https://www.socialfetch.dev/guides/reddit-search-api
Reddit is one of the few places people describe switching between products in their own words — "cancelled X because Y broke," "anyone got a cheaper alternative to Z." Search is how you find that text. This guide covers the mechanics: which endpoint to call, what the parameters do, how to paginate, and how a public-data search API differs from wiring Reddit's own Data API for the same job. If you're setting up credentials first, see How to get a Reddit API key. If you're running a full research sprint — subreddit discovery, comment mining, sentiment scoring — see Reddit product research. This page is the narrower reference: how the search call itself works. What "Reddit search API" means here Two different things get called "the Reddit search API": 1. Reddit's own Data API search — an OAuth-gated endpoint under Reddit's official developer terms, meant for Reddit-native clients and approved apps. 2. A public-data API's Reddit search route — a third-party service (like Social Fetch) that reads Reddit's public posts and exposes them as a plain GET endpoint with its own key and billing model. Both return posts matching a keyword. The difference is everything around the call: auth model, rate limits, response shape, and whether you're building a Reddit-native product or pulling public posts into a research or monitoring pipeline. This guide covers the second kind. The two search endpoints | Endpoint | Use it for | | --- | --- | | GET /v1/reddit/search | Global keyword search across all of Reddit — competitor names, switching phrases, "best tool for X." | | GET /v1/reddit/subreddits/search | Finding subreddits by topic before you know the exact name — query "project management" to surface r/productivity, r/SaaS. | Once you know the exact community, GET /v1/reddit/subreddits/ /posts returns its feed directly (hot/top/new) without a keyword — useful when you want everything from a community, not a match. A first request The response returns matching posts (title, body, score, subreddit, permalink, createdAt) under data, with meta.requestId and meta.creditsCharged alongside — the same envelope every Social Fetch route uses, so a Reddit integration doesn't need its own error-handling branch next to your TikTok or Instagram code. Parameters that matter query — the keyword or phrase. Quote exact phrases the way you would in a browser search for tighter matches. sortBy — relevance, new, or top. relevance for exploratory search, top for backfills where you want the highest-signal posts first, new for monitoring what just got posted. timeframe — day through all. Bound a backfill (year) or a monitoring window (week) so you're not re-pulling the same old posts every run. Paginating results Every response carries data.page.nextCursor and data.page.hasMore. Loop until hasMore is false: Each page is a separate billed lookup, so a wide backfill across many queries adds up — budget credits before you kick off a 12-month, multi-keyword pull rather than discovering the cost mid-run. Reddit's own search API vs a public-data API | | Reddit's official Data API | Social Fetch | | --- | --- | --- | | Auth | Registered app + OAuth | One sfk_… API key | | Setup time | App registration, approval risk for commercial use | Minutes | | Rate limit | ~100 QPM per OAuth client on approved access | No request quota — credits are the limit | | Billing | Free non-commercial tier + separate commercial contract | Prepaid credits, one rate, no expiry | | Response shape | Reddit's native listing format | Same envelope as every other platform | | Scope | Full Reddit access per your app's approved scopes | Public posts, comments, and search only | If you're building a Reddit-native client, mod tooling, or anything that needs scopes beyond public reads, Reddit's own API is the right — and only — path; see How to get a Reddit API key for that flow. If public search is enough, skip the OAuth setup. Common patterns Competitor mention tracking — cron sortBy=new&timeframe=week against your product and competitor names, diff against the last run, alert on volume spikes. Launch backfill — sortBy=top&timeframe=year on a category phrase ("alternative to Airtable") to find every high-signal thread before you start reading. Subreddit discovery first — when you don't know where a conversation lives, run GET /v1/reddit/subreddits/search before the keyword search, then scope your queries to the communities that actually matter instead of wading through unrelated results. Full multi-endpoint workflow — subreddit discovery, comment mining, sentiment scoring in your own stack: Reddit product research. Endpoint reference: Reddit platform hub. Try a query with no key first: free Reddit research tool. --- Next steps: Reddit hub · How to get a Reddit API key · Reddit product research · Pricing
---
# Social Comments for Sentiment Analysis with an API (2026)
Source: https://www.socialfetch.dev/guides/social-comments-for-sentiment-analysis
# Social Comments for Sentiment Analysis with an API (2026)
Pull paginated comments from TikTok, YouTube, Instagram, Reddit, and more as normalized JSON — ready for keyword rules, classifiers, or LLM batch jobs.
**Read on the site:** https://www.socialfetch.dev/guides/social-comments-for-sentiment-analysis
A sponsored caption can read positive while the comment section argues about shipping delays. Sentiment on post text alone misses that split — and on most networks the argument lives behind infinite scroll, different sort orders, and nested reply trees. This guide walks through comment collection for scoring pipelines: which endpoints to call on TikTok, YouTube, Instagram, and Reddit, how pagination actually works, when to sample instead of draining a thread, and how to hand normalized text to keyword rules or an LLM classifier without double-counting the same reply on every cron run. Pass a public post URL to a platform's comments endpoint, paginate with cursor, and feed comment.text into your classifier. Same envelope on every platform. You'll need an API key. Test comment lookups in the Playground. Why comments beat post text alone Post copy is one voice. Comments are hundreds of independent reactions — often angrier, more specific, and closer to purchase intent than anything in the creative brief. | Signal | Where it shows up | Why it matters for sentiment | | --- | --- | --- | | Objections | "shipping took 3 weeks" | Product gaps surface in replies, not captions | | Brand perception | "used to love them until…" | Churn language clusters in threads | | Campaign QA | Debate under sponsored posts | Creative testing via audience pushback | | Creator risk | Toxic reply patterns | Partnership vetting before you sign | Manual copy-paste fails on pagination, breaks when URLs redirect, and does not scale to a launch monitor that runs hourly. A scheduled job with cursors and a warehouse table does. Pair comment pulls with search-based listening when you do not already have the post URL — search finds candidates; comments endpoints score the ones that crossed your velocity threshold. Which platforms expose comments Social Fetch normalizes comment listing under predictable routes. Pattern: GET /v1/ /posts/comments or .../videos/comments, required url, optional cursor. | Platform | Route | Notable query params | Reply depth | | --- | --- | --- | --- | | TikTok | /v1/tiktok/videos/comments | trim for lighter payloads | Top-level per page; replyCount on each row | | YouTube | /v1/youtube/videos/comments | order=top or newest | /v1/youtube/videos/comments/replies per thread | | Instagram | /v1/instagram/posts/comments | works on posts and reels | Top-level; replyCount when reported | | Reddit | /v1/reddit/posts/comments | trim | Nested replies on each comment | | Facebook | /v1/facebook/posts/comments | — | Top-level pages | | Rumble | /v1/rumble/videos/comments | — | Top-level pages | Every response includes data.lookupStatus (found or not_found), data.comments, data.page.nextCursor, data.page.hasMore, and meta.requestId. Field names differ slightly per platform — TikTok uses likes on the comment object; YouTube uses likeCount; Reddit uses score — but text and id are always there for scoring. Phase 0: Scope the scoring job Before you paginate, write down what "done" means. Vague goals produce expensive full-thread pulls on videos that do not need them. | Job type | Example question | Typical pull | | --- | --- | --- | | Launch monitor | Did sentiment flip negative after the drop? | Top 2–3 pages per flagged post, hourly | | Creator vetting | Are reply threads hostile? | First 500 comments by likes on recent posts | | Support triage | Which posts need a human? | Keyword filter on newest page only | | Research archive | What objections appear in r/SaaS? | Full pagination on 10–20 high-score threads | List inputs: post URLs from your CMS, URLs from a Reddit research sprint, or video IDs from TikTok search. Set a per-post page cap before you write the loop — cursors make it easy to overspend. TikTok video comments TikTok threads move fast and skew short. Comments often carry the meme reaction while the on-screen caption stays neutral. Useful fields for scoring: text — primary classifier input likes — weight positive/negative aggregates (high-like sarcasm still counts) language — route to locale-specific models without guessing replyCount — prioritize threads with debate before you pay for more pages author.handle — blocklist repeat spam accounts client-side Optional trim=true drops ancillary fields when you only need text and ids for batch scoring. Reference: TikTok video comments. On viral videos, totalComments in the response helps you decide whether full pagination is worth it — a post with 40,000 comments rarely needs every page for a dashboard chart. YouTube video comments YouTube exposes sort order at query time. That matters because "top" and "newest" can disagree on sentiment for the same video. | order value | When to use | | --- | --- | | top | Default for brand monitoring — surfaces the visible thread | | newest | Launch week, controversy spikes, or support triage | Fields worth storing: likeCount and replyCount — same weighting story as TikTok author.creator — creator replies often clarify context; tag separately in aggregates repliesCursor — non-null means a sub-thread exists Nested replies are a separate endpoint. After listing top-level comments, fetch replies for rows where replyCount exceeds your threshold: Each reply page bills separately. For sentiment, scoring top-level comments plus high-reply threads usually captures the argument without walking every leaf node. Reference: YouTube video comments · Comment replies. Instagram post comments Instagram comments on reels and feed posts share one route. Pass the full post or reel URL from the share sheet — shortened instagr.am links usually work, but the canonical /p/ or /reel/ URL is safest. TypeScript with the SDK: Instagram returns top-level comments per page. replyCount tells you where sub-threads exist; there is no separate replies route today — weight high-reply top-level comments heavily if the debate lives in one visible reply chain. author.verified helps filter brand-account replies when you want audience-only sentiment. Reference: Instagram post comments. Reddit post comments Reddit is where sentiment work pays off for B2B and product research — long objections, switching stories, and nested arguments. If you arrived from search, pull comments only on threads that passed your score filter (see the Reddit research guide). Reddit comments include depth, nested replies, and score. Flatten before feeding an LLM if your classifier expects a list of strings: Use trim=true when you only need text, score, and ids. Keep isSubmitter — OP clarifications change how you read negative replies. Reference: Reddit post comments. Facebook posts follow the same URL-in pattern at /v1/facebook/posts/comments when you need comment text on Page posts or public group discussions. Paginate the full thread Comment endpoints return one page plus data.page.nextCursor. Loop until hasMore is false or you hit your budget cap: Checklist for every pagination loop: 1. Stop when lookupStatus !== "found" — do not keep passing cursors after not_found. 2. Prefer hasMore over guessing from array length — empty pages can still have a cursor on some platforms. 3. Pass cursor verbatim — do not parse or construct tokens. 4. Log meta.requestId per page for support traces. Re-running the same cursor chain twice bills twice. Treat cursors as single-use pagination tokens within one ingestion run. Sampling strategies Full-thread pulls are the exception, not the default. A 30-second TikTok with 8,000 comments does not need 8,000 rows for a launch dashboard — the top three pages by default sort already skew what humans see in-app. | Strategy | How | Good for | | --- | --- | --- | | Page cap | Stop after N cursor iterations | Hourly monitors, credit budgets | | Engagement floor | Skip comments where likes/score < threshold | Noise reduction on viral posts | | Reply threshold | Only fetch YouTube reply pages when replyCount > 10 | Debate-heavy threads | | Time window | Re-fetch newest page only on repeat runs | Trend detection vs archive | | Stratified sample | Top page + newest page (YouTube order) | When sort order disagrees | | Search handoff | Comments only on posts from search hits above velocity | Monitoring workflows | For LLM batch jobs, chunk comments into batches of 50–100 texts with the post URL in the system prompt. Asking the model to score 5,000 comments in one prompt produces mushy averages and blows context limits. Weight aggregates by engagement: weighted_score = sentiment_score * log1p(likes) damps single-comment noise without ignoring a 10k-like pile-on. Feed LLM classifiers Normalized JSON maps cleanly to three scoring patterns. Keyword rules (cheap, deterministic) Run first. Flag refund, scam, love this, competitor names before you spend tokens. Classical ML (fast at volume) Export text + likes/score to your sklearn or Hugging Face pipeline. Train on a few hundred hand-labeled comments per vertical; rules catch spikes, the model catches paraphrases. LLM batch classification Send structured input — one JSON object per batch: Ask for per-id labels (positive, negative, neutral, mixed) and optional themes. Require JSON output; parse defensively. Store the model version on each row. Preprocessing that usually helps: 1. Strip URLs and bare @mentions if your model treats them as noise. 2. Keep emoji when monitoring Gen-Z brands — stripping flattens sarcasm. 3. Attach language (TikTok) or detect locale before routing to the right prompt. 4. Pair with transcripts when spoken claims and comment reactions diverge. Roll per-comment labels into post-level scores: weighted fraction positive, or "mixed" when top and bottom quartiles disagree. Deduplication and warehouse rows Comment pipelines fail in the warehouse, not at the HTTP layer. Plan keys before your second cron run. | Problem | Fix | | --- | --- | | Same comment on re-fetch | Upsert on platform + comment.id | | Same text, different ids (rare) | Secondary hash on normalize(text) for analytics only | | Same post scored twice in one run | Dedupe URLs before the outer loop | | Stale sentiment in dashboards | Store capturedAt; re-pull on schedule, do not mutate old rows | | Audit trail | Persist meta.requestId and meta.creditsCharged per page | Suggested flat row for Postgres or BigQuery: When you merge comment sentiment back to a listening snapshot, join on postUrl or platform-native video id — not on title text, which collides across reposts. Troubleshooting not_found but the post opens in a browser Comments may be disabled on that post — lookup still resolves for many platforms; you get zero rows with found. Private, age-gated, or region-blocked media returns not_found at request time. Pass the canonical URL (full YouTube watch link, full Reddit /comments/ path). Tracker URLs and stripped share links fail more often. Empty comments array with lookupStatus: found Legitimate — new posts, brand accounts with comments off, or cleared threads. Still billed — the upstream lookup completed. Budget for empty pages in cron jobs. Pagination stops early or repeats Only pass cursor from the immediately previous response. If hasMore is true but nextCursor is null, stop and log requestId — that is an upstream anomaly worth a support ticket. Cap pages per post so a bug does not loop until your balance drains. YouTube top vs newest disagree Run two passes with different order values if sort skew matters for your decision. That is two credit lines per page, not one. Reddit nested replies missing from classifier input Top-level pagination does not always inline every nested reply on one page. Walk replies.items recursively or flatten as shown above. TikTok id looks like a placeholder Some comments use deterministic ids derived from available fields. Still stable within a pull — use them for dedupe keys in that run. lookup_failed or HTTP 503 Not charged. Retry with backoff; include meta.requestId from the failed attempt if you contact support. Classifier drift Re-score a frozen comment snapshot when you change models — do not compare June scores to March scores across model versions without a calibration pass. Billing notes Each page is its own metered lookup (typically one credit). meta.creditsCharged on every response tells you what that page cost. | Action | Credits (typ.) | | --- | --- | | 1 TikTok comment page | 1 | | 1 YouTube comment page | 1 | | 1 YouTube reply page | 1 | | 1 Instagram comment page | 1 | | 1 Reddit comment page | 1 | | 10 posts × 3 pages each | 30 | Completed lookups that return not_found (deleted video) still ran upstream and are billed. Infrastructure failures (lookup_failed, 503) are not. See Credits. Rough planning formula: (posts you care about) × (pages per post) + (YouTube reply pages you opt into). A launch monitor on 20 posts with a 3-page cap is about 60 credits per run. What you can build Launch monitoring — score comment sentiment hourly after a product drop; alert when negative fraction crosses a threshold. Creator vetting — flag toxic reply patterns and recurring spam before signing a partnership. Support triage — route negative threads to Slack when keyword rules fire on the newest page. Competitive dashboards — same classifier on your posts and competitor posts discovered via search. Research exports — flat CSV of Reddit thread comments with themes for PM decks. --- Next steps: Playground · API reference · Pricing
---
# Social Fetch vs DIY Scraping — Real Tradeoffs (2026)
Source: https://www.socialfetch.dev/guides/social-fetch-vs-diy-scraping
# Social Fetch vs DIY Scraping — Real Tradeoffs (2026)
When to run headless browsers vs call an API — maintenance, breakage, schema drift, and credit metering side by side.
**Read on the site:** https://www.socialfetch.dev/guides/social-fetch-vs-diy-scraping
"Just scrape it yourself" sounds free until you count proxies, fingerprint patching, and the Friday night a platform deploy breaks your parser. This guide compares DIY and Social Fetch side by side — no vendor dunking, just the tradeoffs that affect build vs buy. DIY wins for one-off research and learning. A data API wins when you need reliable JSON across platforms, on a schedule, without owning bot-detection maintenance. If you are evaluating a data API for the first time, start here. If you already run scrapers in production, skim to the true cost worksheet and sanity-check your spreadsheet. Try the API path first with 100 free credits — no card. Compare against your DIY estimate with Pricing. The real comparison Teams compare DIY and API on the wrong axis. They multiply requests by proxy cost and declare victory. That math ignores the hours between "it worked in staging" and "prod is red because Instagram renamed a field inside a script tag." | Factor | DIY (Playwright / Puppeteer) | Social Fetch API | | --- | --- | --- | | Upfront build | Days to first working scrape | Minutes to first curl | | Ongoing maintenance | You own every platform change | Maintained routes + stable schema | | Multi-platform | N separate scrapers, N proxy configs | One auth header, one envelope | | Metering | Infra + proxy bills + engineer time | Prepaid credits per lookup | | Rate limits | You throttle, rotate, and back off | No enforced cap on metered routes | | Failure modes | Silent partial HTML, CAPTCHA walls | Typed lookupStatus + requestId | | Legal surface | Your infra, your IP, your ToS exposure | Same use obligations; different ops owner | Price per thousand requests is the wrong sole metric. Ask: what does a reliable datapoint cost including maintenance? A reliable datapoint is one your downstream job can consume without a human opening DevTools. That bar is higher than "we got JSON once in a notebook." What DIY scraping actually costs A working social scraper is rarely a single script. The demo is fifty lines; production is a small platform team did not budget for. Around that core you still need: Residential or mobile proxies — datacenter IPs die fast on TikTok, Instagram, and X. Token refresh — TikTok msToken, Instagram csrftoken, Reddit OAuth if you use the official API. Behavioral pacing — scroll delays, warm-up navigations, session stickiness. Extraction logic — data often lives in __UNIVERSAL_DATA_FOR_REHYDRATION__ or equivalent blobs, not in stable DOM selectors. Observability — success rate by platform, proxy vendor, and region; without it you ship blind. Retry policy — distinguish "account gone" from "we got blocked" from "parser returned null." Platform walkthroughs with runnable GETs: TikTok, Instagram, and LinkedIn — each covers DIY, official APIs, and where those leave gaps. Hidden line items | Line item | Typical DIY reality | | --- | --- | | Headless browser fleet | 1–4 vCPUs per concurrent session; memory spikes on video-heavy pages | | Proxy vendor | Per-GB or per-GB+per-request; residential is 5–50× datacenter | | Engineer time | Initial build + reactive fixes when layouts change | | On-call | Someone gets paged when a cron job returns empty arrays | | Data warehouse cleanup | Schema drift breaks dashboards unless you version raw blobs | None of that shows up in a $0.001/request back-of-napkin calculation. Proxy math nobody puts in the slide deck Proxies are the bill that scales with success. The more profiles you fetch, the more bandwidth you burn — and social sites are heavy. Rough planning numbers (order of magnitude, varies by vendor and region): | Volume | DIY proxy spend (residential) | Notes | | --- | --- | --- | | 1,000 profile loads/month | $30–$120 | Assumes ~2–5 MB per session with warm-up | | 50,000 loads/month | $800–$3,500 | Retry traffic adds 15–40% | | 500,000 loads/month | Negotiate enterprise tier | You are now running a proxy ops program | Datacenter proxies look cheaper until your success rate drops to 60%. Then you pay twice: cheap bandwidth plus engineer time rewiring fingerprints. Social Fetch bundles fetch infrastructure into per-lookup credits. You trade variable proxy algebra for a number you can budget before a batch job runs. Whether that trade wins depends on volume and how much your team costs per hour — not on ideology. DOM breakage and hidden JSON blobs Social networks do not publish HTML for your convenience. They publish HTML for their React app. Your scraper is a side effect. Three breakage patterns show up constantly: 1. Selector drift — div[data-testid="user-followers"] becomes span[class^="Count"] after a redesign. CSS selectors break weekly on fast-moving surfaces. 2. Hydration blobs — TikTok, Instagram, and others embed JSON inside tags. Field names change without announcement. stats.followerCount becomes follower_count inside a nested object you were not parsing. 3. A/B buckets — Two users see different HTML for the same URL. Your scraper works in US-East and fails in EU-West until you notice the skew. DIY teams often respond by screenshotting the page and parsing harder. That works until the platform ships a client-side-only API path your headless browser never calls. A data API sits upstream of that churn. Your integration reads data.profile.handle and data.metrics.followers from the documented OpenAPI spec — not from whatever minified key TikTok used in Tuesday's deploy. Example response shape: When TikTok moves fields internally, the mapping problem is ours. Your TypeScript types against the public contract stay put. Rate limits you own vs limits you buy out of With DIY, every limit is yours to discover: | Platform | DIY friction | What breaks first | | --- | --- | --- | | TikTok | Aggressive bot scoring | Empty hydration blob after ~20 fast requests | | Instagram | Login walls for deep data | Session cookies expire mid-cron | | Reddit (official API) | OAuth + per-app quotas | Commercial use restrictions | | X / Twitter | Guest token rotation | 429 storms on search | | YouTube | Relatively open for public pages | CAPTCHA on datacenter IPs at scale | You implement token buckets, exponential backoff, and per-platform concurrency caps. Burst traffic — a customer clicks "refresh all influencers" — becomes an ops incident. Social Fetch metered routes do not enforce a per-minute cap. Your practical limit is credit balance and reasonable concurrency (~500 parallel requests is a courtesy ceiling, not a hard wall). Bursty teams — heavy windows, then quiet — fit that model without filing a rate-limit ticket. DIY still wins when you need weird pacing: crawl one profile every six hours from a single residential IP to stay under the radar for a sensitive internal audit. APIs optimize for throughput and consistency, not for "look like my laptop." Legal and ToS gray areas This section is not legal advice. It is the conversation engineering leads have before counsel returns their memo. Public data is not automatically free to use. Courts in some jurisdictions (hiQ v. LinkedIn is the usual US reference) have treated publicly visible web data differently from hacked or logged-in private data. That does not mean "scrape anything." Platform terms, CFAA arguments, GDPR/CCPA duties, and your customer contracts still apply. DIY does not reduce compliance work. You choose what to collect, how long to store it, and whether your use is commercial. Running the browser yourself means your IP addresses hit the platform directly. Logs, retention, and subprocessors are yours. A data API does not transfer liability. Social Fetch fetches public data you request; you remain responsible for lawful use under our Terms and your jurisdiction. What changes is operational: you are not maintaining a fleet of headless browsers on your cloud account, and you get a meta.requestId audit trail per lookup. Practical distinctions teams actually care about: | Question | DIY | API | | --- | --- | --- | | Who holds platform relationship risk? | You, directly | Shared; vendor maintains fetch layer | | Can I prove what was fetched when? | Only if you logged it | requestId on every response | | Official API available? | Sometimes simpler to use | Use it when it covers your use case | | Banned or private content | Your scraper must detect | lookupStatus: "not_found" / "private" | When an official API covers your use case — Reddit for a nonprofit research app, YouTube Data API for video metadata you already have rights to — use it. This guide is for the gap where browser parity matters and official routes do not. The maintenance treadmill The expensive part of DIY is not the first commit. It is the seventh emergency fix in a quarter. Typical timeline for a team that ships a multi-platform scraper: | Week | What happens | | --- | --- | | 1–2 | Proof of concept works on three handles | | 3–4 | Cron job, Postgres table, dashboard | | 6 | Instagram deploy; follower count returns null | | 8 | Proxy vendor subnet flagged; success rate 40% | | 10 | Hire contractor to "just fix TikTok" | | 12 | Two platforms stable; third deferred | | 16 | Product asks for LinkedIn company pages — new scraper, new proxy rules | Each fix is small. The compound cost is context switching. Your senior backend engineer becomes a part-time anti-bot researcher. Social Fetch exists because that treadmill is a product, not a side quest. When a route breaks, support traces meta.requestId and the team behind the API ships a fix. You keep building features that differentiate your product. Exception: if your DIY scraper only touches one slow-changing surface — say, a government filings site — maintenance may be negligible. Social networks are the opposite of slow-changing. Envelope consistency The best reason to buy an API is not "we hate Playwright." It is contract stability. Every Social Fetch route returns the same top-level shape: Your code checks result.ok (SDK) or HTTP status, then branches on data.lookupStatus. found, private, and not_found arrive with HTTP 200 — intentional, so you handle outcomes in business logic instead of treating "missing influencer" as a transport error. Multi-platform jobs become boring in a good way: The same loop works for Instagram, YouTube, Reddit, and the rest of the catalog. You do not maintain three parser modules with three error conventions. DIY across platforms means three JSON shapes you invented, three retry policies, and three alert channels. Envelope consistency is the glue code you do not write. Where DIY still wins We sell an API. DIY is still the right call sometimes. One-off research — a weekend pull for a slide deck or investor memo. Spin up Playwright, export CSV, delete the VM. Learning — you want to see how a platform loads data. Reading network tabs teaches more than reading docs. Hyper-custom extraction — fields no API exposes, and you can legally collect them. Niche DOM corners, internal tools, experimental signals. Air-gapped or policy constraints — some enterprises forbid third-party data vendors regardless of cost. DIY on their network may be the only approved path. Ultra-low volume forever — twelve lookups a year does not justify any vendor relationship. If the job runs once and never again, DIY friction is acceptable. If the job runs every Monday for paying customers, factor maintenance into the ticket price. What a data API buys you One GET returns normalized JSON: Paginate videos, pull comments, fetch transcripts — same auth header, same error semantics. See cross-platform creator profiles for a full enrichment pipeline. Operational promises that matter for production: 1. Try before you pay — 100 free credits, no card. 2. Never charged for our mistakes — bad requests caught pre-send; lookup_failed and 503 free. 3. No surprise bills — prepaid refill packs, no metered overage invoices. 4. Fresh data — no cache layer returning an hour-old snapshot. 5. Support from builders — questions go to the team behind the routes, with requestId for tracing. What we do not promise: every public URL on earth, every private field behind login, or immunity from platform policy changes. Check route coverage in the API reference before you design around an endpoint. Mixing DIY and API Hybrid setups are normal, not a compromise. | Layer | DIY | API | | --- | --- | --- | | Internal research notebook | ✓ | | | Customer-facing enrichment | | ✓ | | Platform A (stable, official API) | ✓ | | | Platform B (hostile bot detection) | | ✓ | | Fallback when API returns lookup_failed | ✓ (careful) | | A common pattern: engineers prototype queries with DIY scripts, prove product value, then move scheduled jobs to an API before the first customer SLA. Another pattern: DIY for a proprietary internal data source, API for TikTok + Instagram + YouTube in the same report. The mistake is hybrid without boundaries — two code paths writing the same table with incompatible schemas. Pick one canonical JSON shape in your warehouse; map DIY output into it or stop DIY when the API path ships. True cost worksheet Copy this into a spreadsheet. Fill in your numbers. Compare 12-month TCO, not first-week excitement. | Cost driver | DIY (your estimate) | Social Fetch | | --- | --- | --- | | Initial build (eng days × day rate) | | ~0 (integration hours only) | | Proxy + compute (monthly) | | | | Maintenance (hours/month × rate) | | | | Incidents (PagerDuty weekends) | | | | Lookup volume (monthly) | | × credits per Pricing | | 12-month total | | | Example: 20,000 profile lookups/month across three platforms. DIY: $1,200/mo proxies + 8 eng-hours/mo maintenance at $150/hr ≈ $2,400/mo → ~$28,800/yr API: 20,000 credits/mo at prepaid rates (check current pricing) → often $2,000–$6,000/yr before eng time drops to near zero Your mileage varies. A solo founder with free time skews DIY. A team with a shipped product skews API. How billing works We do not say "only pay for data you get." That slogan hides edge cases. | Outcome | Charged? | | --- | --- | | Pre-send validation error (bad handle format) | No | | lookup_failed / HTTP 503 | No | | HTTP 200 + lookupStatus: "not_found" | Yes — upstream ran | | HTTP 200 + empty search results | Yes — lookup completed | | HTTP 200 + lookupStatus: "found" | Yes | A completed lookup that resolves to not_found still ran upstream work and is charged. Infrastructure failures and invalid requests caught before they run are not charged. Read the full matrix in Credits. DIY billing is the same logic with worse labels: you still paid for the proxy session when the page loaded a CAPTCHA instead of a profile. The difference is whether that cost appears on a vendor invoice or your AWS bill. Decision checklist Choose DIY when: [ ] Single platform, single pull, no SLA [ ] You have spare engineering time for breakage [ ] Data shape is unique and not available via API [ ] Policy forbids third-party fetch vendors [ ] Volume is low enough that proxy + eng cost stays under API credits Choose Social Fetch when: [ ] Customer-facing or scheduled jobs [ ] Multiple platforms with one codebase [ ] You want stable JSON and prepaid metering [ ] You would rather ship product than babysit proxies [ ] You need requestId traceability for support and audits Still stuck? Run both for a week. Log success rate, p95 latency, and eng interruptions. The winner is usually obvious by Friday. --- Next steps: Playground · TikTok DIY vs API guide · Instagram scrape guide · LinkedIn scrape guide · Pricing
---
# Social Fetch with Cursor & Claude (MCP, 2026)
Source: https://www.socialfetch.dev/guides/social-fetch-with-cursor-claude
# Social Fetch with Cursor & Claude (MCP, 2026)
Connect Cursor, VS Code, or Claude to Social Fetch via MCP — OAuth tools, llms.txt for agents, and the same credit billing as REST.
**Read on the site:** https://www.socialfetch.dev/guides/social-fetch-with-cursor-claude
Coding agents ship faster when they can call live APIs as tools and read your docs without you pasting OpenAPI fragments into chat. Social Fetch provides a hosted MCP server with OAuth, plus /llms.txt and /llms.json written for agent orientation. This guide walks through setup in Cursor and Claude, example prompts that work, how to prototype with nl_ask_post (the MCP wrapper for POST /v1/ask), and how to teach your agent loop to handle Social Fetch errors without burning credits on retries. Add https://api.socialfetch.dev/mcp to Cursor or Claude, complete OAuth in the browser, and tell the agent to read llms.txt before writing integration code. Use nl_ask_post to explore; pin typed tools once you know the route. Endpoint tools bill like REST; docs tools are free. Optional: install the Agent Skills pack so the harness loads Social Fetch onboarding without pasting a prompt every time. You'll need a Social Fetch account, credits for metered routes (Pricing), and an MCP client that supports remote Streamable HTTP with OAuth — Cursor, VS Code, Claude Code, or Claude Desktop. Product overview: MCP. Reference docs: MCP integration. Who this is for Developers using Cursor or Claude to scaffold social-data features while coding. Teams building agent workflows that need live TikTok, YouTube, Reddit, or Instagram JSON — not HTML to parse. Anyone who wants the agent to pick the right endpoint instead of guessing field names from training data. If you are wiring a custom orchestrator (LangChain, Vercel AI SDK, your own runtime), the function-calling and error-handling sections apply even without MCP — register REST routes as tools and use the same response envelope. MCP vs REST vs llms.txt | Surface | Purpose | Auth | Credits | | --- | --- | --- | --- | | REST / SDK | Production integrations | x-api-key | Per endpoint | | MCP tools | Agent-driven lookups while building | OAuth | Same as REST for endpoint tools | | llms.txt | Orientation — what to read, in what order | None (public) | Free | | llms.json | Full structured operation inventory | None (public) | Free | The MCP server exposes 154 endpoint tools (one per public API route) plus docs_search and docs_read. Tool names mirror OpenAPI operation IDs with dots replaced by underscores — tiktok.profile.get becomes tiktok_profile_get, reddit.search.get becomes reddit_search_get. | MCP tool | REST equivalent | Notes | | --- | --- | --- | | tiktok_profile_get | GET /v1/tiktok/profiles/ | 1 credit on completed lookup | | nl_ask_post | POST /v1/ask | 0 credits to route; nested lookup bills normally | | billing_balance_get | GET /v1/balance | Free — check before large batches | | docs_search | — | Free — search live docs | | auth_whoami | GET /v1/whoami | Free — confirm OAuth session | MCP is for building. Production traffic should use @socialfetch/sdk or fetch with an API key — same JSON shapes, different auth surface. Phase 1: Connect MCP in Cursor Step 1 — Add the server config Create or edit ~/.cursor/mcp.json for global access, or .cursor/mcp.json in a project repo so teammates share the same config: No API key goes in this file. The URL is the entire config for remote HTTP MCP. Step 2 — Restart and open MCP settings Restart Cursor (or reload the window). Open Settings → MCP and confirm socialfetch appears. Status should show "needs authentication" until you complete OAuth. One-click install links for Cursor, VS Code, and others: MCP docs. Step 3 — Complete OAuth Click Connect or trigger a tool call. Cursor opens your browser to the Social Fetch sign-in page: 1. Sign in or create an account. 2. Approve MCP access for your client. 3. Return to Cursor — the server status should flip to connected. Credits charge to the account you signed in with, same as REST. Step 4 — Verify tools load In Agent chat, ask: You should see endpoint tools (tiktok_profile_get, reddit_search_get, …) plus docs_search, docs_read, nl_ask_post, and billing_balance_get. If the list is empty, see Troubleshooting. Step 5 — Optional project rules Add a Cursor rule (.cursor/rules/social-fetch.mdc or project instructions) so every session starts oriented: Phase 2: Connect MCP in Claude Claude Code (terminal agent) Then inside a Claude Code session: Select Social Fetch and complete the browser OAuth flow. Test with: Claude Desktop 1. Open Settings → Connectors (or Developer → Edit Config depending on version). 2. Add a custom remote MCP connector. 3. Set URL to https://api.socialfetch.dev/mcp. 4. Save, restart Claude Desktop if prompted. 5. Authorize when Claude first calls a Social Fetch tool. In a new conversation, enable the Social Fetch connector in the tools panel before sending prompts that need live data. stdio-only clients Some older MCP clients only speak stdio. Bridge to the hosted server: Point your client at the stdio process mcp-remote spawns. OAuth still runs through the browser when the bridge connects. VS Code Add to settings.json: Restart VS Code and complete OAuth when Copilot or your MCP extension prompts you. OAuth — what actually happens Social Fetch MCP uses OAuth 2.1. Your client never stores an API key in config. | Step | What happens | | --- | --- | | 1 | Client discovers the MCP server at https://api.socialfetch.dev/mcp | | 2 | Client redirects you to Social Fetch sign-in in the browser | | 3 | You approve access; client receives a short-lived access token | | 4 | Every tool call sends Authorization: Bearer | | 5 | Metered lookups debit credits on your signed-in account | Token expiry: if every call returns 401, reconnect — open MCP settings and re-authenticate. Do not paste a dashboard API key into mcp.json; that is for REST/SDK only. Team note: OAuth ties to a personal account. For CI or server-side agents, use x-api-key with REST function calling instead of MCP. Point agents at llms.txt llms.txt is a ~100-line orientation file: platform coverage, recommended reading order, workflow hints, and links to Quickstart, Credits, and Errors. llms.json lists every operation with method, path, and operation ID — useful when you are registering dozens of function schemas. To load the same guidance as an installable skill (instead of pasting a prompt each session): See Agent Skills. Paste this into your first message or system prompt: The MCP server also returns workflow instructions in its initialize handshake (docs first, check lookupStatus, call billing_balance_get before batches). Your agent sees this automatically when connected — but llms.txt in Cursor rules catches sessions before the first MCP call. Example agent prompts These prompts work in Cursor Agent or Claude with the connector enabled. They assume Social Fetch MCP is connected. Scaffold a feature with live JSON Multi-platform creator check Reddit research while coding See the Reddit product research guide for a full research sprint. Docs-driven SDK integration Pre-flight credit check Explore with nl_ask_post When you do not know which typed tool to call, use nl_ask_post — the MCP mirror of POST /v1/ask. Routing costs 0 credits; only the nested lookup bills. MCP call: REST equivalent: TypeScript SDK: Example response shape: Pin the typed tool after exploration. Once routedOperation tells you tiktok.profile.get, switch to tiktok_profile_get for repeat calls. Typed tools are faster, more deterministic, and easier to budget. | Use nl_ask_post | Use typed tools | | --- | --- | | First time exploring a question | Production agent loops | | User speaks in plain English | You know platform + resource | | Prototyping in chat | Cron jobs, CI, server runtimes | | Discovering routedOperation | Paginated search with cursors | nl_ask_post is one-shot routing, not a chat endpoint. For Q&A about a single public URL's content, use web_ask_get (GET /v1/web/ask) instead. Try routing in the Playground or the free Ask tool before wiring it into an agent. Function calling patterns Whether you use MCP or register REST routes in a custom runtime, these patterns keep agent loops predictable. One tool per route Register tiktok_profile_get, reddit_search_get, and youtube_videos_transcript_get as separate functions. Do not build one mega-tool with a free-text platform field — models pick wrong values and you lose schema validation. Map OpenAPI operation IDs to tool names the same way MCP does: dots to underscores. Schema from OpenAPI, not prose Generate JSON Schema from the OpenAPI spec or copy parameter definitions from llms.json. Required fields (handle, url, query) should be in the schema's required array so the runtime rejects bad calls before they hit the API (pre-send validation is free). Explore, then pin Free guardrail tools | Tool | When to call | | --- | --- | | docs_search | Before choosing an endpoint | | docs_read | For full parameter docs on one page | | billing_balance_get | Before parallel batches | | auth_whoami | Confirm OAuth session in a new chat | Parallel fan-out Agents often fire ten profile lookups at once. That is fine if you have ten credits — there are no request quotas on paid metered routes; credits are the only limit. Under extreme concurrency you may get 503 with Retry-After (not charged). Stay under ~500 concurrent requests for reliability. Sequential pagination with modest concurrency is cheaper and easier to debug. Pagination in tool loops Search and list tools return data.page.nextCursor and data.page.hasMore. Teach the agent: Error handling in agent loops Most agent failures around social data are integration mistakes, not model mistakes. Encode these rules in your system prompt or orchestrator. HTTP 200 is not always "found" Profile and post routes return data.lookupStatus on HTTP 200: | lookupStatus | Meaning | Retry? | Charged? | | --- | --- | --- | --- | | found | Data returned | — | Yes | | not_found | Target does not exist | No | Yes | | private | Account exists but is private | No | Yes | | restricted | Post not publicly scrapable (Instagram) | No | Yes | | hidden | List hidden (e.g. TikTok followers) | No | Yes | Transport and billing errors | HTTP | error.code | Agent action | Charged? | | --- | --- | --- | --- | | 400 | bad_request | Fix parameters; do not retry same payload | No | | 401 | unauthorized | Reconnect OAuth or check API key | No | | 402 | insufficient_credits | Stop loop; surface to user | No | | 502 | lookup_failed | Retry with backoff (up to 3×) | No | | 503 | temporarily_unavailable | Retry with backoff | No | Always log meta.requestId (or error.requestId) — support can trace the exact lookup. MCP-specific: read meta at the top level MCP tool results put meta beside data, not nested under structuredContent. After each call, parse meta.creditsCharged and meta.requestId from the tool JSON your client returns. Stop conditions for loops Add explicit guardrails: 1. 402 — halt immediately; do not retry. 2. not_found — record and continue to next item; do not retry the same handle. 3. Same requestId twice — orchestrator bug; halt. 4. Credit budget — call billing_balance_get first; stop when creditsCharged cumulative exceeds your limit. End-to-end workflow A typical session building a creator dashboard: 1. Orient — agent reads llms.txt and runs docs_search for "tiktok profile" + "youtube channel". 2. Explore — nl_ask_post with "YouTube subscribers for @mrbeast" → learns youtube.channel.get. 3. Prototype — parallel MCP calls: tiktok_profile_get, youtube_channel_get, instagram_profile_get with handle mrbeast. Agent inspects real JSON. 4. Implement — you merge SDK code the agent scaffolds: 5. Validate — run the same handles in the Playground and compare requestId if numbers disagree. 6. Ship — production uses API key; MCP stays in dev. Move from MCP to production SDK | Concern | MCP (dev) | SDK (prod) | | --- | --- | --- | | Auth | OAuth browser flow | x-api-key env var | | Where it runs | Cursor, Claude Desktop | Your server, CI, cron | | Tool discovery | Automatic | You import typed methods | | Billing account | Developer who OAuth'd | API key owner | Copy field paths verbatim from MCP responses into your types. data.profile.metrics.followers in MCP is the same path in SDK result.value.data. Do not deploy MCP inside a server runtime — use REST. For no-code workflows with API keys, see n8n integration. Billing and credits Endpoint tools (MCP or REST): billed per completed lookup — see Credits. nl_ask_post routing: 0 credits; meta.creditsCharged reflects the nested lookup only. not_found / private on HTTP 200: still charged — the lookup completed. Pre-send validation errors, lookup_failed, 503: not charged. docs_search, docs_read, auth_whoami, billing_balance_get: no lookup credits. 100 free credits on signup — Pricing. Agent loop math: 5 creators × 3 platforms = 15 credits if every lookup completes. Add pagination credits per page. Call billing_balance_get before fan-out. Troubleshooting 401 on every MCP call Token expired or OAuth incomplete. Open MCP settings → reconnect → finish browser sign-in. OAuth redirect loop Complete sign-in at app.socialfetch.dev, then click Approve to return to your client. Disable aggressive popup blockers for the OAuth window. 402 insufficient_credits Top up in Credits & billing. Teach the agent to stop on 402 instead of retrying. Empty tool list after connect Restart the client. Check mcp.json URL is exactly https://api.socialfetch.dev/mcp (no trailing path). Agent keeps retrying not_found Add a rule: "lookupStatus: not_found is a valid outcome — never retry." See Errors. Wrong platform routed from nl_ask_post Be specific: "TikTok followers for @handle" not "followers for handle". Pin the typed tool once you know the route. MCP works but SDK returns different numbers Point-in-time snapshots differ. Compare requestId in Playground vs your logs. stdio client cannot connect Use npx mcp-remote https://api.socialfetch.dev/mcp as a bridge. FAQ Do MCP tool calls cost credits? Yes for endpoint tools, same as REST. docs_search, docs_read, auth_whoami, and billing_balance_get are free. Do I paste an API key into MCP config? No — OAuth for MCP; API keys for REST/SDK from API keys. What should my agent read first? llms.txt, then Quickstart and endpoint reference pages. Use MCP docs tools for parameters. When should I use nl_ask_post instead of a typed tool? When you do not know the route yet. After you have routedOperation, switch to the explicit tool. Why did my agent retry not_found five times? not_found is HTTP 200 with a completed lookup. Add explicit stop conditions in your prompt or orchestrator. Can I use MCP in production? No — MCP targets dev agents. Ship with the SDK or REST and an API key. --- Next steps: MCP · MCP integration · AI agents use case · llms.txt · Playground · Pricing
---
# Build a social listening dashboard (2026)
Source: https://www.socialfetch.dev/guides/social-listening-dashboard
# Build a social listening dashboard (2026)
Watch lists, cron polling, dedupe, spike detection, and Slack alerts — snapshot brand mentions across TikTok, X, YouTube, and Reddit with one JSON schema.
**Read on the site:** https://www.socialfetch.dev/guides/social-listening-dashboard
Networks do not push a webhook when someone misspells your product on TikTok. Social listening is a scheduling problem: you define watch lists, poll search endpoints on a cron, store snapshots, dedupe by post ID, diff against yesterday, and only then chart volume or page someone. This guide walks through that pipeline end to end — watch lists through Slack alerts — using a fictional brand Acme as the running example. Define watch terms, GET each platform's /search route on a schedule, upsert rows keyed by platform + postId, compare today's net-new count to a baseline, and alert on spikes. One API key, one envelope. Swap in your keywords, cadence, warehouse, and alert channels. You'll need an API key, a job runner (cron, QStash, Temporal, GitHub Actions), and a database (Postgres is used in the examples below). Prototype searches in the Playground. Why listening is a pull problem Brand monitoring tools often sell "real-time" dashboards. In practice, most teams: 1. Run keyword searches on a timer — there is no firehose subscription for public TikTok or X posts. 2. Store point-in-time JSON — metrics on a post change; your warehouse records what you saw at poll time. 3. Alert on diffs — a spike is "40% more net-new mentions than the seven-day median," not "search returned 47 items." Social Fetch handles step 1 with normalized search routes. Steps 2–4 live in your stack. The same envelope (data + meta.requestId + meta.creditsCharged) means one ingestion function with a platform column instead of four scraper codepaths. Architecture at a glance | Layer | You own | Social Fetch provides | | --- | --- | --- | | Watch lists | Brand, competitor, crisis query strings grouped by cadence | — | | Collection | Cron schedule, concurrency, retry on 503 | /v1/ /search routes | | Storage | mentions, poll_runs tables with capturedAt | meta.requestId for support traces | | Dedupe | Upsert on platform + postId | Stable post IDs in JSON | | Spike detection | Baseline median, multiplier threshold | — | | Alerting | Slack webhook, PagerDuty, email | — | | Dashboard | Metabase, Grafana, Looker, Sheets | — | Filter noise before you store: language=en on X, datePosted=this-week on TikTok, minLikes to drop drive-by mentions. Post-filter in SQL on author handle blocklists if needed. Step 1: Define watch lists Write watch terms before writing cron code. A typical B2C brand might run three groups: | Group | Example queries | Cadence | Platforms | | --- | --- | --- | --- | | Brand | acme, "acme app", #acme | Hourly | TikTok, X, YouTube, Reddit | | Competitor | rivalco, "switched from rivalco" | Daily | Reddit, X | | Crisis | acme scam, acme lawsuit, acme down | Every 5–15 min | X (section=latest) | Query tactics that reduce false positives: Quote exact phrases on X — "acme widget" avoids matching unrelated "acme" (the generic word). OR crisis variants — "acme" OR acmeapp OR @acmeofficial catches handle mentions and text. Hashtag vs keyword — campaign tracking often uses /search/hashtags on TikTok and YouTube; brand misspellings need keyword search. Date windows — TikTok datePosted, X startDate/endDate, Reddit timeframe keep polls bounded so you are not re-billing the same historical page every hour. Store watch lists in your database, not hard-coded in the worker: Set spike multipliers per group in config — crisis terms might alert at 2× baseline; brand terms at 4× to avoid noise. Maintain a blocklist table for owned accounts (@acmeofficial, your CEO's handle) and noisy domains so brand polls do not inflate mention counts with your own marketing posts. Apply the blocklist in SQL after upsert, not in the API query — you still want audit rows in poll_runs even when every hit is filtered out client-side. Step 2: Poll each platform Each platform exposes GET /v1/ /search (plus hashtag variants). Responses share data.lookupStatus, cursor pagination via data.page.nextCursor, and meta.requestId. Map the items array to a common mention shape in your worker. TikTok keyword search Parameters worth tuning for listening: | Parameter | Values | Listening use | | --- | --- | --- | | sortBy | relevance, date | date for "what posted today" widgets | | datePosted | today, this-week, this-month | Narrow polls so hourly cron does not replay old viral hits | | cursor | from data.page.nextCursor | Paginate until hasMore is false or credit budget stops you | Reference: TikTok search. Hashtag campaigns: TikTok hashtag search. X (Twitter) search | Parameter | Values | Listening use | | --- | --- | --- | | section | top, latest, people, photos, videos | latest for crisis watches; top for weekly recap dashboards | | language | ISO code, e.g. en | Drop non-target-locale noise before warehouse insert | | minLikes, minRetweets | integers | Suppress low-engagement hits in brand dashboards | | startDate, endDate | YYYY-MM-DD | Bound incident windows | Reference: Twitter search — 2 credits per successful request (most other platform search routes are 1). YouTube and Reddit YouTube keyword search mirrors TikTok — query, sortBy, uploadDate, cursor pagination: Reference: YouTube search. Campaign hashtags: YouTube hashtag search. Reddit catches early honest signal — complaints in niche subreddits often appear before a story trends on X. Use global GET /v1/reddit/search for brand strings; see the Reddit research guide for subreddit-scoped passes and comment pulls. Instagram, Threads, LinkedIn, and Web search follow the same pattern under /v1/ /search in the API reference. For Instagram brand monitoring, combine keyword search with profile lookups when you know the official handle — search catches UGC and misspellings; profile routes give follower counts for context on reach. Threads search works for text-first brand mentions where TikTok video search would miss the conversation entirely. Step 3: Schedule with cron or QStash There is no platform push stream — your worker GETs on a schedule. Common patterns: | Runner | When to use | | --- | --- | | Vercel cron / system cron | Single-region worker, simple hourly brand poll | | QStash | Retries, delayed jobs, fan-out one message per watch term | | Temporal / Inngest | Long-running workflows with per-platform retry policies | Budget credits before enabling 5-minute crisis polls: platforms × keywords × polls_per_day × credits_per_call. Example: 4 platforms × 3 brand terms × 24 hourly polls × ~1.5 avg credits ≈ 432 credits/day (X at 2 credits pulls the average up). Wrap each poll with capturedAt and persist meta.requestId: Retry lookup_failed and HTTP 503 with exponential backoff — those responses are not charged. Do not retry validation errors. QStash fits bursty listening well — publish one message per watch term so a slow Reddit page does not block your X crisis poll: Your HTTP handler loads the watch term, runs the platform-specific search, upserts mentions, and returns 200 so QStash does not retry a successful poll. Step 4: Storage schema Split poll runs (audit log) from mentions (deduped facts). Append-only snapshot blob (optional) for replay debugging: Chart COUNT() FILTER (WHERE first_seen_at::date = ...) grouped by platform for "new mentions per day." Use last_seen_at to show posts still appearing in search results. Dashboard queries your BI tool can run directly on mentions: Pipe text_snippet from high-engagement rows into an LLM summary for weekly exec digests — always attach url and requestId as citations. Step 5: Dedupe mentions The same post surfaces under multiple queries ("acme" and "acme app"). Dedupe on platform + postId before counting. Field mapping per platform: | Platform | Post ID source | Text source | | --- | --- | --- | | TikTok | video.id | video.description | | X | tweet.id | tweet.text | | YouTube | video.id | video.title | | Reddit | post.id | post.title | Cross-posts (same text, different IDs) are rare in listening workloads. If you need one row per discussion, normalize on canonical url instead. Re-running the same cursor chain twice bills twice — treat cursors as single-use pagination tokens within one poll run. Step 6: Spike detection Do not alert on raw items.length from a single API response. Platform ranking changes move that number without a real story. Better signal: net-new mentions per watch term per rolling window. Baseline: seven-day median of hourly net-new counts, excluding the current hour: Fire when new_last_hour > median_hourly spike_multiplier (e.g. 3× for brand, 2× for crisis). Optionally add a floor — AND new_last_hour >= 10 — so a jump from 1 to 4 does not page anyone. Velocity alerts: for X crisis watches, flag individual posts where like_count or retweet_count jumped more than 50% since last_seen_at on the previous poll. That catches a single viral complaint before hourly aggregates move. Step 7: Route alerts Send net-new high-signal items, not the full poll payload. Include requestId in internal alert metadata so support can trace the exact lookup if a URL looks wrong. After spikes, pull comment threads on the top post for sentiment — see the sentiment guide. Captions alone miss most brand damage in replies. Full multi-platform job Extend the preset: loop watch terms from your DB, map each platform to the right SDK method, upsert mentions, record poll_runs, then run spike SQL. Pseudocode for the outer loop: Run platforms in parallel with Promise.all per term group if credit balance allows — stay under ~500 concurrent requests. Troubleshooting Chart shows a spike but nothing looks new You counted total poll results instead of net-new first_seen_at rows. Fix the SQL before tuning alert thresholds. TikTok datePosted rolled forward at midnight UTC and resurfaced a different result set. Store query + filter params on poll_runs for comparison. Duplicate rows in the dashboard Same post matched two queries. Expected — dedupe in charts with COUNT(DISTINCT post_id) or attribute mentions to a primary watch term. Alert fatigue on launch day Raise spike_multiplier temporarily or switch brand terms to daily cadence while crisis terms stay at 5 minutes. Add minLikes on X and minRetweets for non-crisis groups. Empty results but the post exists in a browser Search indexes lag behind profile URLs. Try a direct post lookup route if you have the URL. Query too broad or too narrow — test variants in the Playground before adding to cron. lookup_failed or HTTP 503 Not charged. Retry with backoff; log meta.requestId from the failed attempt. Credits burned faster than expected Pagination loops billing per page. For hourly brand polls, often one page per term is enough — stop when hasMore is false or you have 50 items. X costs 2 credits per search call; factor that into multi-platform budgets. Storing full raw JSON blobs in S3 is cheap; re-fetching the same paginated cursor chain because you lost poll_runs metadata is not. Credits and scheduling Prepaid credits — prepaid refill packs, no metered overage invoices; balance is the guardrail. No expiry — run listening windows 1–3 times per month without wasting a subscription cycle. Billing — completed searches that return empty arrays are still charged; lookup_failed and 503 are not. See Credits. Rough daily math for planning: | Setup | Calls/day | Credits (approx.) | | --- | --- | --- | | 3 terms × 4 platforms × hourly (X=2, others=1) | 288 | ~360 | | 5 crisis terms × X every 15 min | 480 | 960 | | Weekly recap: 10 terms × 2 pages Reddit | 20 (once) | 20 | Public data only — you remain responsible for lawful use under Terms. What you can build Brand pulse dashboard — multi-platform net-new mention volume with week-over-week deltas in Metabase or Grafana. Crisis monitor — Slack alert when X latest search net-new count exceeds 3× the seven-day median. Campaign wrap-up — hashtag search across TikTok and YouTube in one export, deduped by post ID. Competitor share-of-voice — same watch-list machinery with competitor query group; chart relative first_seen_at counts. Sentiment handoff — comment pulls on posts that breached velocity thresholds, fed to your classifier. --- Next steps: Playground · API reference · Social media monitoring use case · Pricing
---
# Social Fetch comparisons
Source: https://www.socialfetch.dev/compare
# Social Fetch comparisons
Side-by-side comparisons of Social Fetch vs alternative social data APIs and scrapers.
**Compare hub:** https://www.socialfetch.dev/compare
## Available comparisons
- [Apify](https://www.socialfetch.dev/compare/apify) — Actor marketplace and scraper runtime vs a synchronous social REST API with flat per-request pricing.
- [Ayrshare](https://www.socialfetch.dev/compare/ayrshare) — Social posting and profile-management API vs read-only public social data lookups.
- [Brandwatch](https://www.socialfetch.dev/compare/brandwatch) — Enterprise social listening and CI suite vs a self-serve social REST API for product engineering.
- [Bright Data](https://www.socialfetch.dev/compare/bright-data) — Proxy networks and dataset pipelines with spending limits vs a social-native REST API you can call from production code today.
- [Crawlbase](https://www.socialfetch.dev/compare/crawlbase) — Complexity-priced crawling API and LinkedIn crawls vs social-native REST with flat per-lookup credits.
- [Data365](https://www.socialfetch.dev/compare/data365) — Sales-led social API with per-network monthly plans from €300 vs self-serve multi-platform credits.
- [EnsembleData](https://www.socialfetch.dev/compare/ensembledata) — Direct social REST API with daily unit subscriptions vs prepaid credits, broader platforms, and a normalized response envelope.
- [Exa](https://www.socialfetch.dev/compare/exa) — Neural web search and contents API vs structured social REST lookups for known handles and posts.
- [Firecrawl](https://www.socialfetch.dev/compare/firecrawl) — LLM-ready web scrape/crawl vs a social-native REST API for profiles, posts, and metrics.
- [Meltwater](https://www.socialfetch.dev/compare/meltwater) — Media intelligence and listening suite with custom ACV vs prepaid social REST credits for developers.
- [Modash](https://www.socialfetch.dev/compare/modash) — Enterprise Discovery + Raw influencer APIs (IG/TikTok/YouTube, annual) vs self-serve multi-platform public social REST.
- [Outstand](https://www.socialfetch.dev/compare/outstand) — Unified posting/scheduling API with connected accounts vs public social read API with prepaid credits.
- [Oxylabs](https://www.socialfetch.dev/compare/oxylabs) — Enterprise proxy and Web Scraper API with monthly plans vs a social-native REST API at flat per-lookup pricing.
- [PhantomBuster](https://www.socialfetch.dev/compare/phantombuster) — No-code social automation and Phantoms vs a synchronous social REST API for product engineering.
- [Phyllo](https://www.socialfetch.dev/compare/phyllo) — Creator OAuth and consented private metrics vs a self-serve public social REST API with published pack pricing.
- [Proxycurl](https://www.socialfetch.dev/compare/proxycurl) — Shutdown (July 2025) LinkedIn enrichment API → Enrich Layer path vs live multi-platform Social Fetch.
- [RapidAPI](https://www.socialfetch.dev/compare/rapidapi) — Marketplace of third-party scrapers with a different publisher per platform vs one first-party API, shared envelope, and traceable support.
- [Scrape.do](https://www.socialfetch.dev/compare/scrape-do) — Success-based scraping API with monthly credit plans vs social-native REST lookups at flat per-request pricing.
- [ScrapeCreators](https://www.socialfetch.dev/compare/scrapecreators) — Closest-lane peer: PAYG social scraping API with non-expiring credits vs Social Fetch's Scale rate, envelope, and SDK.
- [ScraperAPI](https://www.socialfetch.dev/compare/scraperapi) — Proxy HTML scraping with domain credit multipliers vs structured social REST endpoints.
- [Scrapfly](https://www.socialfetch.dev/compare/scrapfly) — Credit-based web scraping API with anti-bot and browsers vs social-native REST lookups at flat per-request pricing.
- [ScrapingBee](https://www.socialfetch.dev/compare/scrapingbee) — Headless scraping API with monthly credit plans vs a social-native REST API with flat per-lookup credits.
- [ScrapingDog](https://www.socialfetch.dev/compare/scrapingdog) — Monthly scrape + SERP credit plans vs social-native REST with flat per-lookup PAYG credits.
- [SerpApi](https://www.socialfetch.dev/compare/serpapi) — Multi-engine SERP API with monthly search quotas vs social-native REST for profiles, posts, and comments.
- [SociaVault](https://www.socialfetch.dev/compare/sociavault) — Closest peer: PAYG social REST API with non-expiring credits vs Social Fetch's lower Scale rate, envelope, and SDK.
- [Tavily](https://www.socialfetch.dev/compare/tavily) — AI web search for agents vs structured social profile/post lookups on a REST API.
- [Xpoz](https://www.socialfetch.dev/compare/xpoz) — MCP-oriented social query API on four networks vs multi-platform REST social data with flat per-lookup packs.
- [ZenRows](https://www.socialfetch.dev/compare/zenrows) — Monthly Universal Scraper API with JS/proxy multipliers vs social-native REST lookups at flat per-request credits.
For marketplace-style access, see also the [RapidAPI comparison](/compare/rapidapi) and Social Fetch on **RapidAPI Hub** (subscribe via RapidAPI, same API surface as socialfetch.dev).
---
# Apify vs Social Fetch — Sync REST API, Not Actors
Source: https://www.socialfetch.dev/compare/apify
# Social Fetch vs Apify
Apify runs containerized Actors on a schedule and stores results in datasets you download later. Social Fetch is a REST API that returns profile JSON in the same HTTP response. Same underlying problem — getting TikTok or Instagram data — but a completely different integration shape. This page is about which shape fits your product.
**Full comparison page:** https://www.socialfetch.dev/compare/apify
## At a glance
- **What you integrate against** — Social Fetch: REST endpoints (`GET /v1/tiktok/profiles/{handle}`); Apify: Actor runs + dataset exports (Clockworks, community Actors, your own)
- **Response timing** — Social Fetch: JSON in 2–4 seconds, same request; Apify: Start run → wait → poll status → fetch dataset (10s–minutes)
- **TikTok profile pricing** — Social Fetch: $1.65 per 1,000 requests; Apify: From $3.70 per 1,000 results (Clockworks; varies by Actor)
- **Multi-platform setup** — Social Fetch: One API key, one schema, shared credit balance; Apify: Separate Actor per platform, each with its own input schema
- **Billing model** — Social Fetch: One credit per completed lookup; PAYG packs never expire; Apify: Per-event fees + compute units (memory × runtime)
- **Best fit** — Social Fetch: Production features that need data in the request thread; Apify: Custom scrapers, batch jobs, browser automation you write yourself
## Pricing scenario
Apify's Clockworks TikTok Scraper is the most-cited Actor for TikTok profiles. It charges per event, and the rate depends on your Apify subscription tier and whether you're scraping profiles, videos, or comments. Some Actors bill flat per request; others bill compute units on top. Social Fetch charges one credit per completed lookup at a flat rate — a not_found result still ran upstream and is charged; lookup_failed and 503 temporarily_unavailable are not.
- **Single TikTok profile:** Social Fetch — ~$0.00165; Apify — ~$0.0037+ (Clockworks profile event)
- **1,000 TikTok profiles:** Social Fetch — ~$1.65; Apify — ~$3.70+ (Clockworks; video/comment events cost more)
- **75k profiles/month (TikTok only):** Social Fetch — ~$124 one-time (Scale pack); Apify — ~$278+ at Clockworks rates
- **75k profiles across TikTok + Instagram + YouTube:** Social Fetch — ~$124 one-time, one balance; Apify — ~$278–500+ (three Actors, three input schemas)
- **Compute-unit surprises:** Social Fetch — None — flat per lookup; Apify — Slow runs, retries, and high memory settings increase cost
- **Monthly subscription required?:** Social Fetch — No — optional plans available; Apify — No base fee, but paid plans reduce per-event rates
- **Unused PAYG credits roll over?:** Social Fetch — Yes — PAYG packs never expire; Apify — N/A — billed at time of run
_Apify pricing from apify.com/clockworks/tiktok-scraper (July 2026). Clockworks lists from ~$3.70 per 1,000 results; video and comment events can cost more. Other Actors use different models (flat per-request, compute units only, or hybrid). Always check the specific Actor's pricing tab before estimating._
## Verdict
Apify is the right tool when you need to run custom scrapers, schedule batch jobs, or automate browsers at scale. Social Fetch is the right tool when you need TikTok, Instagram, YouTube, and the rest as structured JSON inside your application — now, with predictable per-request pricing. If your Apify integration is mostly "start Clockworks, poll until done, read dataset," you're using a general-purpose runtime for a job a REST API handles in one call. Keep Apify for the custom stuff; use Social Fetch for production social lookups.
## When Social Fetch wins
- Profile or post data must return during the user's request (onboarding, search, live dashboards)
- Multi-platform apps without maintaining separate Actor configs per network
- Flat per-lookup billing you can forecast from request volume alone
- One schema and one API key instead of marketplace Actor evaluation
- Production features where a broken community Actor is unacceptable downtime
## FAQ
### Is Social Fetch cheaper than Apify for TikTok scraping?
For standard profile and post lookups, usually yes. Social Fetch is $1.65 per 1,000 requests at the Scale pack. Clockworks TikTok Scraper lists from about $3.70 per 1,000 results, and video or comment events often cost more. Apify can be cheaper for very custom Actors you run yourself on minimal compute, but marketplace social Actors at production volume typically cost more than Social Fetch's flat rate.
### Do I have to poll for results with Social Fetch?
No. The JSON is in the HTTP response body. Apify requires starting a run, checking run status, and downloading from a dataset — or wiring webhooks on your side. Social Fetch is one request, one response.
### How fast is Social Fetch compared to an Apify Actor run?
Social Fetch typically returns in 2–4 seconds. Apify Actor runs usually take at least 10–30 seconds (container startup plus scrape time), and complex runs take minutes. For UI-driven features, that gap matters.
### Can I use Apify and Social Fetch together?
Yes. A common split: Social Fetch for production social lookups in your app, Apify for custom scrapers or batch jobs on sites we don't cover. Most teams that try both end up dropping Apify for standard social endpoints once the REST integration is in place.
### Does Social Fetch replace Apify entirely?
No — and we wouldn't claim that. Social Fetch replaces the Clockworks-style Actor workflow for structured social data across major platforms. It does not replace custom Actor development, browser automation, or Apify's scheduling and dataset pipeline for general web scraping.
### What about Apify compute units — do I pay those with Social Fetch?
No. Social Fetch bills per completed lookup, not per second of container runtime or megabyte of memory. Your cost is tied to request count, not how hard the upstream scrape was.
### Which platforms does each service cover?
Social Fetch covers 20 platforms (154 marketplace operations) under one API key with normalized schemas — TikTok, Instagram, YouTube, X/Twitter, LinkedIn, Facebook, Reddit, Threads, Spotify, and more. Apify's social coverage depends on which Actors you choose — there's no unified catalog with guaranteed maintenance.
### I'm already on Apify — is migration hard?
If you're fetching profiles and posts through marketplace Actors, migration is usually an afternoon. Remove run polling and dataset download code, point your app at Social Fetch endpoints, map response fields. Harder cases involve custom Actors with logic Social Fetch doesn't replicate — those should stay on Apify.
### What does the Apify TikTok scraper Actor cost in 2026?
Clockworks TikTok Scraper lists from about $3.70 per 1,000 results for profile events; video and comment events typically cost more, and total spend also depends on compute units (memory × runtime), not just the per-event rate. Check the Actor's own pricing tab before estimating — rates vary by author and change over time. Social Fetch is a flat $1.65 per 1,000 requests with no compute-unit variable.
### Does Apify charge compute units on top of per-result pricing?
Yes, for platform usage: roughly memory allocated × runtime, on top of any per-event Actor pricing. A slow proxy day or a retry loop increases cost for the same output. Social Fetch bills one credit per completed lookup regardless of how long the upstream fetch took.
---
# Social Fetch vs Ayrshare (2026) — read API vs post API
Source: https://www.socialfetch.dev/compare/ayrshare
# Social Fetch vs Ayrshare
Ayrshare lets your product publish, schedule, and moderate on behalf of connected social accounts — OAuth into the user's networks, then post. Social Fetch reads public social data without posting rights. One is a write/management API. The other is a read/enrichment API.
**Full comparison page:** https://www.socialfetch.dev/compare/ayrshare
## At a glance
- **Primary verb** — Social Fetch: Read public profiles, posts, comments, transcripts; Ayrshare: Post, schedule, analyze, and moderate connected accounts
- **Auth model** — Social Fetch: Your API key; public data only; Ayrshare: End-user OAuth / connected social profiles
- **Billing unit** — Social Fetch: Credits per completed lookup; Ayrshare: Active social profiles (customer/brand slots), monthly
- **Entry paid price** — Social Fetch: $25 PAYG pack; Ayrshare: Premium $149/mo (own presence) / Launch $299/mo
- **Needs user to connect Instagram?** — Social Fetch: No — public lookup by handle/URL; Ayrshare: Yes — posting requires linked accounts
- **Best fit** — Social Fetch: Enrichment, monitoring, creator intel in your backend; Ayrshare: SaaS products that publish as their users
## Pricing scenario
Ayrshare bills monthly by active social profiles (one customer connecting many networks still counts as one profile): Premium $149/mo, Launch $299/mo (multi-user / MVP), Business from $599/mo with tiered per-profile pricing as you scale, Enterprise custom. Max Pack and ads boosts are add-ons. Social Fetch does not sell posting: Scale pack $379 / 230k read credits ($1.65/1k).
- **Cheapest paid plan:** Social Fetch — $25 for 10k read credits; Ayrshare — $149/mo Premium
- **MVP multi-user posting:** Social Fetch — Not offered; Ayrshare — $299/mo Launch (trial available)
- **SaaS scale posting:** Social Fetch — Not offered; Ayrshare — From $599/mo Business + per-profile tiers
- **75k public profile reads:** Social Fetch — ~$124; Ayrshare — N/A — not a read-metered product
- **Post as your customer:** Social Fetch — No; Ayrshare — Yes — core product
- **Free trial:** Social Fetch — 100 credits, no card; Ayrshare — Launch plan 28-day free trial (no card per Ayrshare)
_Ayrshare pricing from ayrshare.com/pricing (July 2026). Profile definition and volume discounts described on that page. Social Fetch does not provide OAuth posting; do not budget Ayrshare as a read-API substitute._
## Verdict
Ayrshare is a posting and social management API priced on connected profiles. Social Fetch is a public read API priced on lookups. They barely compete. Use Ayrshare to publish as your users. Use Social Fetch to read public social data into your product. Many serious social products eventually need both.
## When Social Fetch wins
- You need public social data without user OAuth
- Discovery, enrichment, monitoring, or agents read entities at volume
- Per-lookup credits beat per-profile monthly minimums for read-only workloads
- You want OpenAPI-documented read routes across many networks
- Posting is out of scope — you only need the data plane
## FAQ
### Can Social Fetch post to Instagram?
No. Social Fetch is read-oriented public data. For posting, use Ayrshare or another publishing API with proper user authorization.
### Can Ayrshare replace Social Fetch for profile enrichment?
Only for accounts your users have connected, and within Ayrshare's analytics scope. It is not a general-purpose public TikTok/Instagram read API for arbitrary handles.
### Why is Ayrshare more expensive per month?
You are paying for OAuth publishing infrastructure and platform compliance across networks, metered by profiles. Social Fetch's cheaper entry reflects a different product: prepaid read credits.
### Do we need both?
If you both discover creators from public data and later publish as them (with consent), yes. If you only do one of those jobs, buy one.
### Does Social Fetch store user social passwords?
No. We do not OAuth users' posting credentials for publishing workflows.
### What about Ayrshare historical content APIs?
Ayrshare exposes management and analytics for connected profiles, including historical content on higher plans. Social Fetch fetches live public data for entities you specify — different authorization boundary.
---
# Social Fetch vs Brandwatch (2026) — listening vs data API
Source: https://www.socialfetch.dev/compare/brandwatch
# Social Fetch vs Brandwatch
Brandwatch (Cision) sells consumer intelligence dashboards: query builders, historical mention firehoses, sentiment, and analyst workflows on annual contracts. Social Fetch sells HTTP endpoints that return public profile and post JSON. One is a research and insights platform. The other is a data API for engineers.
**Full comparison page:** https://www.socialfetch.dev/compare/brandwatch
## At a glance
- **Category** — Social Fetch: Social data API for developers; Brandwatch: Enterprise social listening / consumer intelligence
- **Primary user** — Social Fetch: Engineers shipping product features; Brandwatch: Insights, brand, and research teams in a UI
- **Buying motion** — Social Fetch: Self-serve signup, card optional after free credits; Brandwatch: Sales-led custom quote, typically annual
- **Published pricing** — Social Fetch: $1.65/1k on Scale pack; packs from $25; Brandwatch: No public list price; third-party deal data often $800+/mo entry
- **Output** — Social Fetch: JSON via REST for entities you request; Brandwatch: Dashboards, alerts, exports, analyst workflows
- **Historical firehose** — Social Fetch: Live lookup of public entities you specify; Brandwatch: Large historical conversation archives in-product
## Pricing scenario
Brandwatch does not publish a price list. Procurement datasets and buyer reports commonly place entry deployments around $800–$1,500/month, mid-market around $2,000–$5,000/month, and larger suites higher — often on annual contracts with modules for listening, management, and influencer add-ons. Social Fetch has no annual listening suite: 100 free credits, then PAYG packs (Scale $379 / 230k credits ≈ $1.65/1k).
- **How you get a price:** Social Fetch — Read the pricing page; Brandwatch — Talk to sales; custom scope
- **Typical commercial shape:** Social Fetch — Prepaid credits or optional monthly plans; Brandwatch — Annual (sometimes multi-year) platform subscription
- **Indicative entry spend (third-party reports):** Social Fetch — $0 to start; $25 for first paid pack; Brandwatch — Often ~$800+/mo equivalent once contracted
- **75k entity lookups:** Social Fetch — ~$124 at Scale rate; Brandwatch — Not sold as per-lookup credits — bundled in suite
- **Analyst seats & Vizia-style viz:** Social Fetch — Not included — bring your own BI; Brandwatch — Core product for many buyers
- **Embed in your SaaS backend:** Social Fetch — First-class (API key + SDK); Brandwatch — Possible via enterprise integrations; not the default path
_Brandwatch pricing is not published on brandwatch.com. Indicative ranges cited from third-party procurement writeups (e.g. Vendr marketplace summaries and 2026 pricing roundups) as of July 2026. Treat them as directional; only a Brandwatch quote is authoritative for your scope._
## Verdict
Brandwatch wins for enterprise listening and consumer intelligence in a hosted suite. Social Fetch wins for developers who need public social JSON on demand. Comparing sticker prices is mostly noise — you are not buying the same thing. Choose Brandwatch for research programs. Choose Social Fetch for product APIs. Keep both when marketing and engineering have separate jobs.
## When Social Fetch wins
- Engineers need programmable public social entity data inside a product
- You want self-serve pricing without an annual listening contract
- Live profile/post lookups matter more than Boolean query archives
- You are building creator tools, enrichment, or agent workflows on HTTP APIs
- Budget is closer to credit packs than $10k–$50k+/year suite ACV
## FAQ
### Is Social Fetch a Brandwatch alternative?
Only if you were forcing Brandwatch to act as a raw data API for engineering. For social listening, sentiment workbenches, and historical mention analysis, Brandwatch remains the category tool. Social Fetch is an alternative to scrapers and social REST APIs — not to a full CI suite.
### How much does Brandwatch cost?
Brandwatch does not publish list pricing. Third-party procurement summaries in 2026 often cite entry around $800+/month equivalent on annual contracts, with mid-market and enterprise far higher. Ask Brandwatch for a quote scoped to your modules and seats.
### Does Brandwatch have an API?
Enterprise customers may get integration paths and exports. That is not the same experience as Social Fetch's public OpenAPI, TypeScript SDK, and per-lookup credits aimed at product engineers.
### Can Social Fetch do sentiment analysis?
We return public content and metrics. Sentiment, topic models, and executive dashboards are your layer (or a listening suite). Many teams pull text via Social Fetch and score it in their own pipeline.
### Which is better for influencer discovery?
Brandwatch's influencer modules are built for marketer workflows. Social Fetch is better when you already have handles or URLs and need verified public metrics in software. Different starting points.
### Do I need a sales call for Social Fetch?
No for standard self-serve usage. Email support@socialfetch.dev for enterprise paperwork or high-volume arrangements.
---
# Social Fetch vs Bright Data (2026) — proxies vs social API
Source: https://www.socialfetch.dev/compare/bright-data
# Social Fetch vs Bright Data
Bright Data is a proxy and web-scraping platform built for enterprise data teams — residential IP networks, browser farms, batch datasets, and spending limits that gate every request. Social Fetch is a social-native API: one key, one price per lookup, JSON back in seconds. If you only need Instagram profiles or TikTok posts in your app, you're buying a lot of infrastructure you won't touch.
**Full comparison page:** https://www.socialfetch.dev/compare/bright-data
## At a glance
- **What you're actually buying** — Social Fetch: Social data API — profiles, posts, comments, transcripts; Bright Data: Proxy infrastructure + scraper tooling + optional datasets
- **Target buyer** — Social Fetch: Product engineers shipping social features; Bright Data: Data engineering, procurement, enterprise analytics
- **Request model** — Social Fetch: Sync REST — call endpoint, get JSON; Bright Data: Sync API, async batch jobs, or scheduled dataset drops
- **Social media pricing** — Social Fetch: $1.65 per 1,000 requests; Bright Data: $2.50–$3.70 per 1,000 records (tier-dependent)
- **Social endpoint count** — Social Fetch: 154 operations across 20 platforms; Bright Data: 68 endpoints across 10 platforms
- **Getting started** — Social Fetch: 100 free requests, no card required; Bright Data: Free trial, then spending limits from $100/mo
- **Pricing transparency** — Social Fetch: One rate on the pricing page; Bright Data: Rates vary by product page, domain tier, and commitment
## Pricing scenario
Bright Data's social scraper pricing is hard to quote from a single page. Their web scraper product lists ~$3.70 per 1,000 records on one URL and ~$2.50 per 1,000 on another. Social platforms sit in "premium" domain tiers. Spending limits start at $100/month, and hitting your cap stops requests until you raise the limit — often after a sales conversation. Social Fetch charges a flat rate per completed lookup. No domain tiers, no monthly floor, no cap that fails your production traffic.
- **Single social profile record:** Social Fetch — ~$0.00165; Bright Data — ~$0.0025–$0.0037 per record
- **75k records/month (mixed platforms):** Social Fetch — ~$124 one-time; Bright Data — ~$188–$278 + $100/mo minimum commitment
- **Minimum monthly commitment:** Social Fetch — None — buy when needed; Bright Data — $100+ (higher limits require 50% monthly commitment)
- **What happens if you exceed limits?:** Social Fetch — Top up — no interruption; Bright Data — Requests fail until spending limit is raised
- **Proxy network fees (if you use them):** Social Fetch — Not applicable — no proxies to manage; Bright Data — Separate product line (residential, datacenter, mobile IPs)
- **Dataset delivery to S3/Snowflake:** Social Fetch — You call the API; you own the pipeline; Bright Data — Built-in delivery pipelines (part of enterprise stack)
_Bright Data pricing from brightdata.com/pricing/web-scraper (July 2026). Social scraper listings commonly show ~$3.70 per 1,000 records; lower tiers exist with spending-limit commitments. Their $499/mo Scale plan includes 384k records but still requires monthly commitment. Proxy network pricing is a separate line item._
## Verdict
Bright Data is the right vendor when you need proxy infrastructure, browser automation, or warehouse dataset delivery at enterprise scale — and you have the data engineering team to operate it. For social-only workloads, it's the wrong shape: you're paying for IP networks and procurement machinery when you need a handle lookup. Social Fetch is built for that narrower job. Same social data, faster integration, transparent per-request pricing, and no spending limit that fails your production traffic. Stay on Bright Data if you're already deep in their proxy and delivery stack. Switch to Social Fetch if you're using them as an expensive social profile API.
## When Social Fetch wins
- Product teams shipping social features on a sprint timeline, not a quarterly data platform rollout
- You want prepaid credits without a spending limit that can fail production traffic
- Live lookups in user-facing flows — creator cards, onboarding, search — where batch jobs and dataset polling are the wrong model
- Multi-platform apps that need TikTok, Instagram, YouTube, LinkedIn, and Reddit under one API key with one schema
- Startups and growing teams where $100+/mo spending limits and commitment tiers are premature overhead
- You don't want to manage proxy configuration, spending limits, or dataset delivery pipelines for work that is just "get this profile as JSON"
## FAQ
### Is Bright Data cheaper per request than Social Fetch?
No. Bright Data's typical social rates run about $2.50–$3.70 per 1,000 records — roughly 50–125% more than Social Fetch at $1.65 per 1,000. You also face spending limits, tier-dependent pricing, and often a $100+/mo minimum commitment. Social Fetch has no monthly floor and one flat rate across standard endpoints.
### Does Bright Data support more social platforms?
No. Bright Data covers 10 social platforms with 68 endpoints. Social Fetch covers 20 platforms with 154 operations. Social Fetch has broader coverage with a more consistent API surface across all of them.
### Do I need Bright Data's proxy network for social media data?
Not if you're using their Web Scraper API for social endpoints. Bright Data routes that traffic through their infrastructure automatically — you don't configure proxies separately for social API calls. But you're still paying for a platform designed around proxy management, spending limits, and enterprise data pipelines. Social Fetch handles extraction and routing internally; you just call an endpoint.
### Can Social Fetch deliver data to S3 or webhooks like Bright Data?
Social Fetch is a request-response API — you call an endpoint and receive JSON immediately. If you need automated delivery to cloud storage, wrap Social Fetch calls in your own cron job or queue. Bright Data's built-in S3/Snowflake delivery is worth paying for if you're already running warehouse ETL through their platform. For most app teams, a 20-line script that calls Social Fetch and writes to S3 is simpler than onboarding to Bright Data's delivery pipeline.
### What's the difference between Bright Data's sync API and batch collection?
Sync API returns data in the HTTP response — similar to Social Fetch. Batch collection kicks off an async job, you poll for status, then download results from a dataset. Batch is cheaper per record at very high volume but adds orchestration code and latency measured in minutes, not seconds. Social Fetch only offers sync. If your feature needs data in the request thread, batch is the wrong model regardless of vendor.
### Do I need a monthly subscription with Social Fetch?
No required subscription. Pay-as-you-go credit packs never expire — start with 100 free credits (no card), then purchase packs when needed. Optional monthly plans with included credits are available for steady volume. No minimum spend on PAYG.
### How long does it take to integrate Social Fetch vs Bright Data?
Social Fetch: minutes to first API call, an afternoon to production integration. Bright Data: typically days to weeks depending on spending limit setup, product selection (sync vs batch vs dataset), endpoint mapping, and whether procurement needs to approve a spending limit increase. For a team with a shipping deadline, that gap matters.
### Why does Bright Data list different prices on different pages?
Bright Data sells multiple products — proxy networks, browser scrapers, web scraper APIs, datasets — each with its own pricing page and commitment structure. Social scraper rates vary by tier and whether you're on pay-as-you-go or a monthly plan. The $2.50/1k and $3.70/1k figures both appear on their site depending on which product page you land on. Social Fetch publishes one rate per credit pack.
### Who should stay on Bright Data?
Teams actively using Bright Data's proxy networks, browser scrapers, or S3/Snowflake delivery for non-social or mixed workloads — especially at enterprise volume with negotiated pricing. If you're only using Bright Data for social media API access and none of the infrastructure around it, Social Fetch does the same job with less friction and no required subscription on pay-as-you-go.
### What is Bright Data's pricing model for social media data in 2026?
Social scraper rates commonly run ~$2.50–$3.70 per 1,000 records depending on the product page and tier, with spending limits starting around $100/month and higher tiers requiring a 50% monthly commitment. There's no single published rate — it depends on which product (Web Scraper API, batch collection, dataset delivery) you're on. Social Fetch publishes one flat rate per credit pack with no monthly minimum.
---
# Social Fetch vs Crawlbase (2026) — crawling API vs social API
Source: https://www.socialfetch.dev/compare/crawlbase
# Social Fetch vs Crawlbase
Crawlbase is a crawling and proxy platform: send a URL, get a page, pay by success and domain complexity. Social Fetch is a social data API. LinkedIn is where the comparison gets noisy — Crawlbase sells LinkedIn crawls as HTML; Social Fetch returns structured LinkedIn profile and company JSON among 20 platforms.
**Full comparison page:** https://www.socialfetch.dev/compare/crawlbase
## At a glance
- **Product shape** — Social Fetch: Social REST API; Crawlbase: Crawling API + Smart AI Proxy + storage
- **Billing unit** — Social Fetch: Credits per completed social lookup; Crawlbase: Per successful crawl; tiered by domain complexity
- **LinkedIn** — Social Fetch: Structured profile/company routes (1 credit typical); Crawlbase: Flat $15 per 1,000 successful LinkedIn crawls
- **Entry** — Social Fetch: 100 free credits; $25 packs; Crawlbase: 1,000+ free crawl requests; PAYG volume tiers
- **Output** — Social Fetch: Normalized social JSON + meta envelope; Crawlbase: HTML/page body (you parse)
- **Best fit** — Social Fetch: App features on social entities; Crawlbase: High-volume open-web crawling infrastructure
## Pricing scenario
Crawlbase's Crawling API uses PAYG volume tiers across Standard / Moderate / Complex domain complexity. Published third-party breakdowns for 2026 show roughly $3.00 / $4.50 / $6.00 per 1,000 at the lowest volume band, declining with volume (e.g. toward $0.60 / $0.90 / $1.20 per 1k after the first ~11k). LinkedIn is a separate flat rate around $15 per 1,000 successful crawls (public pages; free credits often excluded). Smart AI Proxy is a separate subscription ladder from about $149/mo. Social Fetch Scale is $379 for 230k credits at $1.65/1k for structured social lookups including LinkedIn.
- **Free start:** Social Fetch — 100 credits, no card; Crawlbase — 1,000 free crawl requests (more with payment on file)
- **1,000 standard-complexity pages:** Social Fetch — N/A; Crawlbase — ~$3.00 at lowest volume band (declines with volume)
- **1,000 LinkedIn page crawls:** Social Fetch — N/A (use structured routes instead); Crawlbase — ~$15 (flat LinkedIn rate)
- **1,000 structured LinkedIn profiles:** Social Fetch — ~$1.65; Crawlbase — Crawl cost + your HTML parsers
- **Failed upstream crawls:** Social Fetch — lookup_failed / 503 not charged; Crawlbase — Documented as free on unsuccessful crawls
- **Multi-platform social schema:** Social Fetch — 154 ops / 20 platforms; Crawlbase — Any URL; no social schema included
_Crawlbase pricing from crawlbase.com docs/blog and public plan summaries (July 2026). Domain complexity tiers and LinkedIn rates change; use their live calculator for exact quotes._
## Verdict
Crawlbase wins at scale page fetching and LinkedIn HTML transport. Social Fetch wins when you need structured social JSON — including LinkedIn — without owning parsers. Do not compare $15/1k LinkedIn crawls to $1.65/1k profile JSON as if they were the same SKU.
## When Social Fetch wins
- Structured LinkedIn/TikTok/Instagram JSON without HTML parsers
- A multi-platform social catalog, not a LinkedIn-crawl-plus-parsers plan
- Flat credit budgeting for product features
- Sync REST with requestId for support
- Coverage beyond LinkedIn HTML transport
## FAQ
### Is Crawlbase cheaper for LinkedIn?
Crawlbase's ~$15/1k is for successful LinkedIn page crawls (HTML). Social Fetch's ~$1.65/1k is for structured LinkedIn lookups. Cheaper depends on whether you already have parsers and what "done" means for your feature.
### Does Social Fetch crawl arbitrary URLs?
We have web fetch routes for supported use cases, but the product center is social entities. For general crawling at volume, Crawlbase (or similar) is the better fit.
### Does Crawlbase charge failed crawls?
Docs state unsuccessful crawls are not billed. Social Fetch similarly does not charge lookup_failed or 503 temporarily_unavailable.
### Can I use both?
Yes. Crawlbase for broad web crawls; Social Fetch for social profile/post/comment routes in the product.
### What is domain complexity?
Crawlbase classifies targets as standard, moderate, or complex based on anti-bot difficulty and prices successful requests accordingly. Social Fetch does not expose that dimension — standard social routes stay flat credits.
---
# Social Fetch vs Data365 (2026) — social API pricing
Source: https://www.socialfetch.dev/compare/data365
# Social Fetch vs Data365
Data365 is a social media API sold through monthly subscriptions that start at €300 for a single network and scale by how many networks you unlock. Social Fetch is a self-serve multi-platform API with published credit packs and one key for the whole catalog. Same category; very different buying motion.
**Full comparison page:** https://www.socialfetch.dev/compare/data365
## At a glance
- **What you're buying** — Social Fetch: Multi-platform social REST API; Data365: Social media API (per-network subscription)
- **Entry price** — Social Fetch: 100 free credits; packs from $25; Data365: €300/mo Basic — 1 social network, 500k credits
- **3 networks** — Social Fetch: Same key, same balance; Data365: €850/mo Standard — 3 networks, 1M credits
- **Getting docs / API access** — Social Fetch: Public docs + playground; Data365: Introductory call; docs after sales contact
- **Credit examples (their site)** — Social Fetch: Usually 1 credit per standard lookup; Data365: 1 post = 1 credit; profile info = 9; search = 7
- **Platforms on one plan** — Social Fetch: 20 platforms / 154 ops; Data365: 1–7 networks depending on tier
## Pricing scenario
Data365's public pricing (data365.co/pricing) lists Basic at €300/month for one social network and 500,000 credits, Standard at €850/month for three networks and 1,000,000 credits, and Custom up to seven networks. Credits reset with the subscription. Example costs on their page: 1 post = 1 credit, post + comments = 5, search = 7, profile with info = 9. Social Fetch publishes $1.65 per 1,000 standard lookups across all platforms on prepaid packs — no per-network upsell.
- **TikTok-only, light volume:** Social Fetch — Buy a small pack when needed; Data365 — €300/mo floor (Basic, 1 network)
- **TikTok + Instagram + YouTube:** Social Fetch — ~$1.65/1k on one balance; Data365 — €850/mo Standard (3 networks)
- **Profile with info (their example):** Social Fetch — Typically 1 credit (~$0.00165); Data365 — 9 credits against monthly pool
- **Unused monthly credits:** Social Fetch — N/A on PAYG — balance persists; Data365 — Expire with the billing period
- **Trial:** Social Fetch — 100 credits, no card, self-serve; Data365 — 14-day trial after sales form
_Data365 pricing from data365.co/pricing (July 2026), listed in EUR. Convert to USD for your budget. Full credit tables are behind their introductory call per their FAQ._
## Verdict
Data365 is a real social API with serious monthly pools — and a buying process and per-network packaging aimed at committed budgets. Social Fetch is built for teams that want the whole catalog on one key, published pack pricing, and no €300 floor before the first production week. Choose Data365 when the sales motion and network tiers match your org. Choose Social Fetch when time-to-first-call and multi-platform PAYG matter more.
## When Social Fetch wins
- Self-serve signup, public docs, and a playground without a sales call
- Many platforms on one key without per-network tier jumps
- Bursty usage and credits that never expire on PAYG
- Transparent $1.65/1k math for standard lookups
## FAQ
### Is Data365 cheaper per request?
Sometimes at very high steady volume inside one subscription tier — you have to convert EUR, apply their per-endpoint credit weights, and include the monthly floor. For bursty or multi-platform product traffic, Social Fetch's $1.65/1k PAYG is usually simpler and lower risk.
### Can I buy Data365 without talking to sales?
Their site directs you to a form and sales contact for trial and docs. Social Fetch is self-serve.
### How many platforms does each include?
Social Fetch: 20 marketplace platforms on one key. Data365: 1 network on Basic, 3 on Standard, up to 7 on Custom — priced accordingly.
### Do Data365 credits roll over?
They are monthly subscription credits. Social Fetch PAYG packs never expire.
---
# Social Fetch vs EnsembleData (2026) — social API comparison
Source: https://www.socialfetch.dev/compare/ensembledata
# Social Fetch vs EnsembleData
EnsembleData and Social Fetch are both direct REST APIs for public social data — not proxy networks or actor marketplaces. The split is billing (monthly units that reset nightly vs prepaid credits), platform coverage (8 networks vs 20), and how predictable your integration stays when Instagram renames a field.
**Full comparison page:** https://www.socialfetch.dev/compare/ensembledata
## At a glance
- **What you're comparing** — Social Fetch: Direct social REST API; EnsembleData: Direct social REST API
- **Billing model** — Social Fetch: PAYG packs never expire; optional monthly plans; EnsembleData: Monthly subscription ($100–$1,400/mo)
- **TikTok profile cost** — Social Fetch: $1.65 per 1,000 requests; EnsembleData: ~$2.67 per 1,000 requests (Bronze, typical use)
- **Endpoint surface** — Social Fetch: 154 operations across 20 platforms; EnsembleData: ~58 endpoints across 8 platforms
- **Response shape** — Social Fetch: Normalized data + meta envelope on every route; EnsembleData: Platform-native JSON (TikTok aweme_info, etc.)
- **What happens to unused quota?** — Social Fetch: Nothing — yours forever; EnsembleData: Daily units reset at midnight UTC
## Pricing scenario
On EnsembleData Bronze ($200/mo), you get 5,000 units per day — 150k/month capacity on paper. You still pay $200 if you only use 75,000 requests that month, and a single day above 5,000 fails until you upgrade tiers. Social Fetch charges per completed lookup with no monthly floor; unused credits stay on your balance. Both vendors skip billing on internal failures — EnsembleData documents zero units for internal errors; Social Fetch does not charge lookup_failed or 503 temporarily_unavailable.
- **Single TikTok User Info request:** Social Fetch — ~$0.00165 (1 credit); EnsembleData — ~$0.00267 (1 unit on Bronze at 75k/mo)
- **Instagram User Detailed Info:** Social Fetch — ~$0.00165 (1 credit); EnsembleData — ~$0.0267 (10 units on Bronze)
- **75k requests/month:** Social Fetch — ~$124 one-time; EnsembleData — $200/mo recurring (whether you use it or not)
- **What if you need 6,000 requests in one day?:** Social Fetch — No problem — no daily cap; EnsembleData — Exceeds Bronze daily limit (5,000/day) — requests fail
- **Free tier:** Social Fetch — 100 requests free, no card, no expiration; EnsembleData — 50 units/day trial (resets daily)
- **Per-minute rate limits:** Social Fetch — No published per-minute cap; EnsembleData — No published per-minute cap
_EnsembleData pricing from ensembledata.com/pricing (July 2026). Plans: Wood $100/mo (1,500/day), Bronze $200/mo (5,000/day), Silver $400/mo (11,000/day), Gold $800/mo (25,000/day), Platinum $1,400/mo (50,000/day). Unit costs per endpoint from ensembledata.com/apis/docs._
## Verdict
EnsembleData and Social Fetch are both legitimate REST APIs for public social data, and both skip charges on internal failures. EnsembleData goes deep on TikTok and includes Snapchat; Social Fetch goes wide across 20 platforms with LinkedIn, Facebook, Twitch, and transcripts in the same key. The deciding factor for most teams is economics and envelope shape: EnsembleData's daily unit reset turns slow weeks into wasted spend and turns spike days into failed requests unless you upgrade tiers, while Social Fetch's flat $1.65 per 1,000 completed lookup with no expiry fits real product traffic better. Choose EnsembleData when your usage is steady and your stack already speaks platform-native JSON. Choose Social Fetch when you need cross-network coverage, normalized responses, and credits you can spend on your schedule.
## When Social Fetch wins
- Multi-platform products that need LinkedIn, Facebook, Spotify, or web utilities in the same vendor
- Bursty or uneven usage — launches, backfills, seasonal campaigns, side projects with quiet months
- Pipelines that need lookupStatus and requestId on every response for support and retries
- Developers who want a TypeScript SDK, hosted OpenAPI, and a playground without assembling Postman collections
- Startups where a $100–200/mo floor is hard to justify before product-market fit
## FAQ
### Are EnsembleData and Social Fetch the same kind of product?
Yes. Both are direct REST JSON APIs for public social data — not proxy marketplaces, not async actor platforms. You send a GET with an API token and receive JSON. The differences are billing (monthly units with a daily reset vs prepaid credits), platform coverage, and whether responses are normalized across networks.
### What happens to unused EnsembleData units at the end of the day?
They reset at 00:00 UTC. If Bronze gives you 5,000 units/day and you use 2,000, the other 3,000 do not roll forward. Social Fetch PAYG credits stay on your balance until you spend them; optional subscription included credits reset each monthly period.
### Is EnsembleData actually cheaper than Social Fetch?
Often no at realistic volume. A 1-unit TikTok User Info call on Bronze looks cheap in isolation (~$0.00267 at 75k/month), but you pay $200/month whether you use 75,000 requests or 5,000. Heavy Instagram endpoints cost up to 10 units per call. Under-using slow days or hitting the daily cap pushes effective rates toward $3+ per 1,000. Social Fetch stays $1.65 per 1,000 for standard lookups on PAYG with no required subscription floor.
### Which API covers more platforms?
Social Fetch lists 20 platforms including LinkedIn, Facebook, Spotify, GitHub, Rumble, Telegram, Twitch, Bluesky, and web utilities. EnsembleData covers eight: TikTok, Instagram, YouTube, Threads, Reddit, Twitch, X, and Snapchat. EnsembleData is stronger if you specifically need Snapchat; Social Fetch is stronger for LinkedIn, Facebook, and ad-library workflows.
### How do response formats compare?
EnsembleData returns largely platform-native JSON — TikTok aweme_info structures, Instagram fields as Meta serves them. Social Fetch normalizes fields across platforms and wraps every response with data.lookupStatus, meta.requestId, and meta.creditsCharged. Native JSON is fine if you already maintain per-network parsers; normalized envelopes reduce ETL work for multi-platform products.
### Can I burst above my daily limit on EnsembleData?
No. Requests fail once you exhaust the day's units. Upgrading tiers ($200 → $400 → $800/mo) is the documented path for more daily capacity. Social Fetch has no daily cap — spend credits at whatever rate your job requires.
### Do both APIs charge for failed lookups?
Neither charges for their own infrastructure failures. EnsembleData's FAQ states zero units for failed requests caused by internal errors. Social Fetch does not charge lookup_failed or 503 temporarily_unavailable. Both charge for completed lookups where the upstream ran — including not_found results on Social Fetch.
### Does EnsembleData have a TypeScript SDK?
No official SDK. EnsembleData provides API docs, a downloadable OpenAPI spec, and Postman support. Social Fetch adds an official TypeScript SDK with full types, a hosted OpenAPI spec, and an interactive browser playground.
### Which API is better for a side project or startup?
Usually Social Fetch for early-stage work: 100 free requests with no card and no expiration, no $100/month production floor, and credits that survive quiet months. EnsembleData's Wood plan starts at $100/month with 1,500 units/day — reasonable once usage is steady, heavy for experiments that spike and pause.
---
# Social Fetch vs Exa (2026) — social API vs neural web search
Source: https://www.socialfetch.dev/compare/exa
# Social Fetch vs Exa
Exa searches the web with semantic and neural retrieval — people, companies, code, and general queries with contents included on search. Social Fetch looks up social network entities you already identified. Both show up in AI stacks; only one returns a TikTok followerCount field.
**Full comparison page:** https://www.socialfetch.dev/compare/exa
## At a glance
- **Primary job** — Social Fetch: Structured social media lookups; Exa: Neural / semantic web search for AI
- **Pricing (headline)** — Social Fetch: $1.65 per 1,000 social lookups; Exa: $7 per 1,000 searches (up to 10 results + contents)
- **Free tier** — Social Fetch: 100 credits, never expire; Exa: Generous free credits / monthly allowance (see Exa pricing)
- **People / company search on the web** — Social Fetch: Not the product; Exa: Core strength
- **TikTok profile JSON** — Social Fetch: Dedicated route + normalized schema; Exa: Search results — not a social API
- **Social catalog** — Social Fetch: 154 ops / 20 platforms; Exa: Web index — category mismatch
## Pricing scenario
Exa publishes endpoint pricing on exa.ai/pricing: Search $7 per 1,000 requests (up to 10 results with text/highlights), Deep Search $12, Deep-Reasoning $15, Contents $1 per 1,000 pages, Answer $5 per 1,000. Social Fetch Scale is $1.65 per 1,000 standard social lookups on non-expiring packs. A thousand Exa searches will not yield a thousand structured Instagram profiles.
- **1,000 search requests:** Social Fetch — N/A; Exa — $7 (standard Search, ≤10 results)
- **1,000 social profile lookups:** Social Fetch — ~$1.65; Exa — N/A as structured social
- **Full page contents add-on:** Social Fetch — Web fetch is a separate social-adjacent utility; Exa — $1 per 1,000 pages on Contents endpoint
- **Billing style:** Social Fetch — Prepaid packs; PAYG never expires; Exa — Usage-based API credits
_Exa pricing from exa.ai/pricing (July 2026). Free credit promotions change; verify the current signup and monthly free allotment on Exa's site before modeling a prototype budget._
## Verdict
Exa is for finding and reading the web. Social Fetch is for structured social entities you already named. Keep Exa in the research tool slot. Keep Social Fetch in the social data tool slot. Ranking them on a single price-per-1k chart without separating those jobs misleads procurement.
## When Social Fetch wins
- Live social profiles, posts, comments, transcripts as JSON
- Dashboards and CRM enrichment keyed by social handles
- One envelope across many social networks
## FAQ
### Is Exa cheaper than Social Fetch?
For web search, Exa's $7/1k is the relevant number. For social profile lookups, Social Fetch's $1.65/1k is the relevant number. They are not interchangeable SKUs.
### Can Exa return TikTok follower counts reliably?
Only insofar as some web page mentions them. That is not the same as a live profile lookup with typed fields and lookupStatus.
### Should my agent include both tools?
Usually yes if it both researches the web and enriches social accounts. Route by argument type: query → Exa; handle/URL → Social Fetch.
---
# Social Fetch vs Firecrawl (2026) — social API vs web crawl
Source: https://www.socialfetch.dev/compare/firecrawl
# Social Fetch vs Firecrawl
Firecrawl is a web context API for AI — scrape, crawl, map, and search pages into LLM-ready markdown. Social Fetch is a social data API — TikTok handles, Instagram posts, LinkedIn companies as normalized JSON. If your agent needs a whole docs site, Firecrawl. If it needs a creator's follower count, Social Fetch.
**Full comparison page:** https://www.socialfetch.dev/compare/firecrawl
## At a glance
- **Primary job** — Social Fetch: Structured social media data; Firecrawl: Web scrape, crawl, and search for AI agents
- **Typical output** — Social Fetch: Normalized profile/post JSON; Firecrawl: Markdown, HTML, or schema extract per page
- **Pricing shape** — Social Fetch: PAYG packs from $1.65/1k; credits never expire; Firecrawl: Monthly plans (Hobby $19 → Growth $399); credits reset
- **TikTok profile by handle** — Social Fetch: First-class REST route; Firecrawl: Scrape the public URL yourself — no social schema
- **Site-wide crawl / map** — Social Fetch: Not the product (web fetch is single-page); Firecrawl: Core product
- **Social catalog** — Social Fetch: 154 ops / 20 platforms; Firecrawl: Any URL — you own parsing social HTML
## Pricing scenario
Firecrawl bills monthly credit allotments: Free 1,000/mo, Hobby $19/mo for 5,000, Standard $99/mo for 100,000, Growth $399/mo for 500,000 (annual billing lowers the effective monthly rate). Scrape/Crawl are 1 credit per page; JSON extract and Enhanced Mode add credits. Plan credits do not roll over (auto-recharge packs do). Social Fetch sells prepaid packs that never expire at $1.65 per 1,000 standard social lookups. Comparing "1 credit" across vendors is misleading — Firecrawl's unit is a web page; ours is a social operation.
- **1,000 standard social profile lookups:** Social Fetch — ~$1.65; Firecrawl — N/A as a social product — scrape URLs + parse HTML
- **1,000 web pages to markdown:** Social Fetch — Web fetch routes exist; not priced as a crawl farm; Firecrawl — ~1,000 credits (Hobby covers 5k/mo)
- **Unused credits next month:** Social Fetch — Still on your balance (PAYG); Firecrawl — Plan credits reset (auto-recharge packs roll)
- **Required subscription:** Social Fetch — No on PAYG; Firecrawl — Yes for volume above free tier
- **Crawl entire documentation site:** Social Fetch — Wrong tool; Firecrawl — Designed for this
_Firecrawl pricing from firecrawl.dev/pricing (July 2026). Hobby $19/mo or $16/mo annual; Standard $99/$83; Growth $399/$333. Confirm current credit modifiers for JSON and Enhanced Mode on their billing docs._
## Verdict
Firecrawl is the right buy for LLM-ready web crawl and scrape. Social Fetch is the right buy for production social profiles and posts. Credits are not interchangeable: one meters pages, the other meters social operations. Keep Firecrawl for the open web; use Social Fetch when the entity is a creator, brand, or post on a social network.
## When Social Fetch wins
- TikTok, Instagram, YouTube, LinkedIn, etc. as structured JSON
- Product features that need lookupStatus and stable field names
- PAYG social credits that never expire
- Avoiding HTML parsers for social profile pages
## FAQ
### Can Firecrawl replace Social Fetch for TikTok data?
Only if you are willing to scrape TikTok URLs and maintain your own parsers. Firecrawl will fetch pages; it will not give you our social schema, multi-platform envelope, or platform-specific maintenance. For production social features, use a social API.
### Does Social Fetch crawl websites like Firecrawl?
No. We offer web fetch utilities for individual pages alongside social routes. We do not offer Firecrawl-style crawl, map, or browser interact products.
### Which is cheaper?
For web pages, compare Firecrawl's monthly credit plans. For social lookups, compare Social Fetch's $1.65/1k packs. Mixing the unit of work into one "cheaper API" number is how budgets go wrong.
### Do Firecrawl credits roll over?
Monthly plan credits do not. Auto-recharge packs do. Social Fetch PAYG packs never expire.
---
# Social Fetch vs Meltwater (2026) — media suite vs social API
Source: https://www.socialfetch.dev/compare/meltwater
# Social Fetch vs Meltwater
Meltwater packages media monitoring, social listening, journalist databases, and influencer workflows into a sales-scoped platform. Social Fetch packages public social entity lookups into a REST API. PR teams buy Meltwater. Product teams buy Social Fetch.
**Full comparison page:** https://www.socialfetch.dev/compare/meltwater
## At a glance
- **Category** — Social Fetch: Social data API; Meltwater: Media intelligence / social listening platform
- **Who logs in daily** — Social Fetch: Services and backends (API keys); Meltwater: Comms, PR, and brand teams (workspace UI)
- **Pricing transparency** — Social Fetch: Public packs and per-1k rates; Meltwater: Custom quote; Meltwater publishes indicative yearly bands
- **Indicative commercial entry** — Social Fetch: 100 free credits; paid from $25; Meltwater: Starter-from figures around $10k/year on Meltwater's own ranges
- **News + print + broadcast** — Social Fetch: Not our focus; Meltwater: Core media monitoring coverage
- **Ship a creator card in your app** — Social Fetch: Direct fit; Meltwater: Wrong tool shape — exports/UI, not product API-first
## Pricing scenario
Meltwater states that pricing is tailored. Their pricing materials list indicative starting points (USD): Starter from about $10,000/year, Pro from about $25,000/year, Enterprise from about $130,000/year — scoped by modules, regions, and users. Third-party deal datasets often show medians near the mid–five figures annually. Social Fetch does not sell a media suite: Scale pack $379 / 230k credits ($1.65/1k), no annual listening floor.
- **Pricing model:** Social Fetch — Credits (PAYG + optional plans); Meltwater — Custom annual (modules + coverage + seats)
- **Indicative Starter band (vendor ranges):** Social Fetch — N/A — not a suite tier; Meltwater — From ~$10,000/year (Meltwater indicative)
- **Indicative Pro band:** Social Fetch — N/A; Meltwater — From ~$25,000/year (Meltwater indicative)
- **75k social profile API lookups:** Social Fetch — ~$124; Meltwater — Not metered that way inside the suite
- **Journalist / media contacts database:** Social Fetch — Not included; Meltwater — Available as part of media relations modules
- **Time to first successful API call:** Social Fetch — Minutes after signup; Meltwater — After scoping, contract, and workspace setup
_Meltwater indicative tiers from meltwater.com/en/blog/meltwater-pricing and meltwater.com/en/pricing (July 2026). Figures are vendor-stated ranges for early budgeting, not a fixed quote. Social Fetch rates from socialfetch.dev/pricing._
## Verdict
Meltwater is the right purchase for media monitoring and listening programs sold to communications teams. Social Fetch is the right purchase for developers who need structured public social data in software. Do not cancel a Meltwater contract to save on API credits — and do not buy Meltwater to power a creator onboarding API. Split the stack by persona.
## When Social Fetch wins
- Product or data engineering needs public social JSON on demand
- You want transparent per-lookup pricing without suite procurement
- Creator enrichment, agents, or SaaS features are the consumers — not analysts
- You already have BI and only need the data plane for social entities
- Spiky usage fits prepaid credits better than annual module bundles
## FAQ
### Is Social Fetch cheaper than Meltwater?
For raw entity lookups, yes — credits are orders of magnitude cheaper than annual suite ACV. That comparison only matters if you were using Meltwater as a makeshift data API. For PR monitoring, Meltwater's price buys workflows Social Fetch does not sell.
### Does Meltwater publish pricing?
Not a fixed rate card. Meltwater describes tailored pricing and publishes indicative yearly starting bands (Starter / Pro / Enterprise) for budgeting. Your quote depends on modules and scope.
### Can Meltwater replace Social Fetch for TikTok profiles?
Not as a developer-metered REST API with OpenAPI and per-lookup credits. Listening exports and UI search are a different integration model.
### Can Social Fetch replace Meltwater for PR?
No. We do not provide media contact databases, clip monitoring across news/broadcast, or analyst workspaces.
### Who should evaluate both?
Companies where marketing owns a listening suite and product owns enrichment features. Evaluate both, buy both for different teams, and stop trying to stretch one tool across both jobs.
### What platforms does Social Fetch cover?
20 platforms with 154 marketplace operations — see the API docs for the live catalog.
---
# Social Fetch vs Modash (2026) — influencer API comparison
Source: https://www.socialfetch.dev/compare/modash
# Social Fetch vs Modash
Modash sells influencer discovery and live creator data as enterprise APIs with annual contracts. Social Fetch sells public social lookups as prepaid credits. Both return JSON about creators — one is built for agency-grade discovery filters and audience reports, the other for product features that call a profile endpoint mid-request.
**Full comparison page:** https://www.socialfetch.dev/compare/modash
## At a glance
- **Product shape** — Social Fetch: Public social REST API; Modash: Influencer Discovery API + Raw live API
- **Platforms** — Social Fetch: 20 platforms, 154 operations; Modash: Instagram, TikTok, YouTube (380M+ creator index)
- **Entry pricing** — Social Fetch: $25 Starter pack (10k credits) or 100 free; Modash: Raw from $10,000/yr; Discovery from $16,200/yr
- **Contract** — Social Fetch: Self-serve PAYG; optional monthly plans; Modash: Annual commitment; no monthly or PAYG API plans
- **Discovery filters** — Social Fetch: Lookup by handle/URL; search routes per platform; Modash: Audience, credibility, lookalikes, collabs, email match
- **Best fit** — Social Fetch: App features and agent tools needing public JSON; Modash: Influencer platforms and agencies building discovery UIs
## Pricing scenario
Modash publishes two API products on modash.io/influencer-marketing-api/pricing. Discovery starts at $16,200/year for 3,000 credits/month (~$0.45 per credit at that tier; unused Discovery credits roll over while the contract is active). Raw starts at $10,000/year for 40,000 requests/month (~$0.02 per request at that floor). Both require annual commitment; Modash states they do not offer monthly or pay-as-you-go API plans. Social Fetch Scale is $379 for 230k credits that never expire — about $1.65 per 1,000 standard lookups with no annual floor.
- **Cheapest published entry:** Social Fetch — $25 for 10k credits (PAYG); Modash — $10,000/yr Raw (40k req/mo)
- **Discovery / search product:** Social Fetch — Platform search routes; 1 credit typical; Modash — $16,200/yr for 3,000 Discovery credits/mo
- **40,000 live profile/feed pulls:** Social Fetch — ~$66 at Scale rate; Modash — $10,000/yr Raw allotment (contract floor)
- **Monthly or PAYG API?:** Social Fetch — Yes — packs and optional monthly plans; Modash — No — annual only (per pricing FAQ)
- **Free start:** Social Fetch — 100 credits, no card; Modash — Demo / sales-arranged test credits
- **Audience / fake-follower reports:** Social Fetch — Not offered (public fields only); Modash — Discovery credits (influencer + audience reports)
_Modash API pricing from modash.io/influencer-marketing-api/pricing and product pages (July 2026). Platform SaaS plans are billed separately from the API. Confirm current annual tiers with Modash sales before budgeting._
## Verdict
Modash is the right buy when discovery filters and audience intelligence on Instagram, TikTok, and YouTube are the product — and you can fund an annual API contract. Social Fetch is the right buy when you need public social JSON across more platforms, sync REST in the request thread, and published per-lookup pricing. Same keyword ("creator API"); different procurement and depth.
## When Social Fetch wins
- Public profile/post lookups inside product UX or agents
- Self-serve pricing with no annual minimum
- Coverage beyond IG/TikTok/YouTube (20 platforms)
- PAYG credits that never expire on prepaid packs
- TypeScript SDK, playground, and requestId on every response
## FAQ
### Is Modash cheaper per request than Social Fetch?
At full Raw utilization, Modash's published $10k/year for 40k requests/month lands near $0.02 per request — lower than Social Fetch's $0.00165 only if you compare wrong units: Social Fetch is ~$0.00165 per credit. Raw can be cheaper per call at high steady volume, but you still pay the annual floor. For bursty or low volume, Social Fetch PAYG is usually cheaper total spend.
### Does Social Fetch offer audience demographics like Modash?
No. We return public profile and content fields. Audience credibility, fake-follower scores, and similar Discovery reports are Modash features.
### Can I use both?
Yes. Common pattern: Modash Discovery for shortlisting creators; Social Fetch for hydrating public profiles across additional networks or for product features that should not sit behind Modash's annual API contract.
### Does Modash cover LinkedIn or Reddit?
Modash's influencer API marketing focuses on Instagram, TikTok, and YouTube. Social Fetch includes LinkedIn, Reddit, and other networks in the same catalog.
### Is there a Modash free API tier?
API access is demo/sales-arranged. Modash's separate platform product offers a trial; API plans start at five-figure annual amounts. Social Fetch gives 100 free credits with no card.
---
# Social Fetch vs Outstand (2026) — publish API vs data API
Source: https://www.socialfetch.dev/compare/outstand
# Social Fetch vs Outstand
Outstand is a unified publish API: one integration to post, schedule, and pull analytics across connected accounts. Social Fetch is a public data API: look up profiles and posts without OAuth. Both say "social API"; one writes as the user, the other reads what is already public.
**Full comparison page:** https://www.socialfetch.dev/compare/outstand
## At a glance
- **Direction** — Social Fetch: Read public social data; Outstand: Write/schedule posts + read own analytics
- **Auth model** — Social Fetch: API key; no end-user OAuth required; Outstand: Connected social accounts (managed keys or BYOK)
- **Platforms** — Social Fetch: 20 platforms for public lookups; Outstand: 11 networks for publish/schedule/analytics
- **Entry pricing** — Social Fetch: 100 free credits; packs from $25; Outstand: $19/mo including 3,000 posts
- **Webhooks / scheduling** — Social Fetch: Client-driven refetch; no native scheduler; Outstand: Native schedule + webhook events
- **Best fit** — Social Fetch: Enrichment, monitoring, agent read tools; Outstand: Schedulers, social agents that post, agency publishers
## Pricing scenario
Outstand prices publishing: $19/mo includes 3,000 posts, then about $0.007 per post up to 10k and $0.005 beyond (outstand.so, July 2026). Connected accounts are unlimited on that base plan; Managed Keys are included. Social Fetch prices public reads: Scale $379 for 230k credits ($1.65/1k). Comparing "$19 vs $1.65/1k" without separating write vs read is how teams buy the wrong API.
- **3,000 outbound posts:** Social Fetch — N/A — we do not publish; Outstand — $19/mo base (included)
- **10,000 outbound posts:** Social Fetch — N/A; Outstand — $19 + overage (~$0.007 then $0.005/post)
- **10,000 public profile lookups:** Social Fetch — ~$16.50 at Scale; Outstand — N/A — not a public scrape catalog
- **Creator OAuth required?:** Social Fetch — No for public data; Outstand — Yes — accounts must be connected
- **MCP / agent posting:** Social Fetch — Read-oriented agent tooling; Outstand — Publish tools (create_post, schedule, analytics)
- **Cold enrichment of strangers' profiles:** Social Fetch — Supported on public routes; Outstand — Not the product (you post as connected users)
_Outstand pricing from outstand.so (July 2026). Confirm current overage tiers and Business SLA packaging before budgeting._
## Verdict
Outstand is for writing to social networks you have connected. Social Fetch is for reading public data about networks and creators. Same industry keywords; opposite verbs. Many products need both — almost none should pick one expecting the other.
## When Social Fetch wins
- Public profile/post lookups with no user OAuth
- Cold enrichment and brand monitoring on accounts you do not own
- PAYG credits for read-heavy workloads
- Broad public catalog (20 platforms)
- Sync read APIs inside product request threads
## FAQ
### Can Social Fetch post to Instagram?
No. We only return public data. Use Outstand, native Meta APIs, or another publish layer for posting.
### Can Outstand replace Social Fetch for profile enrichment?
Not for cold public lookups. Outstand's analytics and post reads assume connected accounts and content flowing through their publish path.
### Which is cheaper?
For posting volume, Outstand's $19 + per-post overage is the relevant card. For public lookups, Social Fetch's credit packs are the relevant card. Do not cross-compare.
### Can I use both?
Yes. Recommended for agents and schedulers that research publicly then publish as the user.
### Does Outstand require OAuth?
Yes in practice — accounts must be connected (Outstand-managed keys or your own app credentials). Social Fetch public routes use your API key only.
---
# Social Fetch vs Oxylabs (2026) — proxy scraper vs social API
Source: https://www.socialfetch.dev/compare/oxylabs
# Social Fetch vs Oxylabs
Oxylabs is an enterprise proxy and scraper company — residential IPs, SERP and e-commerce scrapers, and a Web Scraper API that returns page HTML or parsed fields by target type. Social Fetch is a social-native REST API: pass a handle, get profile JSON. Same word "scrape" in search results; different products.
**Full comparison page:** https://www.socialfetch.dev/compare/oxylabs
## At a glance
- **What you're buying** — Social Fetch: Social data API — profiles, posts, comments, transcripts; Oxylabs: Proxy networks + Web/SERP/E-commerce Scraper APIs
- **Response shape** — Social Fetch: Normalized social JSON (`followerCount`, bio, avatar…); Oxylabs: HTML or target-specific parsed fields (Amazon, Google, Other)
- **Billing model** — Social Fetch: PAYG packs never expire; optional monthly plans; Oxylabs: Monthly subscription from $49 (Micro) with feature-based rates
- **Typical social-page cost** — Social Fetch: $1.65 per 1,000 completed lookups; Oxylabs: ~$1.15–$1.35 per 1,000 successful results ("Other" / JS tiers)
- **You still need to…** — Social Fetch: Map our fields into your app; Oxylabs: Parse Instagram/TikTok HTML or maintain extraction rules
- **Best fit** — Social Fetch: Product features that need live social lookups; Oxylabs: Data teams scraping e-commerce, SERPs, and the open web
## Pricing scenario
Oxylabs Web Scraper API bills successful results against a monthly plan. On Micro ($49/mo), published rates include Amazon ~$0.50/1k, Google ~$1.00/1k, Other without JS ~$1.15/1k, and with JS rendering ~$1.35/1k. Social platforms sit in the general "Other" / JS buckets — you get page content, not a ready-made TikTok profile schema. Social Fetch charges one credit per completed lookup at $1.65/1k on the Scale pack, with the schema already normalized.
- **Entry monthly commitment:** Social Fetch — None on PAYG; Oxylabs — $49/mo Micro (up to ~37k–98k results depending on target)
- **1,000 JS-rendered page results:** Social Fetch — N/A — we return structured social JSON; Oxylabs — ~$1.35 (Micro JS tier)
- **1,000 structured social profile lookups:** Social Fetch — ~$1.65; Oxylabs — ~$1.35+ scrape cost + your parsing, retries, and schema work
- **75k social lookups/month:** Social Fetch — ~$124 one-time (Scale pack); Oxylabs — ~$99–$249/mo plan tier + engineering time to keep parsers alive
- **Unused capacity:** Social Fetch — PAYG credits never expire; Oxylabs — Monthly result allotment — use it or lose it with the period
- **Free trial:** Social Fetch — 100 credits, no card; Oxylabs — Up to 2,000 results, no time limit on the trial allotment
_Oxylabs Web Scraper API pricing from oxylabs.io/products/scraper-api/web/pricing and developers.oxylabs.io help center (July 2026). Rates are per successful result and vary by target category and JS rendering. Proxy network products are priced separately (per GB / per IP)._
## Verdict
Oxylabs is a strong proxy and general web-scraper vendor. For social-only product work it is the wrong shape: you pay for monthly result plans and still write the social schema yourself. Social Fetch is built for that narrower job — structured public social data, flat per-lookup pricing, no required subscription on pay-as-you-go. Keep Oxylabs for SERPs and e-commerce. Use Social Fetch when the deliverable is a profile or post object.
## When Social Fetch wins
- You need TikTok, Instagram, YouTube, LinkedIn, and related networks as JSON in one vendor
- Product features depend on live lookups inside a user request
- You do not want to maintain CSS/JSON parsers when platforms change markup
- PAYG credits without a $49+/mo scraper-API floor fit your volume better
- lookup_failed / 503 paths should not burn the same credits as a successful HTML fetch
## FAQ
### Is Oxylabs cheaper than Social Fetch for social data?
Listed Oxylabs Web Scraper rates for "Other" / JS results (~$1.15–$1.35/1k on Micro) can look cheaper than Social Fetch's $1.65/1k. That comparison is incomplete: Oxylabs returns page content you must parse and maintain, and you need a monthly plan from $49. Social Fetch returns normalized social JSON with no required subscription on PAYG. Fully loaded cost usually favors Social Fetch for profile and post lookups.
### Does Oxylabs have dedicated TikTok or Instagram APIs?
Oxylabs offers scraper APIs aimed at web, SERP, and e-commerce targets. Social platforms are typically scraped as general web pages (often with JS rendering), not as first-class social profile endpoints with a stable schema like Social Fetch.
### Can I use Oxylabs proxies with Social Fetch?
No need. Social Fetch handles extraction and routing internally. You call our REST endpoints with an API key. If you already buy Oxylabs proxies for other projects, keep them for those projects — they are not part of the Social Fetch integration.
### Does Social Fetch replace Oxylabs?
No. Social Fetch replaces DIY social scraping for supported platforms. It does not replace Oxylabs proxy networks, Amazon/Google scrapers, or general open-web collection.
### How fast is each option?
Social Fetch typically returns in a few seconds with JSON in the response body. Oxylabs scrape latency depends on target, rendering, and retries; you then add your own parse step. For UI-driven social features, the end-to-end gap matters.
### Which platforms does Social Fetch cover?
Social Fetch covers 20 platforms with 154 marketplace operations — TikTok, Instagram, YouTube, X/Twitter, LinkedIn, Facebook, Reddit, Threads, and more under one key.
---
# Social Fetch vs PhantomBuster (2026) — REST vs Phantoms
Source: https://www.socialfetch.dev/compare/phantombuster
# Social Fetch vs PhantomBuster
PhantomBuster is a cloud automation studio — pre-built Phantoms for LinkedIn outreach, scraping flows, and sales workflows, billed in execution hours and slots. Social Fetch is a developer API for structured social data. If you are automating a browser playbook, PhantomBuster. If you are calling an API from your backend, Social Fetch.
**Full comparison page:** https://www.socialfetch.dev/compare/phantombuster
## At a glance
- **What you operate** — Social Fetch: REST endpoints + API key; PhantomBuster: Phantoms, workflows, execution hours
- **Pricing** — Social Fetch: $1.65/1k lookups; PAYG packs; PhantomBuster: Start $69 / Grow $159 / Scale $439 per month
- **Meter** — Social Fetch: Credits per completed lookup; PhantomBuster: Execution hours + Phantom slots + AI/email credits
- **Best user** — Social Fetch: Engineers shipping product features; PhantomBuster: Growth/sales teams running automations
- **LinkedIn enrichment in an app** — Social Fetch: API route, JSON in response; PhantomBuster: Run a Phantom, export CSV/JSON, or call their API around automations
- **Social API catalog** — Social Fetch: 154 ops / 20 platforms; PhantomBuster: Automation recipes — not a unified social schema API
## Pricing scenario
PhantomBuster's paid plans (as of their May 2026 support article): Start $69/mo (20 execution hours, 5 slots), Grow $159/mo (80 hours, 15 slots), Scale $439/mo (300 hours, 50 slots), with ~20% off on annual billing. Trial and free plans cap exports at 10 rows. API access on paid plans is for driving automations — you still think in hours and slots. Social Fetch never bills runtime; a completed lookup is one credit at a published pack rate.
- **75k structured profile lookups:** Social Fetch — ~$124 one-time; PhantomBuster — Depends on Phantom runtime — hours, not rows
- **Monthly floor:** Social Fetch — None on PAYG; PhantomBuster — $69+ once you leave free/trial limits
- **LinkedIn outreach sequences:** Social Fetch — Wrong tool; PhantomBuster — Core use case
- **Embed in a SaaS backend:** Social Fetch — Designed for this; PhantomBuster — Possible via API — still automation-shaped
- **Export limits on free/trial:** Social Fetch — Full API within credit balance; PhantomBuster — 10-row cap on free/trial exports
_PhantomBuster plan details from support.phantombuster.com pricing article (May 2026 figures cited there). Confirm current hours and slot counts on phantombuster.com/pricing before buying._
## Verdict
PhantomBuster wins for cloud social automations billed in execution hours. Social Fetch wins for production social data over REST. Do not replace one with the other — replace a misuse. If you are running Phantoms only to dump profile JSON into your app, you want an API. If you are wiring Social Fetch to send LinkedIn connection requests, you want an automation tool.
## When Social Fetch wins
- Backend features that need social JSON in the request thread
- Multi-platform product data under one REST schema
- Predictable per-lookup pricing without hour/slot math
## FAQ
### Does PhantomBuster offer an API?
Yes on paid plans, primarily to launch and manage automations. Social Fetch's API is the product: social resources as JSON, not Phantom runs.
### Which is cheaper for 50k profile lookups?
Social Fetch, almost always, because you pay per lookup. PhantomBuster cost depends on how long Phantoms run and which plan hours you burn — often higher for pure data extraction.
### Can I use both?
Yes. PhantomBuster for GTM automations; Social Fetch for application data. That split matches how most companies already organize teams.
---
# Social Fetch vs Phyllo (2026) — public data vs creator OAuth
Source: https://www.socialfetch.dev/compare/phyllo
# Social Fetch vs Phyllo
Phyllo is built for creator-economy products that need OAuth-backed, first-party metrics — earnings, Stories, audience demographics a public scrape cannot see. Social Fetch is built for public profile and post JSON without asking anyone to connect an account. Same words on a pricing comparison page; different jobs.
**Full comparison page:** https://www.socialfetch.dev/compare/phyllo
## At a glance
- **Primary data model** — Social Fetch: Public data — no creator login required; Phyllo: Authenticated (OAuth) + public APIs
- **Pricing** — Social Fetch: $1.65/1k published; 100 free credits; Phyllo: Custom quote (third parties cite ~$199/mo entry)
- **Getting started** — Social Fetch: Self-serve API key in minutes; Phyllo: Sales / quote; sandbox for development
- **Request shape** — Social Fetch: Sync REST — JSON in the same response; Phyllo: Public APIs often async (job + webhook/poll)
- **What only they can return** — Social Fetch: N/A — public surface only; Phyllo: Private metrics, earnings, Stories with consent
- **Catalog** — Social Fetch: 154 ops / 20 platforms; Phyllo: 20–25+ platforms marketed; suite is quote-scoped
## Pricing scenario
Phyllo's pricing page (getphyllo.com/pricing) does not list per-1k rates. Plans are customized; independent write-ups commonly cite roughly $199/month as an entry point that scales with API volume and connected creators. Social Fetch publishes credit packs on the website — Scale at $1.65 per 1,000 — with no sales call required. If your finance team needs a spreadsheet before engineering starts, that alone is a product difference.
- **List price for a TikTok profile:** Social Fetch — ~$0.00165; Phyllo — Not published — quote-based
- **75k public profile lookups/month:** Social Fetch — ~$124 one-time at Scale rate; Phyllo — Custom — often includes platform + connection fees
- **Minimum commitment:** Social Fetch — None on PAYG; Phyllo — Typical custom monthly plan
- **Private / consented metrics:** Social Fetch — Not available; Phyllo — Core product (OAuth Connect)
- **Free evaluation:** Social Fetch — 100 credits, no card; Phyllo — Sandbox / sales-enabled trial
_Phyllo pricing from getphyllo.com/pricing (July 2026) — quote-based, no public per-call table. Third-party reviews citing ~$199/mo are secondary sources; confirm with Phyllo sales before budgeting._
## Verdict
Phyllo wins when consented, private creator data is the product. Social Fetch wins when public social JSON at a published per-request price is the product. Comparing them on "social API" alone is how teams buy the wrong shape. Use Phyllo for OAuth-backed creator platforms. Use Social Fetch for public enrichment, monitoring, and app features that never ask a creator to connect.
## When Social Fetch wins
- Public profile/post lookups with no creator login in the flow
- Self-serve pricing you can model from a public page
- Sync REST inside user-facing requests
- Multi-platform public coverage (20 platforms) under one key without a sales cycle
## FAQ
### Can Social Fetch return Instagram Stories views or creator earnings?
No. Those require creator-authenticated access. Phyllo's Authenticated APIs are built for that. Social Fetch only returns public data.
### Does Phyllo publish per-request pricing?
Not on their public pricing page as of July 2026. Plans are customized. Social Fetch publishes credit pack rates including $1.65 per 1,000 at Scale.
### Is Phyllo a scraper?
Phyllo positions Authenticated APIs as platform OAuth, not scraping. Their Public APIs cover non-login public data and are closer to what Social Fetch does — still evaluate sync vs async and pricing separately.
### Can I use both?
Yes. Public discovery and enrichment on Social Fetch; Phyllo Connect after creators opt in for private metrics. Many creator platforms already split those stages across vendors.
### Which is cheaper?
For public lookups alone, Social Fetch is almost always cheaper to start because pricing is published and PAYG has no monthly floor. Phyllo may be cheaper or necessary once private consented data is required — that is a different line item, not a like-for-like rate card.
---
# Social Fetch vs Proxycurl (2026) — after the shutdown
Source: https://www.socialfetch.dev/compare/proxycurl
# Social Fetch vs Proxycurl
Proxycurl was the default LinkedIn enrichment API for many teams until it shut down in July 2025 after LinkedIn litigation. Traffic now points at Enrich Layer (and related successors). Social Fetch is a live multi-platform public social API — LinkedIn included, but not LinkedIn-only.
**Full comparison page:** https://www.socialfetch.dev/compare/proxycurl
## At a glance
- **Status (2026)** — Social Fetch: Live, actively maintained; Proxycurl: Proxycurl shut down July 2025; successor products exist
- **Core focus** — Social Fetch: Public social data across 20 platforms; Proxycurl: LinkedIn person/company enrichment (historically)
- **Entry pricing** — Social Fetch: 100 free credits; packs from $25; Proxycurl: Was credit-based; see Enrich Layer for current terms
- **LinkedIn** — Social Fetch: Structured profile & company routes; Proxycurl: Was deep LinkedIn enrichment; API now dark
- **Other networks** — Social Fetch: TikTok, Instagram, YouTube, Reddit, X, …; Proxycurl: Not the historical product center
- **Best fit today** — Social Fetch: Teams rebuilding after Proxycurl or starting fresh; Proxycurl: Enrich Layer if you want a like-for-like LinkedIn migration
## Pricing scenario
Proxycurl is no longer a buyable API. Nubela's goodbye post (July 2025) confirmed the shutdown after LinkedIn's lawsuit. Former customers were pointed toward successor options; Enrich Layer documents key/credit carryover for many Proxycurl users with a base URL change. Social Fetch is a separate vendor: self-serve credits from $25, Scale at $1.65/1k, LinkedIn plus 20 platforms under one key. Do not budget "Proxycurl rates" into a 2026 spreadsheet — those SKUs are gone.
- **Can I buy Proxycurl today?:** Social Fetch — N/A; Proxycurl — No — service shut down July 2025
- **LinkedIn profile JSON (live vendor):** Social Fetch — ~$0.00165 per standard lookup at Scale; Proxycurl — Enrich Layer / other LinkedIn APIs (separate pricing)
- **Multi-platform in one key:** Social Fetch — Yes — 154 operations; Proxycurl — Historically LinkedIn-centric
- **Free start on Social Fetch:** Social Fetch — 100 credits, no card; Proxycurl — N/A (Proxycurl)
- **Single-network shutdown risk:** Social Fetch — Spread across many platforms; Proxycurl — Realized — LinkedIn legal action ended the product
- **Migration effort from Proxycurl:** Social Fetch — Map person/company fields to SF LinkedIn routes; Proxycurl — Enrich Layer aims for wire-compatible migration
_Shutdown details from Nubela's Proxycurl goodbye post (July 2025) and public migration guides. Enrich Layer terms from enrichlayer.com docs. Social Fetch pricing from socialfetch.com (July 2026)._
## Verdict
Proxycurl is gone. Enrich Layer is the continuity bet for LinkedIn-only stacks. Social Fetch is the rebuild bet for teams that want public social JSON across many networks with self-serve credits. Choose based on migration pain versus roadmap breadth — not on nostalgic Proxycurl rate cards.
## When Social Fetch wins
- You are rebuilding and want a live vendor with published PAYG pricing
- You need LinkedIn plus other social networks under one key
- Official TypeScript SDK, playground, and requestId matter
- You want to reduce single-network vendor concentration risk
- Cold public enrichment without waiting on a LinkedIn-only successor sales motion
## FAQ
### Is Proxycurl still available?
No. The service shut down in July 2025. Treat any "Proxycurl pricing 2026" page that implies you can buy it as outdated.
### What is Enrich Layer?
A LinkedIn-focused successor path documented for many former Proxycurl customers (keys/credits/base URL). Evaluate it separately from Social Fetch.
### Does Social Fetch replace Proxycurl 1:1?
Not as a wire-compatible clone. Expect to remap LinkedIn person/company fields to Social Fetch routes and retest. You gain multi-platform coverage in exchange.
### Does Social Fetch offer LinkedIn people search like Proxycurl?
Check current LinkedIn routes in our API reference — coverage is profile/company oriented public data, not a promise of every historic Proxycurl search endpoint. Validate the exact operations you need.
### Why compare against a dead product?
Because search traffic still asks "Proxycurl alternative." This page answers with accurate shutdown context and a live multi-platform option — without pretending Proxycurl still sells credits.
---
# RapidAPI vs Social Fetch — TikTok Scraper, No Middleman
Source: https://www.socialfetch.dev/compare/rapidapi
# Social Fetch vs RapidAPI
RapidAPI is an app store for APIs: dozens of TikTok scrapers from different publishers, each with its own pricing, rate limits, response shape, and reliability record. Social Fetch is a first-party social data API with one key, one schema, one support team, and a requestId on every response.
**Full comparison page:** https://www.socialfetch.dev/compare/rapidapi
## At a glance
- **What you're buying** — Social Fetch: Direct API from the team that built it; RapidAPI: Access to third-party APIs via a marketplace
- **Per 1,000 requests (typical scraper)** — Social Fetch: $1.65 per 1,000 requests; RapidAPI: $2.50–$4.00+ per 1,000 (varies by API)
- **75k/mo multi-platform** — Social Fetch: ~$124 one-time; RapidAPI: $79–139/mo recurring (3+ subscriptions)
- **Rate limit (production tier)** — Social Fetch: No published per-minute cap; RapidAPI: 300 requests/minute on Pro
- **Adding Instagram + YouTube** — Social Fetch: Same API key, same balance; RapidAPI: Separate APIs, separate subscriptions
- **Response format** — Social Fetch: Same `{ data, meta }` envelope on every route; RapidAPI: Publisher-defined JSON; no shared contract
- **When a call fails in production** — Social Fetch: `meta.requestId` you paste to support; RapidAPI: Ticket with RapidAPI, who routes to the publisher
## Pricing scenario
RapidAPI's TikTok Scraper7 Pro tier ($59/mo) looks cheap in isolation. Real products rarely stop at TikTok. On the marketplace, Instagram means another listing, YouTube means another, and each one bills separately with its own rate limit, schema, and publisher who may change terms without warning. The subscription math is only half the invoice.
- **Per 1,000 requests (comparable scraper):** Social Fetch — $1.65 per 1,000; RapidAPI — $2.50–$4.00+ per 1,000 (marketplace APIs)
- **TikTok-only (75k/mo):** Social Fetch — ~$124 one-time; RapidAPI — $59/mo recurring (TikTok Scraper7 Pro only)
- **Adding 20k Instagram lookups:** Social Fetch — Same balance, same API key; RapidAPI — +$10–30/mo for a separate API subscription
- **Adding 5k YouTube lookups:** Social Fetch — Same balance, same API key; RapidAPI — +$10–50/mo for another API subscription
- **True multi-platform monthly cost:** Social Fetch — ~$124 one-time; RapidAPI — $79–139/mo+ recurring (multiple subscriptions)
- **Engineering cost (often ignored):** Social Fetch — One client, one error handler, one schema mapper; RapidAPI — Three integrations, three mappers, three failure modes
_RapidAPI pricing from TikTok Scraper7 listing (tikwm, July 2026). Instagram and YouTube costs from comparable marketplace APIs. All RapidAPI plans include bandwidth fees of $0.001/MB beyond 10GB._
## Verdict
RapidAPI is a useful place to prototype and compare third-party scrapers. It is a poor place to run load-bearing social data. Separate subscriptions per platform, inconsistent response shapes, publisher churn, and support tickets that bounce through a middleman add cost that never appears on the pricing page. Social Fetch is one first-party API with normalized schemas, a `{ data, meta }` envelope on every route, and a requestId your support team can actually use. Unless you are explicitly in the try-five-scrapers phase, the marketplace model breaks down the moment your product needs more than one platform or more than one reliable integration.
## When Social Fetch wins
- Multi-platform products where Instagram, YouTube, or LinkedIn sit beside TikTok
- Production code that needs the same JSON envelope and error codes on every route
- Teams tired of publisher churn, schema drift, and tickets routed through a middleman
- Debugging workflows that start with a requestId, not a guess about which listing broke
- Burst workloads without marketplace per-minute caps throttling live traffic
## FAQ
### Is RapidAPI cheaper than Social Fetch for TikTok?
TikTok-only on one marketplace API (e.g. Scraper7 Pro at $59/mo) can beat $1.65 per 1,000 on paper for huge monthly volume, but you are capped at 300 requests/minute and tied to one publisher. Most RapidAPI social scrapers list around $2.50–$4.00 per 1,000 requests. For multi-platform products, Social Fetch at $1.65 per 1,000 across every platform is usually cheaper and always simpler to operate.
### What are RapidAPI's rate limits?
TikTok Scraper7 limits: Basic 120/min, Pro 300/min, Ultra 1,200/min, Mega 2,000/min. Social Fetch has no request quotas on paid metered routes — credits are the only limit. Under extreme concurrency you may get 503 with Retry-After (not charged).
### Can one RapidAPI subscription cover TikTok, Instagram, and YouTube?
No. Each platform requires a separate API from a different publisher: separate subscription, separate authentication, separate response schema, separate reliability profile. Social Fetch covers all of these under one API key with normalized JSON responses.
### What if my RapidAPI provider shuts down?
This happens regularly on marketplaces. Publishers change pricing, deprecate endpoints, or abandon their APIs without notice. You find, evaluate, and integrate a replacement, then update every call site that depended on the old schema. With Social Fetch there is no middleman. We maintain the API directly and communicate breaking changes before they hit production.
### Does Social Fetch use a consistent response envelope?
Yes. Every route returns `{ data, meta }`. Success responses include `meta.requestId`, `meta.creditsCharged`, and `meta.version`. Errors follow the same top-level shape with typed codes. Marketplace APIs from different publishers each invent their own JSON structure, so multi-platform apps end up writing one adapter per listing.
### How does support differ?
Social Fetch support starts with a requestId from any response. We can trace the exact lookup. RapidAPI support often means identifying which publisher served a call and waiting for that publisher to respond through the marketplace. When production is down at 2am, that routing delay matters.
### Does Social Fetch require a monthly subscription?
No required subscription. Pay-as-you-go credit packs are one-time purchases that never expire. Optional monthly plans with included credits are available if you want predictable spend — cancel anytime. No penalty for months when you do not use the API on PAYG.
### Which has better developer tooling?
Social Fetch provides a complete OpenAPI specification, an official TypeScript SDK with full type coverage, and an interactive browser playground built against our own routes. RapidAPI offers auto-generated docs and a basic test console, but quality varies by publisher. Some listings have thorough examples; others stop at parameter names.
### Is there a TikTok scraper on RapidAPI, and how does it compare?
Yes — several, the most-cited being Scraper7 (tikwm). It's a single-publisher listing scoped to TikTok only: separate pricing, separate rate limits, separate schema from any Instagram or YouTube listing you'd add later. Social Fetch covers TikTok under the same API key, schema, and rate posture as every other platform.
### What does RapidAPI actually cost for TikTok scraping?
It depends on the listing and tier — Scraper7 runs Basic $10/Pro $59/Ultra/Mega up to $2,000/mo-equivalent tiers, plus bandwidth fees past 10GB. Social Fetch is one flat rate, $1.65 per 1,000 requests, across every platform, with no bandwidth surcharge.
---
# Social Fetch vs Scrape.do (2026) — scraping API vs social API
Source: https://www.socialfetch.dev/compare/scrape-do
# Social Fetch vs Scrape.do
Scrape.do (scrape.do) sells a general web scraping API: datacenter or residential proxies, JS rendering, geo targeting, pay only for successful responses. Social Fetch sells structured public social data. Cheap HTML credits are not the same product as a TikTok profile object.
**Full comparison page:** https://www.socialfetch.dev/compare/scrape-do
## At a glance
- **Product** — Social Fetch: Social data REST API; Scrape.do: Web scraping API (HTML/JSON/XML/markdown from URLs)
- **Billing** — Social Fetch: PAYG packs; $1.65/1k at Scale; Scrape.do: Monthly credits from $29 (Hobby) — success-based
- **Credit multipliers** — Social Fetch: Mostly 1 credit per standard lookup; Scrape.do: 1 / 5 / 10 / 25 by proxy + render; special domains higher
- **LinkedIn special cost** — Social Fetch: Standard social credit (see docs per route); Scrape.do: 30 credits per successful LinkedIn request (docs)
- **You maintain parsers?** — Social Fetch: No — normalized fields; Scrape.do: Yes — unless using a site-specific scraper add-on
- **Best fit** — Social Fetch: App features needing social entities; Scrape.do: High-volume general scraping with WAF bypass
## Pricing scenario
Scrape.do plans (July 2026): Free 1,000 credits/mo; Hobby $29 (250k); Pro $99 (1.25M); Business $249 (3.5M); Advanced $699 (10M). Base costs: 1 credit datacenter, 5 with JS render, 10 residential/mobile (super), 25 residential+JS. Some domains override — Google 10, LinkedIn 30, others listed in docs. Social Fetch Scale remains $1.65/1k for completed standard social lookups.
- **Free tier:** Social Fetch — 100 credits, no monthly clawback; Scrape.do — 1,000 successful credits/month, full features
- **Hobby plan:** Social Fetch — N/A — buy packs as needed; Scrape.do — $29/mo · 250k credits · ~$0.11/1k credits
- **1,000 datacenter fetches (Hobby):** Social Fetch — N/A; Scrape.do — ~$0.11
- **1,000 residential+JS fetches (25 credits):** Social Fetch — N/A; Scrape.do — ~$2.90 on Hobby credit math
- **1,000 LinkedIn pages (30 credits):** Social Fetch — ~$1.65 structured (LinkedIn routes); Scrape.do — ~$3.48 on Hobby + your parsing
- **1,000 structured multi-platform profiles:** Social Fetch — ~$1.65; Scrape.do — Scrape + parse + keep selectors alive
_Scrape.do pricing from scrape.do/pricing; credit table and domain overrides from scrape.do/documentation/request-costs/ (July 2026). Only successful responses consume credits. Confirm LinkedIn and other specials before estimating social workloads._
## Verdict
Scrape.do is a strong general scraping API with sharp success-based credit pricing. Social Fetch is a social data API with flat lookup pricing and maintained schemas. Use Scrape.do for the open web. Use Social Fetch when the unit of work is a social entity. Mixing them by URL class is normal; replacing one with the other end-to-end usually is not.
## When Social Fetch wins
- You need normalized social profiles and posts, not HTML
- LinkedIn/Instagram/TikTok entity lookups should not burn 25–30 scrape credits each
- MCP or Agent Skills should call social tools without inventing selectors
- PAYG social credits without a monthly scrape subscription fit product traffic
- Support with requestId on social routes beats debugging selectors alone
## FAQ
### Is Scrape.do cheaper than Social Fetch for social media?
Base datacenter credits are much cheaper per page than Social Fetch per lookup. Social pages often need residential+JS (25 credits) or LinkedIn's 30-credit special — and you still parse. Structured Social Fetch lookups at $1.65/1k are usually cheaper fully loaded for production social features.
### Is the slug scrape-do the same as scrape.do?
Yes. The product site is scrape.do; our compare slug is scrape-do for URL safety.
### Does Scrape.do return TikTok profile JSON?
It returns whatever the URL response contains (HTML or configured output). Structured TikTok profile schemas are Social Fetch's product, not a Scrape.do default.
### What happens when Scrape.do credits run out?
Requests stop until you upgrade or buy more credits (per their FAQ). Social Fetch PAYG: buy another pack; optional plans available for steady volume.
### Can I use Scrape.do and Social Fetch together?
Yes. Route social entity reads to Social Fetch and everything else to Scrape.do. That split matches how most teams already think about URL classes.
### Do you only charge for success like Scrape.do?
We charge for completed lookups, including not_found. We do not charge lookup_failed or 503 temporarily_unavailable. Different definition of "success" than HTTP scrape success.
---
# Social Fetch vs ScrapeCreators (2026) — PAYG social API
Source: https://www.socialfetch.dev/compare/scrapecreators
# Social Fetch vs ScrapeCreators
ScrapeCreators and Social Fetch are close peers: social-focused REST APIs, prepaid credits that never expire, no required monthly subscription. The decision is unit price at your volume, how consistent the response contract is, and whether you want a first-party TypeScript SDK and meta.requestId on every call.
**Full comparison page:** https://www.socialfetch.dev/compare/scrapecreators
## At a glance
- **What you're comparing** — Social Fetch: Direct social REST API; ScrapeCreators: Direct social REST API
- **Billing model** — Social Fetch: PAYG packs never expire; optional monthly plans; ScrapeCreators: PAYG packs never expire; no subscription required
- **Best published $/1k** — Social Fetch: $1.65 (Scale pack); ScrapeCreators: $0.99 (Large / Mid volume packs)
- **Entry paid pack** — Social Fetch: $25 / 10k credits ($2.50/1k); ScrapeCreators: $47 / 25k credits ($1.88/1k)
- **Free start** — Social Fetch: 100 credits, no card; ScrapeCreators: 100 credits, no card
- **Catalog** — Social Fetch: 154 ops / 20 platforms, normalized envelope; ScrapeCreators: 36+ APIs / 20+ platforms claimed; mostly 1 credit/call
## Pricing scenario
ScrapeCreators prices one-time packs on scrapecreators.com: Freelance $47 for 25,000 credits ($1.88/1k), larger packs down to about $0.99/1k (e.g. $497 for 500,000). Most endpoints are 1 credit; docs list specialty routes higher (audience demographics can be tens of credits). Social Fetch Scale is $379 for 230,000 credits ($1.65/1k); Starter is $25 for 10,000 ($2.50/1k). Both advertise credits that never expire and 100 free credits to start.
- **Standard profile lookup:** Social Fetch — ~$0.00165 (1 credit at Scale); ScrapeCreators — ~$0.00099–$0.00188 (1 credit, pack-dependent)
- **25,000 standard lookups:** Social Fetch — ~$41 at Scale rate; ScrapeCreators — $47 (Freelance pack)
- **230,000 standard lookups:** Social Fetch — $379 (Scale pack); ScrapeCreators — ~$228 at $0.99/1k if you buy Large-style packs
- **Credits expire?:** Social Fetch — No — PAYG packs never expire; ScrapeCreators — No — packs never expire
- **Required subscription?:** Social Fetch — No; ScrapeCreators — No
- **Specialty / demographics routes:** Social Fetch — Documented multi-credit routes in API reference; ScrapeCreators — Some endpoints cost far more than 1 credit
_ScrapeCreators pricing from scrapecreators.com (July 2026). Per-1k rates assume 1 credit per call; check docs.scrapecreators.com for multi-credit endpoints before budgeting._
## Verdict
ScrapeCreators and Social Fetch both sell non-expiring credits for social JSON. ScrapeCreators often wins pure high-volume $/1k. Social Fetch wins when envelope consistency, SDK, playground, and support breadcrumbs matter as much as the rate card. Run both free tiers on your real endpoints before you commit a pack.
## When Social Fetch wins
- You want a normalized data + meta envelope and requestId on every call
- Official TypeScript SDK and interactive playground
- Lower entry pack ($25) and optional monthly plans alongside PAYG
- Consistent single-credit pricing mental model across standard routes
- 154 documented operations with OpenAPI-first tooling
## FAQ
### Is ScrapeCreators cheaper than Social Fetch?
At large pack sizes, ScrapeCreators publishes rates near $0.99/1k vs Social Fetch Scale at $1.65/1k — so yes on sticker price for simple 1-credit calls. At small packs and once multi-credit specialty routes enter the mix, totals often converge. Compare your exact endpoint mix.
### Do both offer free credits?
Yes. Both advertise 100 free credits with no credit card. Use that to hit the same handles on both APIs and compare latency, fields, and failure modes.
### Do ScrapeCreators credits expire?
No — packs are marketed as never expiring, same idea as Social Fetch PAYG packs.
### Does ScrapeCreators have a TypeScript SDK?
Their public positioning is REST + docs. Social Fetch ships an official TypeScript SDK and playground. If generated clients matter, that gap is real.
### Can I use both?
Yes. Some teams keep ScrapeCreators for a niche route and Social Fetch for the multi-platform product surface. Prefer one vendor for the hot path so billing and status codes stay predictable.
---
# Social Fetch vs ScraperAPI (2026) — social JSON vs HTML
Source: https://www.socialfetch.dev/compare/scraperapi
# Social Fetch vs ScraperAPI
ScraperAPI is a scraping infrastructure API — send a URL, get HTML (or parsed JSON helpers) through rotating proxies, JS rendering, and anti-bot handling. Social Fetch is a social data API — send a handle, get normalized profile fields. LinkedIn on ScraperAPI can cost 30 credits per request; on Social Fetch it is a first-class route at flat social pricing.
**Full comparison page:** https://www.socialfetch.dev/compare/scraperapi
## At a glance
- **What returns** — Social Fetch: Structured social JSON; ScraperAPI: HTML (plus optional parsing) via proxies
- **Pricing entry** — Social Fetch: 100 free credits; packs from $25; ScraperAPI: Hobby $49/mo for 100,000 credits
- **LinkedIn request cost** — Social Fetch: Standard social credit (typically 1); ScraperAPI: 30 credits per their domain guide
- **Google / Bing SERP** — Social Fetch: Limited Google utilities — not a SERP farm; ScraperAPI: 25 credits per request (domain guide)
- **Who maintains social parsers** — Social Fetch: Social Fetch; ScraperAPI: You (or their structured add-ons where available)
- **Social catalog** — Social Fetch: 154 ops / 20 platforms; ScraperAPI: Any URL — credits vary by domain difficulty
## Pricing scenario
ScraperAPI Hobby is $49/month for 100,000 credits (Startup $149 / 1M, Business $299 / 3M). A standard page is 1 credit, but LinkedIn is 30, Google/Bing 25, Amazon 5, and bot-protection bypass adds 10 — per their pricing FAQ. Credits reset monthly; unused do not roll. Social Fetch does not sell proxy HTML for arbitrary domains; standard social lookups are one credit at $1.65/1k on packs that never expire.
- **1,000 LinkedIn profile pages (raw HTML path):** Social Fetch — ~$1.65 as API lookups (structured); ScraperAPI — 30,000 credits → burns a large share of Hobby
- **1,000 generic easy pages:** Social Fetch — Use a scrape vendor — not our job; ScraperAPI — 1,000 credits on Hobby
- **Monthly reset:** Social Fetch — No on PAYG packs; ScraperAPI — Yes — unused credits expire each cycle
- **JS rendering / proxies:** Social Fetch — Handled upstream for social routes; ScraperAPI — Included — that is the product
- **Free trial:** Social Fetch — 100 credits, no card; ScraperAPI — 7-day trial with 5,000 credits (no card)
_ScraperAPI pricing from scraperapi.com/pricing (July 2026). Domain credit costs from their FAQ (LinkedIn 30, Google/Bing 25, Amazon 5, anti-bot +10). Always verify with their Domain Cost Estimator for your URLs._
## Verdict
ScraperAPI is a strong proxy scrape API. Social Fetch is a strong social data API. Domain credit multipliers make ScraperAPI expensive precisely where social platforms are hardest — which is where a vertical social API earns its keep. Use ScraperAPI for the open web; use Social Fetch when the resource is a social entity.
## When Social Fetch wins
- Structured social profiles and posts without HTML parsing
- LinkedIn/social workloads where domain multipliers hurt
- PAYG credits that never expire for bursty social traffic
- One normalized envelope across social networks
## FAQ
### Can ScraperAPI scrape Instagram for me?
It can fetch URLs through proxies. You still parse HTML and absorb domain/anti-bot credit costs. Social Fetch returns structured Instagram resources on maintained routes.
### Why is LinkedIn 30 credits on ScraperAPI?
Harder anti-bot domains cost more credits on their price list. That is expected for a general scrape API. A social API absorbs that complexity into a flat social credit where possible.
### Do ScraperAPI credits roll over?
No — monthly plan credits reset. Social Fetch PAYG packs never expire.
### Which should startups pick first?
If the feature is social data in the product, Social Fetch. If the feature is scraping many non-social sites, ScraperAPI. Startups often need both later; start with the dominant URL class.
---
# Social Fetch vs Scrapfly (2026) — scrape API vs social API
Source: https://www.socialfetch.dev/compare/scrapfly
# Social Fetch vs Scrapfly
Scrapfly is a developer-focused scraping platform: scrape API, cloud browser, screenshots, and extraction helpers on one credit balance. Social Fetch is a social data API. Both speak HTTP; only one ships TikTok and Instagram as productized endpoints.
**Full comparison page:** https://www.socialfetch.dev/compare/scrapfly
## At a glance
- **Core product** — Social Fetch: Social media data API; Scrapfly: Web scraping API + browser + screenshot + extraction
- **Billing** — Social Fetch: PAYG packs; Scale $1.65/1k; Scrapfly: Monthly plans from $30 (Discovery) with credit costs per feature
- **Base scrape cost** — Social Fetch: 1 credit per completed standard social lookup; Scrapfly: 1 credit datacenter; 25 residential; +5 JS; ASP may upgrade cost
- **Social endpoints** — Social Fetch: 154 ops / 20 platforms; Scrapfly: Any URL — you define extraction
- **Overflow** — Social Fetch: Buy another pack; Scrapfly: Pro+ can pay-as-you-go extra credits in 10k batches
- **Best fit** — Social Fetch: Production social features in your app; Scrapfly: Building and operating custom scrapers with managed anti-bot
## Pricing scenario
Scrapfly plans (July 2026): Free 1,000 credits; Discovery $30/mo (200k); Pro $100/mo (1M); Startup $250/mo (2.5M); Enterprise $500/mo (5.5M). Per-request cost stacks features: datacenter base 1 credit, residential 25, browser rendering +5, with ASP able to raise the final bill. A residential + JS social page can cost 30 credits — 30× a bare datacenter fetch. Social Fetch keeps standard profile lookups at one credit.
- **Free tier:** Social Fetch — 100 credits, no expiry; Scrapfly — 1,000 credits, no card, no time limit
- **Entry paid plan:** Social Fetch — $25 PAYG pack (10k); Scrapfly — $30/mo Discovery (200k credits)
- **Datacenter HTML fetch:** Social Fetch — N/A; Scrapfly — 1 credit (~$0.15/1k on Discovery prepaid math)
- **Residential + JS page (30 credits):** Social Fetch — N/A; Scrapfly — ~$4.50/1k pages on Discovery credit math
- **1,000 structured social profiles:** Social Fetch — ~$1.65; Scrapfly — Variable scrape cost + your schema layer
- **Failed requests:** Social Fetch — lookup_failed / 503 not charged; Scrapfly — Documented as free on failed scrapes
_Scrapfly pricing from scrapfly.io/pricing and scrapfly.io/docs/scrape-api/billing (July 2026). Credit matrix: datacenter 1, residential 25, render_js +5; ASP may change effective cost. Extra credits billed per 10k on eligible plans._
## Verdict
Scrapfly gives developers levers: proxies, rendering, ASP, cost headers. Social Fetch removes those levers for social data and returns a stable JSON contract instead. If you love operating scrapers, Scrapfly fits. If you want creator and post objects in production, Social Fetch fits. Many teams should use both for different URL classes.
## When Social Fetch wins
- Social profiles and posts are application inputs, not HTML science projects
- You would rather we absorb platform breakage than page your on-call
- Predictable per-lookup pricing without residential credit multipliers
- PAYG social credits beat another monthly scraper subscription for spiky product traffic
- Stable fields matter more than scrape knobs and cost headers
## FAQ
### Is Scrapfly cheaper than Social Fetch?
For simple datacenter HTML, Scrapfly's 1-credit fetches can be far cheaper per page. For social pages that need residential + JS (often ~30 credits), Scrapfly can exceed Social Fetch's $1.65/1k before parsing. Compare the configuration you actually need, not the marketing "credits included" number.
### Does Scrapfly have TikTok or Instagram APIs?
You can scrape those sites as URLs. Scrapfly does not replace a social-native endpoint catalog with normalized profile schemas like Social Fetch.
### Does Social Fetch expose scrape cost headers?
No. You see credit debits on completed lookups in our billing model. We do not bill by proxy type or render flags because you do not select them.
### Can Scrapfly PAYG replace Social Fetch packs?
Scrapfly's extra-credit PAYG is overflow on top of a monthly plan (Pro+). Social Fetch PAYG packs are the primary path and never expire. Different idea of "pay as you go."
### Which should AI agents use?
Agents that need arbitrary page content lean Scrapfly (or similar). Agents that need structured social entities lean Social Fetch — fewer tokens spent on HTML and fewer broken selectors.
### Do you compete on web markdown fetch?
Social Fetch includes web fetch routes for URL-to-content jobs in the same product, but our primary wedge is social platforms. Scrapfly goes deeper on anti-bot scrape controls for hard general web targets.
---
# Social Fetch vs ScrapingBee (2026) — HTML API vs social JSON
Source: https://www.socialfetch.dev/compare/scrapingbee
# Social Fetch vs ScrapingBee
ScrapingBee fetches any URL through rotating proxies and optional headless Chrome, then returns HTML (or extracted snippets). Social Fetch fetches public social entities and returns normalized JSON. If your ticket says "get this creator's follower count," you are comparing a page scraper to a social API.
**Full comparison page:** https://www.socialfetch.dev/compare/scrapingbee
## At a glance
- **Product shape** — Social Fetch: Social REST API (profiles, posts, comments…); ScrapingBee: Web scraping API (HTML, screenshots, Google Search API)
- **Default billing unit** — Social Fetch: 1 credit ≈ 1 completed standard lookup; ScrapingBee: API credits (JS rendering alone is 5 credits by default)
- **Entry paid plan** — Social Fetch: $25 Starter pack (10k credits, never expire); ScrapingBee: $49/mo Freelance (250k credits, monthly)
- **Effective cost for JS pages** — Social Fetch: N/A — structured social routes; ScrapingBee: ~$0.98/1k pages on Freelance if every call costs 5 credits
- **Social schema** — Social Fetch: Documented fields across platforms; ScrapingBee: You parse HTML or write extraction rules
- **Best fit** — Social Fetch: App features powered by social data; ScrapingBee: General website scraping with proxy + browser handling
## Pricing scenario
ScrapingBee sells monthly subscriptions: Freelance $49/mo (250k credits, 50 concurrent), Startup $99/mo (1M), Business $249/mo (3M), Business+ $599/mo (8M). JavaScript rendering is on by default and costs 5 credits per request; premium or stealth proxies cost more (docs list paths up to 75 credits). Unused monthly credits do not roll over. Social Fetch Scale is $379 for 230k credits that never expire on PAYG packs.
- **Free start:** Social Fetch — 100 credits, no card, no expiry; ScrapingBee — 1,000 API credits trial, no card
- **Cheapest paid tier:** Social Fetch — $25 for 10k credits (PAYG); ScrapingBee — $49/mo for 250k credits
- **1,000 JS-rendered page fetches (Freelance math):** Social Fetch — N/A; ScrapingBee — ~$0.98 (5 credits × 1,000 ÷ 250k × $49)
- **1,000 structured social profiles:** Social Fetch — ~$1.65; ScrapingBee — Scrape cost + your parsers + monthly plan floor
- **Credits roll over?:** Social Fetch — Yes — PAYG packs never expire; ScrapingBee — No — monthly allotment resets
- **Stealth / hard anti-bot modes:** Social Fetch — Handled upstream on our social routes; ScrapingBee — Available; can cost tens of credits per request
_ScrapingBee pricing from scrapingbee.com/pricing and help.scrapingbee.com plan articles (July 2026). Credit multipliers from ScrapingBee docs (JS default 5 credits; premium/stealth higher). Confirm current multipliers before budgeting._
## Verdict
ScrapingBee is a solid headless scraping API. Social Fetch is a solid social data API. Comparing them on raw "$/1k credits" misses the product boundary: one returns pages, the other returns social objects. Use ScrapingBee for the open web. Use Social Fetch when the object you need is a creator, post, or comment thread.
## When Social Fetch wins
- You want PAYG credits that never expire instead of a monthly scrape allotment
- Product UX needs JSON in the same HTTP response, not HTML to parse
- JS/premium multipliers make DIY social pages expensive relative to flat lookups
- Finance can budget from lookup count without a credit-mode spreadsheet
- Social enrichment is recurring product traffic, not a one-off crawl
## FAQ
### Is ScrapingBee cheaper for Instagram profiles?
A simple JS-rendered fetch on Freelance can land under $1 per 1,000 pages on paper. That number excludes your parser maintenance, retries when markup changes, and higher credit modes for hard pages. Social Fetch at $1.65/1k returns structured profile JSON. For production social features, fully loaded cost usually favors Social Fetch.
### Does Social Fetch render JavaScript like ScrapingBee?
You do not configure rendering. We return structured data from our social extraction layer. If you need raw HTML from an arbitrary URL, use ScrapingBee or our separate web fetch routes where they fit — not as a substitute for social profile endpoints.
### Do ScrapingBee credits expire?
Monthly plan credits are tied to the billing period and do not roll over. Social Fetch pay-as-you-go pack credits never expire. Subscription included credits on Social Fetch monthly plans reset each period like other SaaS allotments.
### Can I use both?
Yes. Common pattern: ScrapingBee for general websites and SERP-style jobs, Social Fetch for TikTok/Instagram/YouTube/LinkedIn entity lookups inside the product.
### Does ScrapingBee offer a social media API?
ScrapingBee is positioned as a web scraping API with browser and proxy features. Social coverage is "scrape the page," not a catalog of normalized social endpoints.
### What does Social Fetch charge for failed lookups?
Completed lookups that return not_found still consume a credit (we ran the upstream check). lookup_failed and 503 temporarily_unavailable are not charged.
---
# Social Fetch vs ScrapingDog (2026) — scrape API vs social API
Source: https://www.socialfetch.dev/compare/scrapingdog
# Social Fetch vs ScrapingDog
ScrapingDog is a credit-based web scraping and SERP API — HTML fetches, Google endpoints, and a growing set of site-specific scrapers. Social Fetch is a social data API. Overlap exists on TikTok/YouTube-style routes; the core products still solve different tickets.
**Full comparison page:** https://www.socialfetch.dev/compare/scrapingdog
## At a glance
- **Product shape** — Social Fetch: Social REST API; ScrapingDog: Web scraping + SERP + site scrapers
- **Billing** — Social Fetch: 1 credit ≈ 1 standard social lookup; ScrapingDog: Monthly credits; 1–25+ per request by feature
- **Entry paid plan** — Social Fetch: $25 Starter pack (never expire); ScrapingDog: $40/mo Lite (200k credits)
- **Google / SERP** — Social Fetch: Limited Google utility routes; ScrapingDog: Dedicated Google Search, Maps, Shopping, etc.
- **Social schema** — Social Fetch: Normalized fields + meta envelope; ScrapingDog: HTML or scraper-specific JSON; credit cost varies
- **Best fit** — Social Fetch: Product features on social entities; ScrapingDog: SERP + general scraping with social add-ons
## Pricing scenario
ScrapingDog's public pricing ladder starts at Lite $40/mo for 200,000 credits (5 concurrent), then Standard $90/mo (1M), Pro $200/mo (3M), and a long enterprise ladder. Free accounts get a small monthly credit allotment. Docs list web scrapes at 1–25 credits depending on JS/premium flags; Google Search at 5; several social scrapers at 5+; profile scrapers up to 10–100. Social Fetch Scale is $379 for 230k non-expiring credits at $1.65/1k for standard social lookups.
- **Free start:** Social Fetch — 100 credits, no card, no expiry; ScrapingDog — Small free monthly credit allotment
- **Cheapest paid tier:** Social Fetch — $25 for 10k credits (PAYG); ScrapingDog — $40/mo for 200k credits
- **1,000 basic HTML fetches (1 credit):** Social Fetch — N/A; ScrapingDog — ~$0.20 on Lite (1k ÷ 200k × $40)
- **1,000 JS+premium fetches (25 credits):** Social Fetch — N/A; ScrapingDog — ~$5.00 on Lite math
- **1,000 structured social profiles:** Social Fetch — ~$1.65; ScrapingDog — Depends on endpoint credits + monthly floor
- **Credits roll over?:** Social Fetch — Yes — PAYG packs never expire; ScrapingDog — Monthly plans reset; PAYG option exists separately
_ScrapingDog pricing from scrapingdog.com/pricing and docs.scrapingdog.com (July 2026). Credit costs per API from their docs table. Confirm current multipliers and PAYG terms before budgeting._
## Verdict
ScrapingDog is a competitive scrape-and-SERP API with social add-ons. Social Fetch is a social data API that does not pretend to be Google Search. Use ScrapingDog for SERPs and general pages. Use Social Fetch when the object you need is a social entity with a stable schema.
## When Social Fetch wins
- You want plain-English routing to social operations via Ask
- Normalized social profiles/posts are a product feature
- Flat credits without 5–25× scrape multipliers
- Support needs requestId-level breadcrumbs on social routes
- SERP stays on ScrapingDog; social entities move to a social API
## FAQ
### Does ScrapingDog replace a social API?
Only if you are comfortable owning parsers and credit multipliers for social pages. For production creator/profile features, a social-native API is usually the cleaner contract.
### Is ScrapingDog cheaper?
For basic HTML and some SERP workloads, monthly credit math can land under $1/1k. For premium/JS/social scraper routes, effective cost rises fast. Compare against Social Fetch's $1.65/1k for structured social JSON, not against raw HTML CPM.
### Do ScrapingDog credits expire?
Monthly plan credits are tied to the billing period. ScrapingDog also advertises a PAYG option; confirm current expiry rules on their pricing page. Social Fetch PAYG packs never expire.
### Can I use both?
Yes. ScrapingDog for Google/SERP and open-web scrapes; Social Fetch for TikTok, Instagram, YouTube, LinkedIn, and other social entity lookups.
### Does Social Fetch offer a Google Search API?
We offer limited Google utility routes in the catalog, not a full SerpApi-style engine suite. For broad SERP coverage, ScrapingDog or a dedicated SERP vendor fits better.
---
# Social Fetch vs SerpApi (2026) — SERP API vs social API
Source: https://www.socialfetch.dev/compare/serpapi
# Social Fetch vs SerpApi
SerpApi returns structured search engine results (Google and 80+ engines). Social Fetch returns structured social entities. Teams sometimes compare them because both deliver JSON over HTTP — that is where the similarity ends.
**Full comparison page:** https://www.socialfetch.dev/compare/serpapi
## At a glance
- **Product shape** — Social Fetch: Social media data API; SerpApi: Search engine results API (80+ engines)
- **Primary output** — Social Fetch: Profiles, posts, comments, transcripts…; SerpApi: Organic results, ads, knowledge panels, etc.
- **Entry paid plan** — Social Fetch: $25 for 10k social credits (PAYG); SerpApi: $25/mo for 1,000 searches (Starter)
- **Billing model** — Social Fetch: Prepaid credits; packs never expire; SerpApi: Monthly search quota (no rollover on standard plans)
- **Platforms / engines** — Social Fetch: 20 social platforms; SerpApi: Google, Bing, Baidu, Yahoo, and many more
- **Best fit** — Social Fetch: Social enrichment and monitoring in apps; SerpApi: SEO, SERP tracking, search-powered features
## Pricing scenario
SerpApi's public plans (serpapi.com/pricing) include Free (~250 searches/mo), Starter $25/mo (1,000), Developer $75/mo (5,000), Production $150/mo (15,000), Big Data $275/mo (30,000), with larger and Enterprise tiers above that. Searches are successful search credits on a monthly allotment — unused searches typically do not roll over. Social Fetch Scale is $379 for 230k social credits that never expire; standard social lookups are $1.65/1k. These are not interchangeable units.
- **Free tier:** Social Fetch — 100 credits, no expiry; SerpApi — ~250 searches/month
- **$25 entry:** Social Fetch — 10,000 social credits (PAYG, no expiry); SerpApi — 1,000 searches that month
- **5,000 units:** Social Fetch — ~$8.25 at Scale rate (social lookups); SerpApi — $75/mo Developer plan (searches)
- **Unused quota:** Social Fetch — Stays on PAYG balance forever; SerpApi — Resets with the billing month
- **TikTok profile JSON:** Social Fetch — First-class route; SerpApi — Only if it appears in a SERP you parse
- **Google organic results JSON:** Social Fetch — Not our product center; SerpApi — Core product
_SerpApi pricing from serpapi.com/pricing and SerpApi plan docs (July 2026). Confirm current free-tier search counts and Enterprise on-demand rates before budgeting._
## Verdict
SerpApi and Social Fetch both return JSON and both start near $25 — that is the end of the useful overlap. Buy SerpApi for SERPs. Buy Social Fetch for social entities. Using Google results as a substitute for a TikTok profile API is a prototype trick, not a production architecture.
## When Social Fetch wins
- You need social profiles, posts, comments, or transcripts
- PAYG social credits beat monthly SERP seats for your traffic shape
- Multi-platform social coverage (20 platforms)
- Product UX hydrates creators/brands, not search rankings
## FAQ
### Can SerpApi get Instagram follower counts?
Only indirectly if a search result happens to expose them. SerpApi is not a social profile API. Use Social Fetch (or another social vendor) for follower fields.
### Can Social Fetch replace SerpApi for SEO?
No. We are not a multi-engine SERP provider. Use SerpApi or a SERP specialist for rankings and search features.
### Which is cheaper?
For searches, compare SerpApi to other SERP vendors. For social lookups, compare Social Fetch to other social APIs. Cross-category $/1k comparisons are meaningless.
### Do SerpApi searches roll over?
Standard monthly plans generally do not roll unused searches. Social Fetch PAYG pack credits never expire.
### Can I use both?
Yes — and many products should. SerpApi for search monitoring; Social Fetch for social graph entities inside the same app.
---
# Social Fetch vs SociaVault (2026) — PAYG social API pricing
Source: https://www.socialfetch.dev/compare/sociavault
# Social Fetch vs SociaVault
SociaVault and Social Fetch sit in the same product lane: direct REST APIs for public social data, prepaid credits that never expire, no required subscription. The split is unit economics at production volume, how consistent the response contract is across platforms, and whether you want a TypeScript SDK and requestId on every call.
**Full comparison page:** https://www.socialfetch.dev/compare/sociavault
## At a glance
- **What you're comparing** — Social Fetch: Direct social REST API; SociaVault: Direct social REST API
- **Billing model** — Social Fetch: PAYG packs never expire; optional monthly plans; SociaVault: PAYG packs never expire; no subscription required
- **Per 1,000 credits (best published pack)** — Social Fetch: $1.65 (Scale pack); SociaVault: $2.00 (Enterprise pack) / $2.65 (Pro pack)
- **75k lookups** — Social Fetch: ~$124 one-time at Scale rate; SociaVault: $199 one-time (Pro pack, exactly 75k)
- **Free trial** — Social Fetch: 100 credits, no card, no expiration; SociaVault: 50 credits, no card, no expiration
- **Catalog shape** — Social Fetch: 154 ops / 20 platforms, normalized envelope; SociaVault: 25+ platforms claimed; credit cost varies by endpoint complexity
## Pricing scenario
SociaVault prices one-time packs on sociavault.com/pricing: Starter $29 / 6,000 credits ($4.83/1k), Growth $79 / 20,000 ($3.95/1k), Pro $199 / 75,000 ($2.65/1k), Enterprise $399 / 200,000 ($2.00/1k). Social Fetch's Scale pack is $379 / 230,000 ($1.65/1k). Both say credits never expire. SociaVault's marketing says most endpoints are 1 credit; their docs also list moderate calls at 5–10 credits and complex analytics at 20+. Model the endpoints you actually call.
- **Single standard profile lookup:** Social Fetch — ~$0.00165 (1 credit); SociaVault — ~$0.0020–$0.0048 (1 credit, pack-dependent)
- **75,000 standard lookups:** Social Fetch — ~$124 at Scale rate; SociaVault — $199 (Pro pack)
- **200,000 standard lookups:** Social Fetch — ~$330 at Scale rate; SociaVault — $399 (Enterprise pack)
- **Unused credits expire?:** Social Fetch — No — PAYG packs never expire; SociaVault — No — packs never expire
- **Required monthly subscription?:** Social Fetch — No; SociaVault — No
- **Heavier endpoints (comments, analytics):** Social Fetch — Documented multi-credit routes in API reference; SociaVault — Docs list 5–10+ credits for moderate/complex calls
_SociaVault pricing from sociavault.com/pricing and docs.sociavault.com (July 2026). Per-credit rates assume one credit per call; check endpoint docs before budgeting analytics or bulk extraction routes._
## Verdict
SociaVault is a legitimate PAYG social API peer: non-expiring credits, self-serve signup, broad platform claims. Social Fetch is cheaper at every serious pack tier we compared, ships a normalized envelope and TypeScript SDK, and documents multi-credit routes instead of burying them. Stay on SociaVault if you need their niche endpoints. Switch when the invoice is mostly standard profile and post lookups — that is the job our Scale pack is priced for.
## When Social Fetch wins
- Production volume where $1.65/1k undercuts SociaVault's $2.00–$2.65 pack rates
- Teams that want one { data, meta } envelope and a requestId on every response
- TypeScript SDK + hosted OpenAPI as first-class integration surface
- Standard profile/post/search workloads where one credit means one credit
## FAQ
### Is SociaVault cheaper than Social Fetch?
At published packs, usually no for standard one-credit lookups. SociaVault Pro is $2.65 per 1,000 credits; Enterprise is $2.00 per 1,000. Social Fetch Scale is $1.65 per 1,000. SociaVault can win if you only need a small Starter pack for a short project, or if a multi-credit Social Fetch specialty route outweighs their pack rate for your mix.
### Do both APIs expire unused credits?
No. Both sell prepaid packs that never expire. That is the main reason they feel similar in procurement conversations.
### Which covers more platforms?
SociaVault markets 25+ platforms and niche tools (shops, Linktree-style pages, extra ad libraries). Social Fetch documents 20 marketplace platforms and 154 operations in OpenAPI. Breadth of logos is not the same as depth on TikTok, Instagram, LinkedIn, and Facebook — check the routes you actually call.
### Does SociaVault have a TypeScript SDK?
No official SDK we could find comparable to Social Fetch's. They provide docs, examples, and a playground. Social Fetch ships an official TypeScript SDK, hosted OpenAPI, and playground tied to the same catalog.
### Are failed requests free on both?
SociaVault states you pay for successful requests. Social Fetch does not charge lookup_failed or 503 temporarily_unavailable; completed not_found lookups still bill because the upstream ran. Read both billing FAQs before modeling retries.
---
# Social Fetch vs Tavily (2026) — social API vs AI web search
Source: https://www.socialfetch.dev/compare/tavily
# Social Fetch vs Tavily
Tavily answers "what does the web say about X?" with ranked, LLM-ready search results. Social Fetch answers "what is this TikTok or Instagram account right now?" with normalized profile JSON. Agent builders often need both; they are not substitutes.
**Full comparison page:** https://www.socialfetch.dev/compare/tavily
## At a glance
- **Primary job** — Social Fetch: Structured social media lookups; Tavily: Real-time web search for AI agents
- **Output** — Social Fetch: Normalized social JSON + meta envelope; Tavily: Ranked search results / extracted passages
- **Pricing** — Social Fetch: $1.65/1k PAYG; credits never expire; Tavily: 1,000 free credits/mo; PAYG ~$0.008/credit; Project plan ~$30/mo
- **Instagram profile by handle** — Social Fetch: Dedicated REST route; Tavily: Search the web — not a social schema
- **Open-web research query** — Social Fetch: Wrong tool (use web fetch sparingly); Tavily: Core product
- **Social catalog** — Social Fetch: 154 ops / 20 platforms; Tavily: Web index — not a social endpoint catalog
## Pricing scenario
Tavily's Researcher plan includes 1,000 API credits per month free. Basic search is typically 1 credit; advanced search is 2. Pay-as-you-go is about $0.008 per credit (~$8 per 1,000 basic searches). A Project plan starts around $30/month for 4,000 credits. Social Fetch charges ~$1.65 per 1,000 standard social lookups on prepaid packs that never expire. Again: different unit of work.
- **1,000 basic web searches:** Social Fetch — N/A — not a search API; Tavily — ~$0–$8 (free tier then ~$0.008/credit)
- **1,000 TikTok profile lookups:** Social Fetch — ~$1.65; Tavily — N/A as structured social — search + hope
- **Credits roll over?:** Social Fetch — Yes on PAYG packs; Tavily — Monthly allotment resets
- **Best fit workload:** Social Fetch — Entity lookups on social networks; Tavily — Agent research across the open web
_Tavily pricing from tavily.com/pricing (July 2026). Project plan slider and enterprise quotes vary; confirm credit costs for basic vs advanced search in their docs before budgeting._
## Verdict
Tavily is a strong AI search API. Social Fetch is a strong social data API. Use Tavily when the input is a research question. Use Social Fetch when the input is a social handle or post URL. Agents that need both should call both — not force one vendor to fake the other's job.
## When Social Fetch wins
- Known social entities: profiles, posts, comments, transcripts
- Product UIs that need typed fields, not search prose
- Multi-platform social coverage under one key and envelope
## FAQ
### Can Tavily replace Social Fetch?
No for structured social data. Search can surface pages about a creator; it does not replace a profile endpoint with normalized metrics and lookupStatus.
### Can Social Fetch replace Tavily?
No for open-web agent search. Our web utilities fetch pages you already have URLs for; they are not a ranked web search index.
### Which should I put in my agent by default?
If the tool argument is a search query, Tavily (or Exa). If the tool argument is a social handle or post URL, Social Fetch.
---
# Social Fetch vs Xpoz (2026) — social data API comparison
Source: https://www.socialfetch.dev/compare/xpoz
# Social Fetch vs Xpoz
Xpoz pitches social data for AI agents: MCP tools, typed SDKs, and credit-priced queries over Twitter/X, Instagram, TikTok, and Reddit. Social Fetch is a broader REST social API with prepaid credits and production-oriented docs. Overlap is real on four networks; the platforms, billing math, and integration style diverge.
**Full comparison page:** https://www.socialfetch.dev/compare/xpoz
## At a glance
- **Platform coverage** — Social Fetch: 20 platforms / 154 operations; Xpoz: Twitter/X, Instagram, TikTok, Reddit (core marketing)
- **Integration style** — Social Fetch: REST + TypeScript SDK (+ MCP elsewhere in ecosystem); Xpoz: MCP-first, plus TypeScript/Python SDKs and CLI
- **Credit model** — Social Fetch: Usually 1 credit per standard lookup; Xpoz: Per query by platform: Reddit/X 2, TikTok 5, Instagram 12
- **Pro plan (monthly)** — Social Fetch: Optional; PAYG packs work alone; Xpoz: $20/mo for 30k credits ($16/mo billed annually)
- **Max plan** — Social Fetch: Scale pack $379 / 230k credits (one-time PAYG); Xpoz: $160/mo annual rate for 600k credits ($200/mo list-style monthly)
- **Continuous keyword tracking** — Social Fetch: Build with your own scheduler + our lookups; Xpoz: Tracked keywords/users included by plan tier
## Pricing scenario
Xpoz Free gives 2,500 one-time credits. Pro is $20/mo (or $16/mo annual) for 30,000 credits; Max is $160/mo annual ($1,920/year) for 600,000 credits with overage $0.40/1k credits. Query costs: Reddit & Twitter 2 credits, TikTok 5, Instagram 12 — rows returned do not add cost. Social Fetch Scale is $1.65 per 1,000 standard lookups with one credit each on typical profile routes.
- **Free credits:** Social Fetch — 100, never expire; Xpoz — 2,500 one-time (do not refresh)
- **1,000 Twitter/X queries (Pro math):** Social Fetch — ~$1.65; Xpoz — ~$1.33 (2 credits × 1,000 ÷ 30k × $20)
- **1,000 TikTok queries (Pro math):** Social Fetch — ~$1.65; Xpoz — ~$3.33 (5 credits × 1,000 ÷ 30k × $20)
- **1,000 Instagram queries (Pro math):** Social Fetch — ~$1.65; Xpoz — ~$8.00 (12 credits × 1,000 ÷ 30k × $20)
- **1,000 Instagram queries (Max annual math):** Social Fetch — ~$1.65; Xpoz — ~$3.20 (12 × 1,000 ÷ 600k × $160)
- **Unused PAYG balance:** Social Fetch — Never expires; Xpoz — Monthly credits; Free is one-shot
_Xpoz pricing from xpoz.ai/pricing (July 2026). Monthly vs yearly toggle shown on-site; Pro $16/mo and Max $160/mo reflect annual billing. Credit weights from the same page. Confirm before budgeting overage and tracked-keyword add-ons._
## Verdict
Xpoz is a credible, agent-friendly social query product on four major networks with simple monthly plans. Social Fetch is broader, flatter on credits, and oriented to production REST. Choose Xpoz when MCP + those four networks are enough. Choose Social Fetch when coverage, Instagram unit economics, or non-expiring packs decide the architecture.
## When Social Fetch wins
- You need YouTube, LinkedIn, Facebook, and other networks beyond Xpoz's four
- Instagram-heavy workloads where 12-credit queries inflate the bill
- PAYG packs that never expire beat monthly credit resets
- Production REST + OpenAPI + support requestId is the integration standard
- Flat per-lookup economics matter more than per-platform credit weights
## FAQ
### Is Xpoz cheaper than Social Fetch?
Sometimes on Twitter/Reddit at Pro volumes; often not on Instagram because of the 12-credit weight. Compare your platform mix at Pro vs Max rates against Social Fetch's $1.65/1k Scale pack.
### Does Social Fetch support MCP?
Social Fetch's primary contract is REST/OpenAPI with a TypeScript SDK. Agent tooling exists in the broader ecosystem; evaluate current MCP docs on our site if agents are the main client.
### Which has more platforms?
Social Fetch documents 20 platforms. Xpoz's public social data marketing focuses on Twitter/X, Instagram, TikTok, and Reddit.
### Do Xpoz free credits refresh?
No. The Free tier is 2,500 one-time credits. Social Fetch's 100 free credits also do not require a card and sit until used; paid PAYG packs never expire.
### Can I use both?
Yes — for example Xpoz for MCP demos on four networks and Social Fetch for production multi-platform routes. Most teams standardize on one read API to avoid dual schemas.
### What about LinkedIn on Xpoz?
Not part of Xpoz's four-network social data pitch as verified for this page. Social Fetch includes LinkedIn among its supported platforms.
---
# Social Fetch vs ZenRows (2026) — scraper API vs social API
Source: https://www.socialfetch.dev/compare/zenrows
# Social Fetch vs ZenRows
ZenRows fetches any URL through anti-bot tooling and returns HTML (or parsed snippets). Social Fetch fetches public social entities and returns normalized JSON. Same HTTP habit; different deliverable when the ticket says "get this creator's follower count."
**Full comparison page:** https://www.socialfetch.dev/compare/zenrows
## At a glance
- **Product shape** — Social Fetch: Social REST API (profiles, posts, comments…); ZenRows: Universal Scraper API + browser + proxies
- **Default billing** — Social Fetch: 1 credit ≈ 1 completed standard lookup; ZenRows: Monthly balance; JS/proxy features multiply cost
- **Entry paid plan** — Social Fetch: $25 Starter pack (10k credits, never expire); ZenRows: $69/mo (and up) subscription balance
- **JS + premium proxies** — Social Fetch: N/A — structured social routes; ZenRows: Up to 25× basic request cost
- **Social schema** — Social Fetch: Documented fields across platforms; ZenRows: You parse HTML or add extraction rules
- **Best fit** — Social Fetch: App features powered by social data; ZenRows: General website scraping with anti-bot bypass
## Pricing scenario
ZenRows sells monthly plans starting around $69/mo with a shared balance across Universal Scraper, Scraping Browser, and residential proxies. Cost multipliers apply: JavaScript rendering 5×, premium proxies 10×, both 25× vs a basic request. Unused balance does not roll over between billing cycles. Social Fetch Scale is $379 for 230k credits that never expire on PAYG packs — standard social lookups stay one credit regardless of how hard Instagram is upstream.
- **Free start:** Social Fetch — 100 credits, no card, no expiry; ZenRows — Free trial (plan limits apply)
- **Cheapest paid entry:** Social Fetch — $25 for 10k credits (PAYG); ZenRows — ~$69/mo subscription
- **1,000 basic page fetches:** Social Fetch — N/A; ZenRows — Low CPM on higher plans (e.g. ~$0.10/1k on Business math)
- **1,000 JS + premium fetches:** Social Fetch — N/A; ZenRows — Up to 25× basic CPM on the same plan
- **1,000 structured social profiles:** Social Fetch — ~$1.65; ZenRows — Scrape cost + your parsers + monthly floor
- **Unused quota rolls over?:** Social Fetch — Yes — PAYG packs never expire; ZenRows — No — balance resets each billing period
_ZenRows pricing from zenrows.com/pricing and docs.zenrows.com/first-steps/pricing (July 2026). Multipliers and plan CPMs change by tier; confirm current numbers before budgeting._
## Verdict
ZenRows is a strong scraping and anti-bot platform. Social Fetch is a social data API. Comparing them on raw CPM misses the boundary: one returns pages, the other returns social objects. Use ZenRows for the open web. Use Social Fetch when the object is a creator, post, or comment thread.
## When Social Fetch wins
- You need one response envelope and field conventions across social networks
- Product UX binds to followerCount-style fields, not page HTML
- Adding a second network should not mean a second parser codebase
- JS + premium multipliers make DIY social pages expensive
- lookupStatus / requestId matter more than autoparse on arbitrary URLs
## FAQ
### Is ZenRows cheaper for Instagram profiles?
Basic fetches can look cheap on paper. Social pages often need JS and premium proxies (up to 25×), plus your parser maintenance. Social Fetch at $1.65/1k returns structured profile JSON. Fully loaded cost for production social features usually favors Social Fetch.
### Does Social Fetch replace ZenRows?
No. Keep ZenRows (or similar) for general websites. Use Social Fetch for supported social entities.
### Do ZenRows credits roll over?
Unused plan balance does not roll over between billing cycles (upgrade mid-cycle can carry unused usage). Social Fetch PAYG pack credits never expire.
### Does ZenRows charge failed requests?
ZenRows documents pay-per-success for the Universal Scraper API (with noted exceptions like some 404/410 paths). Social Fetch does not charge lookup_failed or 503 temporarily_unavailable; completed not_found still bills.
### Can I use both?
Yes. Common pattern: ZenRows for protected non-social sites; Social Fetch for TikTok/Instagram/YouTube/LinkedIn entity lookups.