DEV Community: Sebastian Wallinstabot project

How HTTP 402 Is Turning APIs Into Vending Machines

Sebastian Wallinstabot project — Mon, 23 Mar 2026 02:01:40 +0000

The payment status code that sat unused for 30 years is finally getting its moment.

When Tim Berners-Lee and Roy Fielding designed HTTP in the early 1990s, they reserved status code 402 for "Payment Required." The spec was vague — it was meant for future micropayment schemes that never materialized. For three decades, 402 has been a historical footnote, occasionally used by SaaS products as a 403 substitute for "you need to upgrade your plan."

That's about to change.

The Problem with API Keys

Every API I've used in the last ten years follows the same pattern:

Sign up for an account
Generate an API key
Choose a pricing plan ($49/mo, $199/mo, enterprise)
Store the key in .env, hope you don't accidentally commit it
Get an email when you exceed your quota

This works fine at scale. But it's terrible for small workloads.

I was building an influencer discovery tool. My use case: a few hundred searches per month, each returning a list of Instagram accounts matching a niche. The cheapest plan from a major influencer data provider was $299/month. I needed maybe 100 searches. That's $3 per search — for data that costs fractions of a cent to generate.

The subscription model assumes you'll use the product enough to justify the monthly fee. For me, that assumption was wrong.

The Vending Machine Model

A vending machine doesn't ask for your name. It doesn't charge a monthly subscription. You insert coins, press a button, receive a product.

That's what HTTP 402 enables.

The x402 protocol uses HTTP 402 to implement pay-per-request APIs. Here's how it works:

Client sends a request to an endpoint
Server responds with 402 Payment Required and a JSON body describing the price and accepted payment tokens
Client sends payment (USDC on Base, Solana, or other EVM chains)
Client resends the original request with a payment proof header
Server verifies the payment on-chain and returns the response

No accounts. No API keys. No subscriptions. Just tokens.

Seeing It in Practice

Let me show you what this looks like with a concrete example. I built Social Intel — an Instagram influencer search API that uses x402 for payments.

Without any setup, you can call it directly with Python:

from x402.client import wrap_client
import httpx

client = wrap_client(httpx.Client(), wallet_private_key="YOUR_PRIVATE_KEY")

response = client.get(
    "https://socialintel.dev/v1/search",
    params={"query": "yoga", "country": "United States", "limit": 20}
)

influencers = response.json()["results"]

The first call returns a 402 response. The wrap_client wrapper reads the payment info, signs a USDC transaction, and retries automatically. The second call returns data. Total cost: $0.10 USDC.

No account creation. No API key rotation. No billing dashboard. Just a wallet and a query.

Why This Pattern Is Interesting for Agents

The timing here matters. Large language models are increasingly calling external APIs autonomously. An AI agent researching influencers for a campaign doesn't want to manage OAuth tokens or deal with subscription renewals.

With x402, the agent just needs a funded wallet. The payment happens at the protocol level — the same way an HTTP redirect is transparent to the calling code.

This is why the x402 ecosystem is growing: developers are building infrastructure for AI agents that need to consume paid services without human intervention in the payment loop.

The Current Tradeoffs

I'll be honest about what doesn't work yet.

USDC friction: Most developers don't have USDC on Base. Getting it requires bridging from another chain or buying on Coinbase. For a $0.10 API call, that setup cost is disproportionate. This is the biggest adoption blocker right now.

No receipts or invoicing: If you're building a product, you probably need expense tracking. x402 transactions are on-chain so they're auditable, but there's no built-in invoice generation.

Error handling is immature: Libraries are still stabilizing. The Python and JavaScript SDKs handle the happy path well, but edge cases (network failures mid-payment, stale price quotes) require manual handling.

Discovery: How do you find x402-compatible APIs? There's x402scan.com and AgentCash — but the ecosystem is early. You mostly have to know what exists.

The Broader Shift

The subscription model made sense when API consumers were human-managed applications. A SaaS company signs up, integrates once, pays monthly. The revenue is predictable.

But AI agents are a different consumer profile. They might make 3 API calls or 3,000 depending on the task. They spin up and tear down. They're often running in contexts where setting up a subscription is impractical.

The vending machine model fits this profile better. No commitment, no minimum spend, no human in the loop for each payment.

HTTP 402 was a placeholder for 30 years. The infrastructure for it — programmable stablecoins, fast settlement, lightweight payment provers — has only recently become practical. It's arriving at exactly the moment it's needed.

Try it yourself: curl "https://socialintel.dev/v1/search/free?query=fitness&limit=5" — returns real influencer data without payment (first 5 results are free). Full paid endpoint at socialintel.dev via the x402 Python or JS SDK.

Sebastian Wall is building Social Intel, a pay-per-call Instagram influencer search API. You can find the MCP server at smithery.ai/servers/socialinteldev/social-intel-mcp.

