How agents verify influencer campaign results automatically

The influencer industry still settles six figure invoices with screenshots. A creator posts, a campaign manager DMs them for screen grabs, someone pastes numbers into a spreadsheet, and the brand pays against self-reported data that nobody re-checks a week later. We run creator campaigns for a living at FindClout and we refused to operate that way, so we built the verification loop described in this post. It works for a campaign of 5 posts or 500, it runs unattended, and its marginal cost is one cent per data point.

The shape of the problem

Campaign verification is three questions asked repeatedly:

1. Did the content go live and stay live? Deleted-after-24-hours is a classic soft fraud pattern.
2. What did it actually deliver? Views, likes, comments, shares, measured by a third party, not screenshotted by the payee.
3. What did delivery cost? Real CPM is spend divided by verified views, and it is the only number that lets you compare an influencer buy against paid social or anything else in your media mix.

Every input you need is public. The blocker was never data access, it was procurement: verification tooling meant vendor contracts and API keys, so most teams skipped it. With a pay per request API there is nothing to procure. A wallet with ten dollars of USDC on Base can verify a season of campaigns.

The whole verifier, in one file

The script below takes a campaign definition (spend plus a list of post URLs across Instagram, TikTok, and X), pulls live stats through the universal /api/v1/post endpoint, and prints a settlement-grade report. The only setup is a funded wallet: USDC on Base, no ETH needed.

// verify-campaign.mjs
import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY);
const payFetch = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: "eip155:8453", client: new ExactEvmScheme(account) }],
});

const campaign = {
  name: "Q3 launch flight",
  spendUsd: 25000,
  contractedViews: 5_000_000,
  posts: [
    "https://www.instagram.com/reel/DLmR4kXtQ2a/",
    "https://www.tiktok.com/@nflstreetmoments/video/7401882236711",
    "https://x.com/AdamSchefter/status/1812340221459871",
    // ...every deliverable URL
  ],
};

const API = "https://x402.findclout.com/api/v1/post?url=";
const results = [];

for (const url of campaign.posts) {
  const res = await payFetch(API + encodeURIComponent(url));
  if (res.status === 400) { results.push({ url, error: "bad_url" }); continue; }
  if (!res.ok) { results.push({ url, error: "retry_later" }); continue; }
  const s = await res.json();
  results.push(
    s.success
      ? { url, platform: s.platform, username: s.username,
          views: s.views ?? 0, likes: s.likes ?? 0,
          comments: s.comments ?? 0, shares: s.shares ?? 0,
          fetchedAt: s.fetchedAt }
      : { url, error: "not_found" } // deleted or private: flag it
  );
}

const live = results.filter(r => !r.error);
const dead = results.filter(r => r.error === "not_found");
const views = live.reduce((n, r) => n + r.views, 0);
const cpm = (campaign.spendUsd / views) * 1000;

console.log(`${campaign.name}`);
console.log(`Live posts:      ${live.length}/${campaign.posts.length}`);
console.log(`Deleted/private: ${dead.length}`, dead.map(d => d.url));
console.log(`Verified views:  ${views.toLocaleString()}`);
console.log(`Contracted:      ${campaign.contractedViews.toLocaleString()}`);
console.log(`Delivery:        ${((views / campaign.contractedViews) * 100).toFixed(1)}%`);
console.log(`Real CPM:        $${cpm.toFixed(2)}`);

Sample output:

Q3 launch flight
Live posts:      48/50
Deleted/private: 2 [ 'https://www.instagram.com/reel/DK...', ... ]
Verified views:  7,312,449
Contracted:      5,000,000
Delivery:        146.2%
Real CPM:        $3.42

Fifty posts, fifty cents, and you know precisely what you bought. Note the error handling maps directly to the API's billing rules: HTTP 400 means your URL was malformed and you were not charged, not_found is a paid answer that means the deliverable is gone (that is your deletion detector), and 5xx means retry later, also unpaid. Verified totals are only half the audit: to check that the views themselves are real, run the ratio screens in how advertisers detect inflated influencer numbers over the same results.

Run it on a schedule, keep the history

A single reading verifies delivery. A time series proves it. Deleted posts, purchased view spikes that decay, and content that keeps compounding all show up the moment you snapshot daily and diff:

// Append each run to a JSONL file; cron it daily during the flight.
import { appendFileSync } from "node:fs";
appendFileSync(
  "campaign-history.jsonl",
  JSON.stringify({ at: new Date().toISOString(), results }) + "\n"
);

The JSONL file becomes your evidence trail: every reading is timestamped by fetchedAt, so a dispute over delivery is settled by diffing snapshots rather than trading screenshots. Daily snapshots of a 50 post campaign for a 30 day flight cost $15 total. There is no vendor on earth that sells you third party, cross platform, daily verified campaign data for $15, which is the point: at this price the right question stops being "should we verify" and becomes "why would we ever not."

Make it a tool, not a script

The loop above is deliberately dumb so an agent can be smart around it. Give an LLM agent the universal endpoint as a tool plus a funded wallet, and it can decide what to check and when: re-poll underperformers more often, pull profile data when a post's numbers look inconsistent with the account's size, or draft the make-good email when delivery lands under contract. The agent wallet tutorial shows the exact tool definitions for Claude and LangChain; the platform field notes for TikTok and Instagram cover the metric quirks worth encoding into your agent's prompts.

A note from the other side of the table

We are not neutral observers here. FindClout sells distribution: we run the biggest independently owned American meme page network, spanning sports, finance, entrepreneurship, movies, TV, and music and place brands natively inside viral clips. We publish this verification playbook, and the API behind it, because measurement transparency is good for us. Our campaigns are priced on delivered views, our clients check our numbers with tools like this one, and the numbers hold. If you would rather be on the side of the table that buys views this verifiable, here is how our network works, or book a call at findclout.com.