Migrating Off Apify Actors to a Creator Data API

This is the practical version: what maps to what, what you delete, what you must keep Apify for, and how to validate the cutover without a flag day.

Before you start: decide what you are actually moving

Be specific, because moving the wrong half will make things worse. Apify is excellent at post level scraping and arbitrary targets. A creator data API covers the creator vertical and the workflow after it.

Good candidates to migrate:

• Creator discovery built on hashtag or keyword scraping plus your own filtering
• Profile lookups where you only need creator level fields (followers, engagement, niche, location, contact)
• Anything where a user waits for the response
• Anything where cost per creator needs to be forecastable
• Contact enrichment running on a community Actor

Keep on Apify:

• Comments at depth. clockworks/tiktok-comments-scraper at $0.50 per 1,000 comments is excellent value with no equivalent here.
• Video level metrics, subtitles, transcripts, media downloads
• YouTube channel and video data
• Any non social target, where Apify's 78,000+ Actors and custom Actors are unmatched
• Custom scraping logic you wrote yourself, or anything on Crawlee

This is almost never all or nothing. The common end state is Apify for the long tail and custom work, a creator API for the creator vertical.

Endpoint mapping

The code you delete

A typical Apify discovery path looks roughly like this:

// 
start the run const run = await fetch(https://api.apify.com/v2/acts/${actorId}/runs?token=${TOKEN}, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ hashtags: ['skincare'], resultsLimit: 2000 }), }).then((r) => r.json());
// 
poll until it finishes let status = run.data.status; while (status === 'RUNNING' || status === 'READY') { await new Promise((r) => setTimeout(r, 5000)); const check = await fetch(
    https://api.apify.com/v2/actor-runs/${run.data.id}?token=${TOKEN}
  ).then((r) => r.json());
  status = check.data.status;
}
// 
fetch the dataset const items = await fetch(
  https://api.apify.com/v2/datasets/${run.data.defaultDatasetId}/items?token=${TOKEN}
).then((r) => r.json());
// 
normalize, because Instagram and TikTok disagree about everything const creators = items.map((i) => ({ handle: i.username ?? i.uniqueId, followers: i.followersCount ?? i.stats?.followerCount ?? i.edge_followed_by?.count, // engagement rate is not returned, so compute it and hope your method // matches whatever you did last time engagement: computeEngagement(i.latestPosts ?? i.itemList ?? []), }));
// 
filter client side, having already paid per result for everything const qualified = creators.filter( (c) => c.followers >= 25000 && c.followers <= 150000 && c.engagement >= 0.035 );

The replacement:

const res = await fetch(
  'https://api.ugcroster.com/v1/creators/search?' +
    new URLSearchParams({
      niche: 'skincare',
      follower_min: '25000',
      follower_max: '150000',
      engagement_min: '0.035',
      has_email: 'true',
      sort: 'engagement',
      limit: '100',
    }),
  { headers: { Authorization: Bearer ${process.env.ROSTER_API_KEY} } }
).then((r) => r.json());
const qualified = res.data; // already filtered, normalized, engagement scored

Five steps become one. The filter moved server side, so you stop paying for the 1,900 candidates you were discarding.

Field mapping

Apify Actor output varies by Actor and platform. The Roster response is one shape:

{
  "pk": 12345,
  "username": "emmachen",
  "full_name": "Emma Chen",
  "follower_count": 245000,
  "engagement_rate": 4.2,
  "category": "Beauty & Skincare",
  "biography": "Beauty creator...",
  "extracted_email": "emma@example.com",
  "niches": "skincare, beauty, lifestyle",
  "city": "Los Angeles",
  "state": "CA",
  "country": "United States",
  "profile_pic_url": "https://...",
  "is_verified": false,
  "external_url": "https://linktr.ee/emma"
}

Common renames: username replaces uniqueId and Instagram's username; follower_count replaces stats.followerCount and edge_followed_by.count; engagement_rate replaces whatever you were computing; extracted_email replaces bio parsing; pk is the stable id to store.

One note on engagement_rate: it arrives as a percentage figure (4.2 meaning 4.2%), while the engagement_min filter takes a decimal (0.03 meaning 3%). Worth getting right on your first call rather than your tenth.

Auth and limits

Auth is a single bearer token. Keys are 44 characters and start with rsk_, self serve at api.ugcroster.com/keys:

curl "https://api.ugcroster.com/v1/creators/search?niche=fitness&limit=5" \
  -H "Authorization: Bearer rsk_your_key_here"

There are two key types worth knowing before you wire anything up. Data keys are self serve and cover read only creator search and profiles, metered in credits. Brand keys come with Roster brand plans and are unmetered across the full API surface including the write endpoints.

Credits: a search query is 10, a profile read is

1. Plans are Starter $98 for 25,000 credits at 60 req/min, Growth $398 for 150,000 at 120 req/min, Scale $998 for 500,000 at 300 req/min, with add on packs at 5K for $25, 25K for $125, 100K for $500.

Rate limit headers come back on every response (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset), with 429 on exceed. Honest comparison: Scrape Creators publishes no rate limits at all, so for pure burst backfills a per minute cap is a real constraint you should size for.

Validating the cutover

Do not flag day it. Run both and compare.

1. Pick a known cohort. Take 200 creators your Apify pipeline already surfaced and that you have opinions about.
2. Look them up by handle via /v1/creators/search with q, and check coverage. Any creator graph has gaps, and you want to know yours before you depend on it, not after.
3. Compare engagement numbers. Yours will differ from engagement_rate, because you chose a method and so did we. What matters is whether the ranking is consistent, not whether the decimals match.
4. Spot check emails. Verify a sample of extracted_email values against what your enrichment step produced.
5. Shadow the discovery query. Run your hashtag pipeline and the equivalent filtered search for a week and compare the shortlists by hand. This is the step people skip and then regret.
6. Then cut over, and keep the Apify path behind a flag until you have a month of real usage.

Where you find gaps, that is also what the q free text filter and /v1/creators/{pk} are for, and where the graph genuinely does not cover a creator, keeping a scraping fallback for that case is a reasonable permanent architecture rather than an admission of defeat.

Two timing notes

Rental Actors retired on 1 October 2026. Apify's docs state that no new rental Actors could be published from 1 April 2026 and that rental Actors were fully retired on 1 October 2026 and migrated to pay per usage. If a cost comparison you built earlier assumed a flat Actor rent, it is now out of date.

One community Actor's Instagram price doubles on 7 October 2026. flash_scraper/creator-leads-scraper moves Instagram leads from $0.002 to $0.004 per lead. If your contact enrichment runs on it, reprice before you decide.

What you gain beyond discovery

The part with no Apify equivalent at all, because no scraping platform does it: the workflow after you found the creator. The UGC Roster API exposes creator search, briefs, campaigns and payouts behind one key at UGCRoster.

• /v1/briefs sends the brief and mints submission links
• /v1/campaigns and /v1/applications run the campaign and triage applicants
• /v1/contracts generates and sends the contract
• /v1/deliverables tracks assets and approvals
• /v1/content tracks published content metrics
• /v1/affiliates/links creates trackable affiliate links
• /v1/payouts pays the creator
• /v1/webhooks notifies your system when any of it changes

Same bearer token. Previously that was five integrations and a database you built.

Background reading: the full Apify alternative breakdown, Apify pricing and compute units decoded, Apify's influencer discovery Actors reviewed and how creator data APIs compare.

Start at api.ugcroster.com/docs, full reference at api.ugcroster.com/reference, and there is an MCP server if you would rather an agent drove it.

FAQ

How hard is it to migrate off an Apify Actor?

For creator discovery it is mostly deletion. The run start, status poll and dataset fetch become one request, the cross platform normalization layer becomes unnecessary because the response is already normalized, engagement computation becomes unnecessary because engagement_rate is precomputed, and client side filtering becomes query parameters. Most teams report removing more code than they add.

Can I keep using Apify for some things?

Yes, and you probably should. Keep it for comments at depth, transcripts, video level metrics, YouTube, any non social target, and any custom Actor you wrote. Apify's 78,000+ Actors and custom Actor support have no equivalent in a vertical API. The usual end state is both tools, each doing what it is shaped for.

What breaks when I migrate?

Mainly expectations rather than code. Engagement rate numbers will not match yours exactly, because both are computed choices rather than platform facts, so compare rankings instead of decimals. Creator graph coverage will differ from whatever your scraping surfaced, so test a known cohort before cutting over. And per minute rate limits replace Apify's per resource per second limits, which matters for burst backfills.

Will it cost less?

Usually, and more importantly it becomes forecastable. Apify meters compute units (memory times duration), data transfer, proxy at $7 to $8 per GB residential, and storage operations, separately from each Actor's per result fee, and prepaid usage expires monthly. A credit meter has one dial, so 100,000 profile reads is 100,000 credits and you can compute the bill in advance.

Do I need to migrate all platforms at once?

No, and you should not. Migrate Instagram and TikTok discovery first, since that is where a creator graph is strongest and where hashtag scraping is weakest. Keep YouTube and any post level work on Apify. Run both paths in parallel for a week, compare shortlists by hand, then move traffic behind a flag.

What about the data I already have in Apify datasets?

Export it before you stop. Unnamed default storages expire after 7 days on Free and 31 days on standard paid plans, and on Free only your 10 most recent runs are retained, for 4 months. Named storages persist until deleted. Store pk values after migrating so you have a stable id to join on.