How to Find Beauty Influencers Programmatically (No Scraping, No API Keys)

Sebastian Wallinstabot project — Mon, 23 Mar 2026 01:40:06 +0000

Finding beauty influencers usually means hours on Instagram, spreadsheets, and guesswork. Or paying $300/month for a tool that gives you the same results.

Here's how to do it in one API call.

The Basics

curl "https://socialintel.dev/v1/search?query=beauty&demo=true"

Response:

{
  "results": [
    {
      "username": "sulehairtransplant",
      "full_name": "Sule Hair Transplant",
      "followers": 3833075,
      "category": "Health/beauty",
      "is_verified": true,
      "public_email": "[available in paid response — ~50% of accounts]"
    },
    {
      "username": "blushbeautybar_sneha",
      "full_name": "Sneha Sharma | Makeup Artist | Educator",
      "followers": 677468,
      "category": null,
      "is_verified": false,
      "public_email": "[available in paid response — ~50% of accounts]"
    }
  ],
  "demo": true,
  "source": "cache"
}

Demo mode returns up to 3 preview results. Full results (up to 100, with business emails) cost $0.10 USDC via x402 — no signup required.

Filter by Country

Looking for US-based beauty influencers specifically?

curl "https://socialintel.dev/v1/search?query=beauty&country=United+States&demo=true"

Supported: 50+ countries. Use full country names ("United Kingdom" not "UK").

Filter by Follower Count

Finding micro-influencers (10K–100K) for better engagement rates:

curl "https://socialintel.dev/v1/search?query=skincare&min_followers=10000&max_followers=100000&demo=true"

Filter by Gender

curl "https://socialintel.dev/v1/search?query=beauty&gender=woman&country=United+States&demo=true"

Python Example

import requests

def find_beauty_influencers(keyword, country=None, min_followers=None, max_followers=None, limit=20):
    """Search for beauty influencers using Social Intel API."""
    params = {
        "query": keyword,
        "limit": limit,
    }
    if country:
        params["country"] = country
    if min_followers:
        params["min_followers"] = min_followers
    if max_followers:
        params["max_followers"] = max_followers

    headers = {
        # x402 payment handled automatically by client
        # Full docs: https://socialintel.dev/docs
    }

    response = requests.get("https://socialintel.dev/v1/search", params=params)

    if response.status_code == 402:
        # x402 payment required — use agentcash or x402 client
        print("Payment required. Run: npx agentcash@latest fetch", response.url)
        return []

    return response.json().get("results", [])

# Find US-based skincare micro-influencers
results = find_beauty_influencers(
    keyword="skincare",
    country="United States",
    min_followers=10000,
    max_followers=100000
)

for influencer in results:
    print(f"@{influencer['username']} — {influencer['followers']:,} followers")
    if influencer.get('public_email'):
        print(f"  Email: {influencer['public_email']}")

What You Get

Each result includes:

Username — direct Instagram handle
Full name — display name
Follower count — live numbers
Category — Instagram-assigned niche (Beauty, Health/Beauty, etc.)
Verified status — blue checkmark
Business email — public email from bio (~50% of accounts have one)

Using the MCP Server

If you're building AI agents, there's an MCP server that lets Claude or Cursor search for influencers directly:

{
  "mcpServers": {
    "social-intel": {
      "command": "npx",
      "args": ["-y", "social-intel-mcp"]
    }
  }
}

Once installed, you can say: "Find 20 US-based beauty influencers with over 50K followers" and the agent calls the API automatically (and pays $0.10 via its own wallet).

Try It

Free demo (3 results, no payment needed):

curl "https://socialintel.dev/v1/search?query=beauty&demo=true"

Full search with emails ($0.10 USDC, one command):

npx agentcash@latest fetch "https://socialintel.dev/v1/search?query=beauty&country=United+States&limit=20"

Built with Social Intel API — Instagram influencer search for developers and AI agents.

Building an Influencer Vetting Pipeline with Two x402 APIs (Python)

Sebastian Wallinstabot project — Sun, 22 Mar 2026 08:48:39 +0000

When I started building an influencer vetting tool, I realized there are two distinct problems:

Discovery — finding accounts that match your criteria (niche, location, follower count)
Research — pulling data on specific accounts you've already identified

Most tools conflate these. I've been building a pipeline that uses two different x402-native APIs for each stage, and it works surprisingly well.

Stage 1: Discovery (who exists?)

Social Intel is purpose-built for discovery. You give it a niche and filters, it returns matching Instagram accounts.

import httpx

# Find yoga micro-influencers in the US
discovery = httpx.get(
    "https://api.socialintel.dev/v1/search",
    params={
        "query": "yoga instructor",
        "country": "United States",
        "gender": "woman",
        "followers_min": 10000,
        "followers_max": 100000,
        "limit": 20
    }
)

