How to Build an Automated Influencer Marketing Pipeline with Claude Code (with working code, 2026)

Most “Claude Code for influencer marketing” guides on the open web right now have one thing in common: no code. They describe pipelines, name-drop a few MCPs (Stripe, Apify, Firecrawl), drop a $450K case study with no math behind it, and call it a tutorial. If you try to build what they describe, you get stuck on step one.

This is the version with code.

You will get a complete pipeline that runs inside Claude Code: discovery, brand-fit scoring, lookalike expansion, outreach with a human-approved gate, content monitoring, and payments. Every step is a real Influship SDK call against a public API. The data and the response shapes are what you would see in production. The honest trade-offs (what works, what doesn't yet, where you still need a human) are called out as they come up.

Think of it as pipeline-as-code for influencer marketing. Three layers stacked together: a discovery layer that turns a brief into a ranked, vetted shortlist; an action layer (Claude Code) that runs the workflow end to end; and a payment layer that does not stall on human sign-up forms. Each layer is independently swappable. The rest of this guide builds all three.

If you run influencer campaigns and you can read TypeScript, you can build this today. The Influencer Marketing Hub's 2026 benchmark report pegs the average creator-discovery and vetting cycle at more than 70 hours of manual work per mid-size campaign. The pipeline below compresses that into a workflow you supervise from your terminal.

What the pipeline actually does

End to end, the workflow has six steps:

1. Discovery. Natural-language search returns a ranked list of creators matched to your brief.
2. Vetting. Each candidate gets a brand-fit score, a recommendation (good / neutral / avoid), and the reasons behind it.
3. Lookalike expansion. Seed the system with proven creators, get back a deeper shortlist of similar ones.
4. Outreach. The agent drafts personalised outreach. You approve before anything leaves your inbox.
5. Content monitoring. Once campaigns are live, the agent polls for brand-mentioning posts and surfaces them back.
6. Payments. The agent settles per-request API calls itself. Creator payouts still route through Stripe Connect or PayPal Mass Payouts, and we will be honest about why.

The whole thing runs in Claude Code, against the Influship MCP server for discovery and our REST API for everything else. No spreadsheets in the loop. No copy-pasting between dashboards.

Setup: three ways to call Influship

Before any code, get the connection working. There are three options, and you can mix them inside the same pipeline.

Option 1: Native MCP. This is the one you want if Claude Code is the surface where the work happens. Add Influship as an MCP server and the assistant gets search_creators, match_creators, lookalike_creators, get_profile, lookup_profiles, get_creator, and a few others as first-class tools.

claude mcp add influship --transport http https://mcp.influship.com/mcp \
  --header "X-API-Key: your-api-key-here"

That is the whole setup. Restart Claude Code, and the tools show up. Full walkthrough for Cursor, ChatGPT, and the rest in the MCP server guide.

Option 2: REST + the TypeScript SDK. When you want to script the pipeline directly (a cron job, a webhook handler, a Next.js route), the SDK gives you typed access to the same surface area:

import Influship from '@influship/sdk';

const client = new Influship({ apiKey: process.env.INFLUSHIP_API_KEY });

const search = await client.search.create({
  query: 'plant-based protein creators with female-skewing US audience',
  filters: { followers: { min: 10000, max: 250000 }, engagement_rate: { min: 0.03 } },
  limit: 25,
});

Option 3: Apify actors. If you already run an Apify pipeline (most marketing-engineering teams that touch scraping do), our actors at apify.com/influship drop into the same orchestration alongside your Instagram and TikTok scrapers. Useful for adjacent tasks like bulk YouTube transcript extraction and for teams that prefer Apify's pay-per-event billing over credits.

Most pipelines end up using two of the three. Discovery and vetting happen interactively in Claude Code via MCP. The scheduled jobs (monitoring, payouts) run on the SDK. Apify shows up when a step needs scraping work the Influship index does not cover.

The rest of this guide uses the SDK so the code is portable. Every snippet below also works through MCP by asking the assistant in plain English. You do not have to choose.

Step 1: Discovery

The first call is the one that does the most work. You hand it a natural-language brief and you get back ranked creators with the reasons each one matched.

const brief = `
Looking for fitness creators promoting plant-based protein.
US audience, female-skewing 18-34, posts at least 3 times per week.
Strong organic engagement, no AI-generated content, no obvious sponsorship spam.
`;

const search = await client.search.create({
  query: brief,
  platforms: ['instagram'],
  creator_kinds: ['INFLUENCER'],
  filters: {
    followers: { min: 25000, max: 250000 },
    engagement_rate: { min: 0.025 },
  },
  limit: 30,
});

console.log(search.total, search.data.length, search.search_id);

The response is exactly what you would expect from a working API. Every row has the creator, the primary profile (with engagement rate, follower count, verification), and a match object with a score and the reasons:

{
  "search_id": "9f3d12b6-...",
  "total": 412,
  "has_more": true,
  "next_cursor": "MjAyNi0wNS0yOFQwOToxN1o6MjA",
  "data": [
    {
      "creator": { "id": "cre_01HX...", "name": "Maya Russo", "bio": "Plant-based PT in Austin." },
      "primary_profile": {
        "username": "maya.russo.fit",
        "platform": "instagram",
        "followers": 84200,
        "engagement_rate": 0.052,
        "is_verified": false,
        "url": "https://instagram.com/maya.russo.fit"
      },
      "match": {
        "score": 0.91,
        "reasons": [
          "Posts vegan recipes and gym content 4+ times per week",
          "Audience skews 64% female, 71% US-based",
          "No paid-content flags in last 60 days"
        ]
      }
    }
  ]
}

That search_id matters. Once you have one, paginating through the rest of the results is free. Charging for the search, not for the page-throughs, is the right shape if you expect agents to scroll.

If you would rather drive this from Claude Code conversationally, the equivalent prompt is “Find fitness creators promoting plant-based protein, US female-skewing 18-34, 25k-250k followers, engagement above 2.5%, return 30.” The search_creators MCP tool runs, the data comes back inside the conversation, and you can ask follow-up questions against the same search_id without leaving the chat.

Step 2: Vetting

Discovery is necessary but not sufficient. A creator who looks great by the numbers can still be wrong for your campaign in ways the search vector does not catch. Have they posted about a competing protein brand in the last 30 days? Does the audience tone match the product? Did they get pulled into a controversy last quarter?

The creators.match endpoint exists for that step. You hand it the shortlist and the campaign intent, and it returns a per-creator decision with evidence.

const shortlist = search.data.slice(0, 10).map(row => ({ creator_id: row.creator.id }));

const match = await client.creators.match({
  creators: shortlist,
  intent: {
    query: 'Promote our new plant-based protein powder, focus on women in their 20s and 30s',
    context: 'Brand voice: warm, no clinical claims, no hard fitness aesthetic.',
  },
});

const good = match.data.filter(c => c.match.decision === 'good');
console.log(`${good.length} of ${match.data.length} cleared vetting`);

The response shape is direct:

{
  "data": [
    {
      "creator": { "id": "cre_01HX...", "name": "Maya Russo" },
      "match": {
        "decision": "good",
        "score": 0.88,
        "reasons": [
          { "text": "Promoted a competing whey brand 8 months ago, but the contract has visibly ended." },
          { "text": "Audience overlaps with our existing top-performing creator cohort by 41%." },
          { "text": "Tone is warm and educational, fits the brief's voice requirement." }
        ]
      }
    },
    {
      "creator": { "id": "cre_01HY...", "name": "Jordan Pace" },
      "match": {
        "decision": "avoid",
        "score": 0.22,
        "reasons": [
          { "text": "Heavy paid-content pattern: 6 of last 10 posts are tagged partnerships." },
          { "text": "Audience demographic skews male, 73%." }
        ]
      }
    }
  ]
}

The decision field is the part that makes this scriptable. You can filter on it directly. Anything avoid is gone. Anything neutral gets surfaced to you for a human read. Anything good rolls into the next step. The pattern that works:

const shortlist = match.data
  .filter(c => c.match.decision === 'good' && c.match.score >= 0.75)
  .map(c => c.creator.id);

There is also a deeper read available with client.creators.retrieve(id, { include: ['profiles'] }). That one returns an AI-generated summary, content themes, brand alignment, audience demographics, and key facts. Use it on the top 3-5 before outreach. The cost per call is low and the context you get back makes the outreach drafts massively better.

Step 3: Lookalike expansion

You have 8 vetted creators. The brief calls for 30. The most efficient way to close the gap is not to run another search and re-vet 412 new candidates. It is to expand from the ones who passed.

const expanded = [];

for await (const item of client.creators.lookalike({
  seeds: shortlist.map(id => ({ creator_id: id, weight: 1 })),
  filters: { followers: { min: 25000, max: 250000 } },
  limit: 50,
})) {
  expanded.push(item);
  if (expanded.length >= 50) break;
}

console.log(`Expanded to ${expanded.length} candidates`);

Each row comes back with a similarity score and the shared traits that drove it:

{
  "creator": { "id": "cre_01HZ...", "name": "Lena Cho" },
  "primary_profile": {
    "username": "lena.movement",
    "followers": 47800,
    "engagement_rate": 0.061
  },
  "similarity": {
    "score": 0.83,
    "shared_traits": ["plant-based recipes", "strength training", "US 25-34 audience"]
  }
}

Now run the new batch back through creators.match against the same intent. The good ones join the shortlist. The avoids are dropped. Repeat once if needed.

The compounding pattern here, search → vet → expand → vet, is what makes the pipeline scale. With three rounds you can go from “I have a brief” to “I have 30 vetted, ranked, brand-aligned creators” in under five minutes of wall-clock time.

Step 4: Outreach (with a human-approved gate)

This is the step where most automated pipelines go wrong. Fully automated outreach without a human gate produces creator inboxes full of identical AI-written notes, which creators detect and tune out within a week. Done well, the agent drafts each one in the creator's voice, you approve in batch, and the send happens after you approve.

The drafting is straightforward. Pull the creator's AI summary and content themes via creators.retrieve, hand both to Claude Code, ask for a personalised note.

const detail = await client.creators.retrieve(creatorId, { include: ['profiles'] });

const prompt = `
Write a short outreach DM to ${detail.data.name} for our plant-based protein campaign.
Their content themes: ${detail.data.content_themes.join(', ')}.
Their vibe: ${detail.data.vibe_and_aesthetics}.
Match their tone. Do not pitch hard. Open with one specific reference to their content.
Keep it under 80 words.
`;

What changes the quality is the reference. Generic “love your content” notes lose. Specific notes (“the vegan overnight oats reel you posted last Tuesday hit me, especially the bit about not pretending oats are exciting”) win.

The send is where you bring the human back in. The pattern that works:

1. Agent drafts all 30 outreach notes into a single review doc (or a Linear/Notion ticket).
2. You read through, edit any that feel off, approve in one pass.
3. Approved notes ship via your real outreach stack. Stable Email works well for one-off pay-per-send programmatic sends. For volume, plug into your existing CRM or sequencing tool.

This is also where Claude Code's terminal context helps. The agent can read your approved-template file from disk, learn what you typically edit, and produce drafts that need less editing each round.

Won't this just produce AI slop?

The honest answer is: not if the agent has something concrete to reference, and not if you keep the approval gate.

The standard objection to automated outreach is that scaled AI-written DMs all read the same and creators tune them out within a week. That's true when the agent has nothing to anchor the message to. It is not true when the agent has a specific post or content theme to cite, retrieved from the same call that surfaced the creator.

The trick is evidence-based personalisation, not vibes-based personalisation. Generic “love your content” notes lose. “The vegan overnight oats reel you posted last Tuesday hit me, especially the bit about not pretending oats are exciting” wins. The difference is one specific reference the agent pulled from creators.retrieve and named in the draft.

Two operational rules keep the slop out:

• Every draft must include at least one post-level citation. No exceptions. If the agent can't retrieve a specific reference, the draft does not get queued for sending.
• Approval is human, not optional. Read every draft once. The 10 minutes you spend editing 30 outreach notes is the difference between a 12% reply rate and a 2% one.

The reply rate is what tells you whether the approach is working. Track it from run one and tune the prompt against it.

Step 5: Content monitoring after launch

The campaign is live. Twelve creators agreed. Posts go up over the next four weeks. You need to know when each one publishes, what the post says, how it performs, and whether the creator hit the brief.

The naive version is a cron job that polls each creator's profile once a day. The slightly better version uses client.posts.list with sort: 'recent' and filters by mentions of the brand handle:

const brandHandle = '@yourbrand';

for (const creator of activeCampaign) {
  const posts = await client.posts.list({
    creator_id: creator.id,
    sort: 'recent',
    limit: 10,
  });

  const matches = posts.data.filter(p =>
    p.mentions?.includes(brandHandle) ||
    p.caption?.includes(brandHandle)
  );

  for (const match of matches) {
    if (!seenPosts.has(match.id)) {
      await notify(creator, match);
      seenPosts.add(match.id);
    }
  }
}

For raw post data (full caption, hashtags, engagement counts, transcripts for video), the Instagram raw post lookup endpoints we shipped recently give you the full payload in one call. If the campaign is YouTube-heavy, the Apify YouTube channel transcripts actor pulls every recent video's full transcript so the agent can verify the brand was mentioned the way the contract specified.

Run that on a 15-minute cron and you have a notification stream the moment a creator publishes. Tie it to a Slack webhook and the campaign manager gets a ping with the post URL, the caption, and the early engagement numbers.

Step 6: Paying creators (the honest version)

This is where every automated-pipeline article on the open web loses the plot.

Most of them describe a workflow where Claude Code uses the Stripe MCP to “release escrow when the post goes live.” The problem with that description is creator payments are not Stripe payments. They are typically a flat-fee contract with a 50% deposit, a content-deliverable milestone, a 50% balance after publish, and a W9 or W8-BEN on file. The brand's accounting team handles the 1099-NEC at year end. None of that fits inside the Stripe MCP's invoice-and-charge surface area.

So you have two things going on, not one:

Paying creators (humans, fiat, contractual). Stripe Connect, PayPal Mass Payouts, or Wise for international creators. Triggered by your contract milestones, not by the agent autonomously. The post-published trigger from Step 5 can release the second 50% into a queue for the accounting team to approve. The release itself stays human-initiated for compliance and dispute reasons. Don't let an agent move money to a human's bank account without an approval gate. Not yet.

Paying for API calls (machines, per-request, programmatic). This is the actual agentic-payment use case, and Influship supports it natively. Our endpoints accept three payment models on the same URL:

• API key for production traffic. Cheapest per call. Account-level.
• x402 (USDC on Base). Agent hits the endpoint without a key, gets a 402, signs a USDC payment, retries. No signup.
• MPP (Stripe Shared Payment Token or USDC on Tempo). Same dance, different rail. Agent picks whichever its framework already speaks.

Full detail in Influship's x402 and MPP launch post. The relevant bit for this pipeline: when the agent decides to enrich one extra creator profile mid-workflow, it pays for that call and moves on. No sign-up flow blocks the loop.

The headline is unflashy but it matters. Stripe MCP is the right tool for billing your customers. It is the wrong tool for paying your creators, and it is the wrong tool for paying your APIs. Use Stripe Connect for the first. Use x402 or MPP for the second. Use Stripe MCP for what it is built for: charging your buyers on your dashboard.

Worked example: TikTok protein bar campaign

To make this concrete, here is the whole thing against a real brief.

• Brand: mid-market plant-based protein bar, $24-pack on Amazon, DTC site live.
• Budget: $20,000 across 30 creators.
• Goals: 40 published Reels, US-female 22-34 audience, average engagement >4%, brand-handle mention required in caption and Reel cover frame.
• Tools: Claude Code with Influship MCP, Stable Email for outreach send, Stripe Connect for payouts.

Step-by-step:

1. Discovery finds 412 candidates against the brief, ranked. First page of 30 has match scores from 0.91 down to 0.74.
2. Vetting on the top 30 clears 22 as good, 5 as neutral, 3 as avoid. The avoids are all paid-content spam. The neutrals get a human read; 4 of 5 get approved manually.
3. Lookalike expansion from the 26 approved seeds pulls 50 more candidates. 31 pass vetting in the same pass.
4. Outreach drafts go into a review doc. I edit 9 of 30, ship 30 the same morning.
5. Twelve creators agree in the first 72 hours. Contracts and 50% deposits go out via the brand's existing flow. Twenty more replies trickle in over the next week.
6. Content monitoring catches the first published Reel six days in, pings the campaign manager in Slack. By week three, 38 of 40 contracted Reels are live.
7. Payouts queue automatically when each post passes verification (correct handle mention, correct cover frame, correct hashtag). A human approves the queue each Friday and Stripe Connect releases.

Wall clock from “brand brief lands” to “first outreach sent”: under 90 minutes, most of it spent editing the nine outreach drafts. Cost of the pipeline tooling for the run (Influship credits + Claude API + Apify): roughly $140. Cost of the campaign itself: $20,000 in creator fees plus the brand's product cost.

The same campaign, run by a marketing manager with a spreadsheet and a CRM, takes 70+ hours of manual work spread across two weeks. Most of that time is discovery and vetting, which is exactly what the pipeline collapses.

What this costs

Honest cost breakdown for the worked example above:

• Influship credits: 412 search results + 60 vetting calls + 26 deep retrieves + lookalike expansion ≈ $35 against our public per-credit pricing.
• Claude API tokens (Claude Code on the Sonnet tier): about $40 across discovery, drafting, and monitoring conversation.
• Apify run-time for YouTube transcript verification on a few creators: ~$15.
• Stable Email for one-off outreach sends: ~$0.05 per send × 30 = $1.50.
• Stripe Connect fees on $20K in payouts: variable, typically 0.25% + $0.25 per payout, so under $80.

The pipeline pays back the first time you run it. It pays back compounding the second time, because the templates and the approved-content patterns from run one feed run two.

What this does not solve

Three honest gaps:

Contract negotiation. Custom usage rights, exclusivity windows, whitelisting, mid-campaign scope changes. None of that should be agent-automated yet. Templates yes, redlines no. See our influencer contract guide for the human side of this.

FTC compliance. Disclosure language, the #ad placement requirement, sponsored-content flagging. The agent can check whether disclosure exists in a caption, but the standard is still a human's responsibility. See our FTC guidelines post.

Dispute handling. Creator missed the deadline. Creator posted but the product label was off-frame. Creator's audience pivoted between contract signing and publish. These all need a human conversation. The agent can flag them. The agent should not resolve them.

You will also want a brand-safety layer on top of what creators.match does, especially for regulated categories (alcohol, supplements, finance). For those, the right move is to run a separate compliance pass before outreach.

Wrap

The pipeline is real. The code runs against a public API. The trade-offs are visible.

The interesting work in marketing engineering right now is not “use AI to write captions.” It is pipeline-as-code: composing a workflow that used to take 70+ hours into something you supervise from your terminal. That requires the three layers working in sync. The discovery layer turns a brief into ranked, vetted creators. The action layer (Claude Code) runs the workflow without context-switching out of your terminal. The payment layer lets the workflow buy what it needs as it goes. Influship covers the first and the third. Claude Code covers the second.

To start, take the Step 1 snippet above, swap in a brief that matches a campaign on your desk, and run it. Five minutes from now, you will know whether this pipeline is useful for you specifically. If it is, the rest of the steps stack on top.

Get started: free trial on Influship, MCP setup guide, or the API docs. For the rest of the developer guides — the MCP server, the creator API, and agentic payments — see influencer marketing for AI agents and developers.