> ## Documentation Index
> Fetch the complete documentation index at: https://docs.influship.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Expand a Roster with Lookalikes

> Use weighted seeds and performance data to find more creators like your best performers

# Expand a Roster with Lookalikes

You have creators that work. Now you need more like them. This recipe uses the lookalike endpoint with weighted seeds to find similar creators, filtered to your requirements, and scored for campaign fit.

The key insight: if you have performance data from previous campaigns, encode it in the weights. Your best-performing creator gets the highest weight, and the API finds more creators who skew toward that profile.

## The Flow

1. **Identify** your <Tooltip tip="A seed is a reference creator used as input for lookalike search.">seed creators</Tooltip> and assign weights based on performance
2. **Run** a lookalike search with filters
3. **Score** results against your next campaign (optional but recommended)

## Step 1: Build Weighted Seeds

Start with creators you've worked with. If you have ROI or engagement data, normalize it to weights:

```typescript theme={null}
import Influship from 'influship';

const client = new Influship();

// Your past campaign data
const campaignResults = [
  { username: 'wellness_maya', roi: 4.2 },
  { username: 'fit_with_dani', roi: 2.8 },
  { username: 'nutrition_neil', roi: 1.5 },
];

// Normalize ROI to 0-1 weights
const maxRoi = Math.max(...campaignResults.map((c) => c.roi));
const seeds = campaignResults.map((c) => ({
  platform: 'instagram' as const,
  username: c.username,
  weight: Math.round((c.roi / maxRoi) * 100) / 100,
}));

// seeds:
// [
//   { platform: 'instagram', username: 'wellness_maya', weight: 1.0 },
//   { platform: 'instagram', username: 'fit_with_dani', weight: 0.67 },
//   { platform: 'instagram', username: 'nutrition_neil', weight: 0.36 },
// ]
```

No performance data? Start with equal weights (1.0). You can also manually weight based on gut feel — give your favorite seed a 1.0 and the others less.

## Step 2: Run the Lookalike Search

```typescript theme={null}
const similar = await client.creators.lookalike({
  seeds,
  filters: {
    followers: { min: 15000, max: 300000 },
    engagement_rate: { min: 2.5 },
  },
  limit: 25,
});

console.log(`Found ${similar.data.length} similar creators`);

for (const result of similar.data.slice(0, 5)) {
  console.log(
    `${result.creator.name} (@${result.primary_profile?.username})`,
    `— similarity: ${result.similarity.score}`,
  );
  console.log(`  Shared traits: ${result.similarity.shared_traits.join(', ')}`);
}
```

At 1.5 <Tooltip tip="Credits are the billing unit for API usage. 1 credit = \$0.01.">credits</Tooltip> per result, 25 results costs 37.5 credits (\$0.375).

## Step 3: Score for Campaign Fit (Optional)

Lookalikes find *similar* creators — but similar to your past performers doesn't automatically mean they're right for your *next* campaign. If the campaign is different, score the results:

```typescript theme={null}
const candidateIds = similar.data.map((r) => r.creator.id);

const scored = await client.creators.match({
  creators: candidateIds.map((creator_id) => ({ creator_id })),
  intent: {
    query: 'Launch campaign for a new organic snack brand',
    context:
      'We need creators who feel authentic, not overly polished. ' +
      'The product is a healthy snack bar. Target audience is active ' +
      'millennials who care about ingredients.',
  },
});

const goodFits = scored.data
  .filter((r) => r.match.decision === 'good')
  .sort((a, b) => b.match.score - a.match.score);

console.log(`${goodFits.length} of ${candidateIds.length} passed campaign fit`);
```

## Combining Similarity and Fit Scores

If you want a single ranking that blends both signals, weight them based on what matters more:

```typescript theme={null}
// Build a combined score
const combined = similar.data
  .map((lookalike) => {
    const matchResult = scored.data.find(
      (s) => s.creator.id === lookalike.creator.id,
    );
    if (!matchResult || matchResult.match.decision === 'avoid') return null;

    return {
      creator: lookalike.creator,
      profile: lookalike.primary_profile,
      similarityScore: lookalike.similarity.score,
      campaignScore: matchResult.match.score,
      // 40% similarity, 60% campaign fit
      combined: lookalike.similarity.score * 0.4 + matchResult.match.score * 0.6,
      traits: lookalike.similarity.shared_traits,
      reasons: matchResult.match.reasons,
    };
  })
  .filter((item) => item !== null)
  .sort((a, b) => b.combined - a.combined);
```

The blend ratio depends on your use case. If you're expanding a proven formula, lean toward similarity (0.7 / 0.3). If the new campaign is different, lean toward campaign fit (0.3 / 0.7).

## Total Cost

| Step                        | Endpoint                      |  Credits |        Cost |
| --------------------------- | ----------------------------- | -------: | ----------: |
| Lookalike (25 results)      | `POST /v1/creators/lookalike` |     37.5 |     \$0.375 |
| Match scoring (25 creators) | `POST /v1/creators/match`     |       25 |      \$0.25 |
| **Total**                   |                               | **62.5** | **\$0.625** |

## The Feedback Loop

This workflow gets better over time:

1. Run a campaign with your shortlist
2. Measure performance (ROI, engagement, conversions)
3. Feed those numbers back as weights in the next lookalike search
4. Repeat

Each iteration refines what "similar to our best creators" means. The weights encode accumulated campaign knowledge that no amount of manual research can replicate.

## Tips

* **Don't over-seed.** 3-5 seeds is usually enough. More seeds dilute the signal unless each one genuinely represents a different trait you want.
* **Vary the weights meaningfully.** If all your seeds have weight 1.0, you're not using the feature. Even rough estimates (1.0, 0.7, 0.3) are better than equal weights.
* **Filter aggressively.** Lookalike search returns creators who are *stylistically* similar — they may not meet your follower or engagement requirements. Filters prevent you from scoring creators you'd never work with.