candidates = discovery.json().get("results", [])
# Returns: username, followers, category, city, email, is_verified
# Price: $0.10 USDC via x402

One call returns up to 20 matching accounts with follower counts, location, and contact email. Good for building the initial candidate list.

Stage 2: Research (what do they post?)

Once you have usernames, StableSocial handles the deep profile pull. Posts, stories, highlights — all the data you need to evaluate fit and engagement.

# For each candidate, pull their recent posts
for creator in candidates[:5]:  # start with top 5
    posts = httpx.post(
        "https://stablesocial.dev/api/instagram/posts",
        json={"username": creator["username"], "limit": 12}
    )
    # Returns: post content, likes, comments, timestamp
    # Price: $0.06 USDC via x402

Putting It Together

import httpx
from dataclasses import dataclass

@dataclass
class InfluencerProfile:
    username: str
    followers: int
    email: str
    avg_likes: float
    recent_posts: list

def build_shortlist(niche: str, country: str, min_followers: int, max_followers: int):
    # Stage 1: Discovery — $0.10
    discovery_response = httpx.get(
        "https://api.socialintel.dev/v1/search",
        params={
            "query": niche,
            "country": country,
            "followers_min": min_followers,
            "followers_max": max_followers,
            "limit": 10
        }
    )
    candidates = discovery_response.json().get("results", [])

    profiles = []
    for candidate in candidates:
        # Stage 2: Research — $0.06 each
        posts_response = httpx.post(
            "https://stablesocial.dev/api/instagram/posts",
            json={"username": candidate["username"], "limit": 12}
        )
        posts = posts_response.json().get("posts", [])
        avg_likes = sum(p.get("likes", 0) for p in posts) / len(posts) if posts else 0

        profiles.append(InfluencerProfile(
            username=candidate["username"],
            followers=candidate["followers"],
            email=candidate.get("email", ""),
            avg_likes=avg_likes,
            recent_posts=posts[:3]
        ))

    # Sort by engagement rate
    profiles.sort(key=lambda p: p.avg_likes / p.followers if p.followers else 0, reverse=True)
    return profiles

# Run it
shortlist = build_shortlist("yoga instructor", "United States", 10000, 100000)
for p in shortlist:
    engagement_rate = (p.avg_likes / p.followers * 100) if p.followers else 0
    print(f"@{p.username} — {p.followers:,} followers | {engagement_rate:.1f}% engagement | {p.email}")

Cost Per Run

Discovery call: $0.10
Research calls (10 profiles): $0.60
Total: $0.70 USDC for a qualified shortlist of 10 influencers sorted by engagement

Both APIs use x402 — your agent handles payments automatically if you're using an x402-compatible wallet like AgentCash.

When to Use Each

Task	Use
"Find yoga influencers in LA"	Social Intel
"Get @username's recent posts"	StableSocial
"Build an influencer shortlist from scratch"	Both, in sequence
"Monitor a specific creator's content"	StableSocial only

Try Without Paying First

Both services have free demo endpoints. Use them to validate the data before committing:

# Social Intel free demo
curl "https://api.socialintel.dev/v1/search/free?query=yoga+instructor&country=United+States"

# StableSocial — standard x402 free tier on first call

Social Intel docs: https://socialintel.dev

How to Find Yoga Influencers Programmatically (API + Python)

Sebastian Wallinstabot project — Sun, 22 Mar 2026 04:43:58 +0000

Building a yoga app and need to find the right Instagram creators to partner with? Here's how I do it without scraping or API key bureaucracy.

The Problem With Finding Yoga Influencers

Most influencer discovery tools are built for marketers: annual contracts, minimum spend, CSV exports, manual review. If you're a developer building a feature that needs influencer data — say, a partnership recommendation engine or a creator discovery widget — none of that fits your workflow.

I needed a pay-per-query approach. Here's what I'm using.

One API Call

import httpx

response = httpx.get(
    "https://api.socialintel.dev/v1/search",
    params={
        "query": "yoga instructor",
        "country": "United States",
        "gender": "woman",
        "followers_min": 5000,
        "followers_max": 500000,
        "limit": 20
    }
)

data = response.json()
for creator in data.get("results", []):
    print(f"{creator['username']} — {creator['followers']:,} followers")

The endpoint returns real Instagram accounts filtered to your spec. First call gives you a free sample to validate the data quality.

What Comes Back

{
  "results": [
    {
      "username": "...",
      "followers": 124000,
      "category": "Yoga & Meditation",
      "gender": "woman",
      "country": "United States",
      "city": "Los Angeles",
      "email": "studio@...",
      "is_verified": false
    }
  ]
}

Real follower counts, category tags, location, and contact email where available. No mock data, no stale snapshots.

Useful Filters for Yoga Discovery

The API supports everything I needed for targeting:

category — "Yoga & Meditation", "Fitness & Wellness", "Health & Lifestyle"
city — "Los Angeles", "New York", "Austin" — great for local studio partnerships
followers_min / followers_max — find micro-influencers (5K–50K) or macro creators
gender — "woman" or "man"
country — full name, e.g. "United Kingdom", "Canada"

Why x402 Instead of API Keys?

The endpoint uses the x402 payment protocol — $0.10 USDC per search on Base network. No signup, no monthly subscription, no rate limit tiers. Your AI agent can discover the endpoint and pay autonomously.

If you're building an agentic workflow, the MCP server lets Claude or any MCP-compatible agent run searches directly:

npx -y @smithery/cli@latest run @socialinteldev/social-intel-mcp

Try It Without Paying

curl "https://api.socialintel.dev/v1/search/free?query=yoga+instructor&country=United+States"

Returns a small preview — enough to see the data format and validate it works for your use case.

Docs and pricing: https://socialintel.dev

How to Find Fitness Influencers Programmatically (No Scraping, No API Keys)

Sebastian Wallinstabot project — Sat, 21 Mar 2026 00:08:16 +0000

I've been building AI agents that do influencer research, and the boring part was always finding the right accounts. Scraping Instagram was either slow, fragile, or got us rate-limited. Paid APIs wanted annual contracts.

Then I found a pay-per-request approach. No account setup, no monthly fees — just pay per search with USDC.

Here's how it works.

The Use Case

I'm building a fitness app that wants to find micro-influencers in the gym/workout niche — specifically women in the US with 10K-100K followers. The old approach: scrape hashtags, filter manually, hope nothing breaks. The new approach: one API call.

The Code

import httpx

response = httpx.get(
    "https://api.socialintel.dev/v1/search",
    params={
        "query": "fitness influencer",
        "country": "United States",
        "gender": "woman",
        "followers_min": 10000,
        "followers_max": 100000,
        "limit": 20
    }
)

# First call returns a free sample to validate data quality
print(response.json())

The first call returns a free sample so you can validate the data quality before paying. Paid calls ($0.10 each) use the x402 protocol — your AI agent handles the payment automatically.

Sample Output

{
  "results": [
    {
      "username": "...",
      "followers": 87400,
      "category": "Fitness & Wellness",
      "gender": "woman",
      "country": "United States",
      "email": "contact@...",
      "is_verified": false
    }
  ]
}

Real accounts, real follower counts, real contact emails where available.

Filters Available

country — "United States", "United Kingdom", "Germany", etc.
gender — "man" or "woman"
followers_min / followers_max — any range
city — specific cities like "Los Angeles" or "New York"
category — fitness, yoga, nutrition, sports, etc.

Why x402 Instead of Traditional API Keys?

The x402 protocol (built by Coinbase) lets AI agents pay for API calls directly — no human in the loop. Your agent discovers the endpoint, sees the price ($0.10), pays in USDC, gets the data. No monthly billing, no rate limit surprises.

For fitness app development: prototype today, scale tomorrow. You only pay for searches you run.

Try It Free First

The free endpoint gives you a preview without payment — useful for testing your filters:

curl "https://api.socialintel.dev/v1/search/free?query=yoga+instructor&country=United+States&gender=woman"

Full docs + MCP server (for Claude/Cursor): https://socialintel.dev

I paid for an Instagram API with 3 lines of code — no signup, no API keys

Sebastian Wallinstabot project — Fri, 20 Mar 2026 13:46:34 +0000

I built a pay-per-request Instagram influencer search API using the x402 protocol — HTTP 402 payments in USDC on Base. This week I tested it with AgentCash to verify the full agent-to-API payment loop.

Here is the entire workflow:

Step 1: Discover the API

AgentCash automatically discovers any x402-compatible API:

discover_api_endpoints("https://socialintel.dev")

Returns all endpoints with pricing:

GET /v1/search — $0.10–$0.26 depending on result count
GET /v1/search/free — 3 free results for testing

Step 2: Make a paid search

curl "https://socialintel.dev/v1/search?query=travel&country=US&limit=5"
# Returns: HTTP 402 Payment Required
# After x402 payment: 5 travel influencer profiles

Verified result: 5 travel photographer profiles, follower counts 78k–85k.

On-chain proof: 0x294ec95cd8c76581e326a3b969f54e9f6a0561489cd7cdb2da34ff372eca6c77

Why x402 matters for AI agents

Traditional APIs need API key registration, monthly subscriptions, and a human to set up billing.

x402 APIs need a funded wallet and one line of code. The agent pays autonomously. No human in the loop.

Try it

Free demo (no wallet needed):

GET https://socialintel.dev/v1/search?query=travel&demo=true

Paid search: point any x402 client at https://socialintel.dev/v1/search

Building in public. Launching on Product Hunt March 30.

I stopped scraping Instagram — my AI agent pays per search instead (Python + x402)

Sebastian Wallinstabot project — Fri, 20 Mar 2026 05:01:18 +0000

The scraper treadmill

Every developer who has built an influencer tool or lead gen pipeline knows the cycle:

Find an Instagram scraper library
It works great for a week
Instagram blocks your IP or rotates its internal API
Find a proxy provider to stay ahead of bans
Repeat every 3-6 months when the scraper breaks again

After going through this twice, I started looking for a stable alternative. I found one that uses a different model entirely: you pay per search instead of running a subscription.

How it works: x402 payments

Social Intel is an Instagram influencer search API that uses the x402 protocol â€” an HTTP extension where your client sends a USDC micropayment before getting data.

No API keys. No monthly plan. No rate limits per tier.

The flow in Python:

import httpx

# Step 1 â€” hit the endpoint, get 402 back
response = httpx.get(
    "https://socialintel.dev/v1/search",
    params={"query": "travel photographer", "country": "United States", "limit": 10}
)
# response.status_code == 402
# response.json() contains payment instructions

# Step 2 â€” pay $0.10 USDC on Base (handled by your x402 client)
# Step 3 â€” re-request with payment proof header
# Step 4 â€” get the data

There are x402 client libraries for Python, JS, and Go. If you use AgentCash, the payment is completely transparent â€” you call fetch() and it handles 402 flows automatically.

What the data looks like

Free demo (try it without any wallet setup):

curl "https://socialintel.dev/v1/search?query=travel+photographer&limit=3&demo=true"

Real output from that query:

{
  "demo": true,
  "results": [
    {
      "username": "bokehm0n",
      "full_name": "Johannes Hulsch | Travel Photographer",
      "followers": 548918,
      "is_verified": false,
      "public_email": "[available in paid response â€” ~50% of accounts]"
    },
    {
      "username": "tripwithmp",
      "full_name": "Mujeeb Padikka | Travel Photographer | Kerala | India",
      "followers": 452793,
      "is_verified": true,
      "public_email": "[available in paid response â€” ~50% of accounts]"
    }
  ]
}

The paid response adds: country, gender, category, bio, media count, and business email (~50% of profiles have one).

Filters that actually work

results = client.search(
    query="yoga instructor",
    country="United Kingdom",   # or ISO code: "GB"
    gender="woman",             # "man" or "woman"
    min_followers=10000,
    max_followers=500000,
    is_verified=False,
    limit=50
)

As an MCP tool (for AI agents)

If you are building with Claude or another MCP-compatible agent framework, there is a one-liner install:

uvx social-intel-mcp

Your agent calls search_leads() and the x402 payment happens automatically â€” the MCP server manages the wallet. Your agent just gets results without any payment logic in your code.

The economics

Option	Monthly cost for 100 searches
Modash / HypeAuditor	$500+ (minimum plan)
Proxy + scraper	$50-150
Social Intel (x402)	$10

For hobbyist projects, internal tools, or proof-of-concepts: $10/month for on-demand data beats $500/month for a SaaS subscription you may not fully utilize.

Try the free demo: curl "https://socialintel.dev/v1/search?query=fitness+influencer&demo=true"

Full docs and quickstart: socialintel.dev/docs

Pay-per-request APIs from Python: skip the API key, pay with USDC instead

Sebastian Wallinstabot project — Mon, 16 Mar 2026 02:01:06 +0000

API keys are friction. Signup, billing portal, monthly minimums, credential rotation. For agents and scripts that call APIs occasionally, there's a better model: pay per call, no account needed.

The x402 protocol does this at the HTTP level. Your script gets a 402 Payment Required response, pays automatically, and retries. Here's how it works from Python.

Install

pip install "x402[httpx,evm]"

Call a pay-per-request API

import asyncio
import httpx
from x402 import x402Client
from x402.http.clients.httpx import x402AsyncTransport
from x402.mechanisms.evm.exact import ExactEvmScheme
from x402.mechanisms.evm import EthAccountSigner
from eth_account import Account

# Wire up your wallet once
account = Account.from_key("0xYOUR_PRIVATE_KEY")
signer = EthAccountSigner(account)
wallet = x402Client()
wallet.register("eip155:*", ExactEvmScheme(signer=signer))

async def search(query: str):
    transport = x402AsyncTransport(wallet)
    async with httpx.AsyncClient(transport=transport) as client:
        r = await client.get(
            f"https://socialintel.dev/v1/search?query={query}&country=US"
        )
        return r.json()

results = asyncio.run(search("fitness influencers"))
print(results)

The x402AsyncTransport intercepts the 402, creates a signed EIP-3009 USDC authorization, retries the request with the payment header. No signup. No account. $0.10 USDC per call, deducted directly from your wallet.

Test without spending USDC first

Most x402 APIs offer a free demo mode. Social Intel does:

curl "https://socialintel.dev/v1/search?query=fitness&country=US&demo=true"

Returns 3 results, no payment required. Use this to verify the API returns what you need before putting real money on it.

Get USDC on Base

Coinbase → buy USDC → withdraw to Base network (direct Base withdrawal supported)
Or bridge from any EVM chain via bridge.base.org
Minimum balance: $1 covers 10 requests

What the 402 response looks like

When you call without a wallet, you get:

{
  "x402Version": 2,
  "error": "Payment required",
  "accepts": [{
    "scheme": "exact",
    "network": "eip155:8453",
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "amount": "100000",
    "payTo": "0xB1Acd9E0269023546074400A434e703B646AaBBa"
  }]
}

amount is in USDC's 6-decimal units, so 100000 = $0.10. The x402 client reads this and pays before you ever see it.

Zero-wallet alternative

Don't have USDC set up? AgentCash wraps the whole thing:

npx agentcash@latest fetch "https://socialintel.dev/v1/search?query=fitness&country=US"

It manages a wallet for you, funded via their dashboard. Useful for quick tests.

Why this matters for agents

AI agents make thousands of API calls. API keys mean:

Credentials that can be stolen or rotated
Monthly billing even during quiet periods
Rate limits tied to account tier, not actual usage

x402 lets an agent carry a wallet and pay only for what it uses. Each request is a transaction on-chain — auditable, reversible if the API misbehaves, and composable with other on-chain logic.

The Social Intel API is one example. Search Instagram influencers by niche, follower count, country, gender — $0.10 per query, no account:

GET https://socialintel.dev/v1/search?query=travel&country=US&min_followers=10000

Try the free demo: https://socialintel.dev/v1/search?query=fitness&demo=true

How to Find Travel Influencers Programmatically with AI Agents

Sebastian Wallinstabot project — Sun, 15 Mar 2026 16:46:41 +0000

Finding the right travel influencer used to mean hours scrolling Instagram manually or paying $300/month for a platform you use twice. Here's a faster way: an API that costs $0.10 per search, requires no signup, and works directly inside AI agents.

The Problem With Influencer Tools

Most influencer search platforms have the same model: monthly subscription, minimum contract, clunky web UI. That works if you run campaigns constantly. It doesn't work if you're an agency dev building an automation, or a brand team that needs 10 searches total this quarter.

How the API Works

Social Intel is a search API for Instagram influencer data. It uses the x402 payment protocol — you pay $0.10 USDC per request, no account required.

A travel influencer search looks like this:

curl "https://socialintel.dev/v1/search?query=travel&country=US&min_followers=10000"

Without a wallet, you'll get a 402 response with payment instructions. To try it free:

curl "https://socialintel.dev/v1/search?query=travel+influencer&demo=true"

The response includes username, follower count, category, verification status, and public email (for business accounts).

Filtering By Niche

You can combine filters for more specific results:

# Micro travel influencers in specific country
curl "https://socialintel.dev/v1/search?query=travel&country=France&min_followers=5000&max_followers=50000"

# Verified travel accounts in the US
curl "https://socialintel.dev/v1/search?query=adventure+travel&country=US&is_verified=true"

# Travel + fashion crossover
curl "https://socialintel.dev/v1/search?query=travel+fashion&min_followers=20000"

Using It From an AI Agent

The API is also available as an MCP server, so Claude, Cursor, and other AI agents can search influencers autonomously.

Add this to your MCP config:

{
  "mcpServers": {
    "social-intel": {
      "command": "npx",
      "args": ["-y", "social-intel-mcp"]
    }
  }
}

Then ask your agent: "Find me 20 travel influencers in Australia with 10k-100k followers." The agent calls the API, pays $0.10 USDC from its wallet, returns structured results.

What You Get Back

{
  "results": [
    {
      "username": "wanderlust.au",
      "followers": 47200,
      "category": "Travel",
      "is_verified": false,
      "public_email": "hello@wanderlust.au"
    }
  ],
  "count": 23,
  "query": "travel",
  "country": "Australia"
}

The public_email field is the high-value one — it's only populated on business accounts, but when it is, you skip the DM-cold-outreach-wait loop entirely.

No Subscription, No Lock-In

The x402 protocol means each request is atomic: your x402 client pays on Base chain, gets results, done. No API key rotation, no usage cap negotiation, no billing dashboard.

If you're building a campaign tool, influencer matching workflow, or just want to pull a list without a monthly commitment: try the live demo.

Full API docs and MCP setup: socialintel.dev/docs

We Launched on Product Hunt — 2 Weeks Building an API Where AI Agents Pay Per Request

Sebastian Wallinstabot project — Thu, 12 Mar 2026 17:59:03 +0000

Two weeks ago I shipped a weird idea: an Instagram influencer search API where you pay per request using USDC, with no API keys, no signup, no monthly billing.

We're launching on Product Hunt this Monday, March 16: https://www.producthunt.com/products/social-intel

Here's the honest 2-week build-in-public report.

What it does

Send a GET request to get HTTP 402 then pay $0.10 USDC on Base chain to get JSON results with Instagram influencer data.

# Step 1: discover the price
curl https://socialintel.dev/v1/search?query=fitness&country=US&limit=20
# returns HTTP 402 with payment instructions

# Step 2: pay and retry (x402 client handles this automatically)
# returns JSON: 20 influencers with username, followers, category, public email

It also runs as an MCP server, so Claude Desktop and Cursor can search influencers directly. The agent pays autonomously from its own wallet.

2-week numbers (honest)

Metric	Value
API hits (payment_402 events)	50
Paying customers	1
Revenue	$1.20 USDC
Gross margin	99.7%
Conversion rate	0% (0 paying after the first customer)

The 0% conversion is the real story. Developers find the API, hit the 402, and... stop. Most don't have USDC on Base ready to go.

What worked

Distribution: Listed on x402scan, Smithery, mcp.so, Glama, awesome-mcp-servers, and registered on-chain via ERC-8004. First paying customer came from one of these discovery channels (Japan, Node.js MCP client).

Pricing model: $0.10/request at 99.7% margin is sustainable even at low volume.

MCP integration: Several developers reached out specifically about the Claude Desktop + MCP use case. This is the right audience.

What didn't work

USDC friction: The biggest blocker. Even technical developers who understand the concept bounce when they realize they need USDC on Base. Fixed: free-tier endpoint is now live -- ?demo=true returns 3 results with no payment required.

GitHub outreach: Posted issues on 14 repos related to x402/MCP. Zero replies after 72 hours. Low-signal channel.

Reddit: Post removed by spam filter (karma 0 account). Need to build karma before posting links.

The tech

FastAPI + FastMCP (Python)
x402 protocol (Coinbase open standard -- HTTP 402 for machine payments)
USDC on Base + Solana (multi-chain via x402 SDK 2.3.0)
DataLikers as the Instagram data source
Postgres for caching + financial tracking
Coolify for hosting

Full backend architecture: the x402 middleware intercepts requests, issues 402 responses with payment schemas, verifies on-chain payments via Coinbase CDP facilitator, and passes through to the data layer.

What's next

~~Free tier endpoint~~ -- SHIPPED: ?demo=true returns 3 results, no wallet needed
Engagement rate data -- the most-requested feature
TON chain support -- pending x402 SDK PR merge
Max followers filter -- currently you can't isolate micro-influencers (<10K)

Support on PH

If you're building with AI agents, x402, or MCP -- we'd love your upvote this Monday: https://www.producthunt.com/products/social-intel

And if you have USDC on Base: try it live at https://socialintel.dev

MCP server (open source): https://github.com/socialinteldev/social-intel-mcp

We're Launching on Product Hunt Monday — 2 Weeks Building an API Where AI Agents Pay Per Request

Sebastian Wallinstabot project — Thu, 12 Mar 2026 17:48:17 +0000

Two weeks ago I shipped a weird idea: an Instagram influencer search API where you pay per request using USDC, with no API keys, no signup, no monthly billing.

We're launching on Product Hunt this Monday, March 16 — upvote here: https://www.producthunt.com/products/social-intel

Here's the honest 2-week build-in-public report.

What it does

Send a GET request → get HTTP 402 → pay $0.10 USDC on Base chain → get JSON results with Instagram influencer data.

# Step 1: discover the price
curl https://socialintel.dev/v1/search?query=fitness&country=US&limit=20
# → HTTP 402 with payment instructions

# Step 2: pay and retry (x402 client handles this automatically)
# → JSON: 20 influencers with username, followers, category, public email

It also runs as an MCP server, so Claude Desktop and Cursor can search influencers directly. The agent pays autonomously from its own wallet.

No wallet? Try the free tier: GET /v1/search?query=fitness&demo=true returns 3 results instantly — no payment required.

2-week numbers (honest)

Metric	Value
API hits (payment_402 events)	50
Paying customers	1
Revenue	$1.20 USDC
Gross margin	99.7%
Conversion rate	0% (0 paying after the first customer)

The 0% conversion is the real story. Developers find the API, hit the 402, and... stop. Most don't have USDC on Base ready to go.

What worked

Pricing model: $0.10/request at 99.7% margin is sustainable even at low volume.

MCP integration: Several developers reached out specifically about the Claude Desktop + MCP use case. This is the right audience.

What didn't work

USDC friction: The biggest blocker. Even technical developers who understand the concept bounce when they realize they need USDC on Base. Fixed: free-tier endpoint is now live — ?demo=true returns 3 results with no payment required.

GitHub outreach: Posted issues on 14 repos related to x402/MCP. Zero replies after 72 hours. Low-signal channel.

Reddit: Post removed by spam filter (karma 0 account). Need to build karma before posting links.

The tech

FastAPI + FastMCP (Python)
x402 protocol (Coinbase open standard — HTTP 402 for machine payments)
USDC on Base + Solana (multi-chain via x402 SDK 2.3.0)
DataLikers as the Instagram data source
Postgres for caching + financial tracking
Coolify for hosting

What's next

~~Free tier endpoint~~ — SHIPPED: ?demo=true returns 3 results, no wallet needed
Engagement rate data — the most-requested feature
TON chain support — pending x402 SDK PR merge
Max followers filter — currently you can't isolate micro-influencers (<10K)

Support on PH

If you're building with AI agents, x402, or MCP — we'd love your upvote this Monday: https://www.producthunt.com/products/social-intel

Try it live: https://socialintel.dev/v1/search?query=fitness&demo=true

MCP server (open source): https://github.com/socialinteldev/social-intel-mcp

How I Built an Instagram API That AI Agents Pay For (x402 + FastAPI + MCP)

Sebastian Wallinstabot project — Wed, 11 Mar 2026 15:54:12 +0000

The Problem: APIs Assume Humans

Most APIs are designed for human developers -- you sign up, get an API key, set up billing, and manage credentials. But AI agents don't have credit cards or email inboxes. They're scripts that run autonomously, sometimes thousands of times per day.

I wanted to build something different: an API where AI agents are the first-class customer, not an afterthought.

What I Built

Social Intel API is an Instagram influencer search endpoint with one unusual property: it accepts USDC micropayments instead of API keys.

Here's the entire authentication flow:

# Step 1: Send request with no auth
curl "https://socialintel.dev/v1/search?query=fitness&country=US"

# Server returns HTTP 402:
# { "x402Version": 1, "accepts": [{ "scheme": "exact", "network": "base", "maxAmountRequired": "100000" }] }

# Step 2: Pay $0.10 USDC on Base chain
# Step 3: Retry with X-Payment header

No API key. No signup. No monthly billing. Just pay per request.

The x402 Protocol

x402 is a standard for machine-native payments using HTTP 402 (Payment Required).

The flow:

Client sends request
Server returns 402 with payment schema (amount, wallet, network)
Client pays on-chain (USDC on Base or Solana)
Client retries with X-Payment header containing payment proof
Server verifies and returns data

The whole thing takes ~1-2 seconds including on-chain settlement.

FastAPI Implementation

Using fastapi-x402:

from fastapi import FastAPI
from fastapi_x402 import X402Middleware
import os

app = FastAPI()
app.add_middleware(
    X402Middleware,
    facilitator_url="https://facilitator.payai.network",
    pay_to=os.environ["PAY_TO_ADDRESS"],
)

@app.get("/v1/search")
async def search(query: str, country: str = "US", limit: int = 20):
    results = await fetch_instagram_data(query, country, limit)
    return {"results": results}

One middleware line and any endpoint becomes pay-per-request.

Dynamic Pricing

def _dynamic_price(context) -> int:
    limit = int(context.get("query_params", {}).get("limit", 20))
    if limit <= 20:
        return 100_000  # $0.10 USDC
    return 100_000 + (min(limit, 100) - 20) * 2_000  # +$0.002 per result

MCP Server Integration

I wrapped this as an MCP server so Claude, Cursor, and other AI tools can search Instagram as a native tool.

Claude Desktop config:

{
  "mcpServers": {
    "social-intel": {
      "command": "python",
      "args": ["mcp_server.py"],
      "env": {"SOCIAL_INTEL_API_URL": "https://socialintel.dev"}
    }
  }
}

Ask Claude: "Find 20 fitness influencers in Germany with over 50k followers" -- it handles everything including payment.

What I Learned

The payment mechanics (x402 + fastapi-x402) are only ~20 lines. The real challenges:

Discovery -- How does an agent know your API exists? MCP servers help, but no universal registry yet.
Wallet management -- Agents need pre-loaded USDC. Most agent frameworks don't support this yet.
Error handling -- Return clean 402s, not 500s. Agents need to retry intelligently.

Try It

pip install x402

from x402.client import X402Client

client = X402Client(private_key="YOUR_BASE_WALLET_PRIVATE_KEY", network="base-mainnet")
response = client.get("https://socialintel.dev/v1/search", params={"query": "fitness"})
print(response.json())

MCP server source: github.com/socialinteldev/social-intel-mcp

Happy to answer questions about x402, FastAPI, or MCP patterns in the comments.