We Shipped an x402 Agentic API for LinkedIn Data

Two months ago we shipped Linked Panda's main product. Today we shipped something different: an x402-payable agentic API that any AI agent can call directly. No signup. No API key. No contract. Pay $0.05 in USDC per profile enrichment, $0.05 per verified work email, and $0.05 per LinkedIn post engagement lookup.

The endpoints are live, the OpenAPI spec is public, and the service is listed on the agentic.market bazaar so agents can discover it autonomously.

This post is for engineers, AI agent builders, and founders building agentic products. If you are here for "how do I find buyers on LinkedIn?", start with the existing guide to finding who liked a LinkedIn post or tracking competitor LinkedIn engagement. If you are here because you want an agent to call LinkedIn-derived B2B data from inside an autonomous workflow, keep reading.

Our thesis is simple: B2B data APIs that require API keys, signup flows, seats, and contracts do not fit how agents actually work. Agents need APIs they can discover, evaluate, pay for, and call without a human stopping to fill out a form. x402 makes that possible, and we wanted builders to have real production endpoints to use instead of another toy weather API.

This post walks through the four endpoint shapes, the payment flow, working code, three things you can build, real costs, and the limits of v1.

What We Shipped

Here is the current surface area. The OpenAPI spec is the source of truth if anything here changes.

Profile enrichment returns a normalized B2B profile record: name, headline, current company and role, location, experience, education, hiring and open-to-work flags, follower count, premium and verified status, and work history. The bulk variant lets an agent enrich up to 25 LinkedIn URLs or IDs in one call, which matters for cost predictability inside loops.

Single-profile lookup is the lower-friction path for agent tools that only have one target at a time. Use GET /agent/v1/profiles/{linkedinId} when you already have the real LinkedIn public identifier from a person profile URL, or GET /agent/v1/profiles/enrich?linkedinUrl=... when your browser or search layer hands you a raw URL.

For profile endpoints, linkedinId means the public identifier from a real linkedin.com/in/<linkedinId> person profile. Do not spend on placeholders such as test-profile, alex-example, or replace-with-real-linkedin-id; pass the real profile URL instead if you have any doubt.

Email lookup returns a verified work email tied to a LinkedIn profile, with a qualityScore from 0 to 1, a deliverable flag, catch-all detection, and provider verification status. This is the verified email layer most agentic enrichment workflows need before they hand data to a CRM, sequence tool, or internal research system.

Post engagement returns engagement data for a public LinkedIn post URL, including reactors, commenters, full comment text, actor profile information, and pagination tokens. This is the endpoint that turns engagement-based outbound from a SaaS workflow into something an agent can execute.

Every endpoint is read-only. Agents can ingest data and act on it elsewhere, but they cannot use this API to write to LinkedIn, send messages, create connection requests, or take account-attached actions. That boundary is deliberate.

A 90-Second Primer on x402

x402 revives HTTP 402 "Payment Required", the status code that has been sitting mostly unused since the early web. The protocol, documented at x402.org, lets a client hit an endpoint without auth, receive a structured payment requirement in the 402 response, sign a payment payload with a wallet, and retry the request with payment proof.

For agents, this changes the integration shape.

• No API keys. An agent that calls ten providers should not need ten dashboards and ten long-lived secrets. x402 replaces provider-specific keys with a wallet.
• Pay per call. The unit of purchase is the request, not a monthly seat. That fits agents that build lists, briefs, or research outputs on demand.
• Fast settlement. Linked Panda settles USDC on Base mainnet (eip155:8453). See the Base network docs if you need chain details.
• Discoverable services. Bazaars such as agentic.market expose service metadata, pricing, inputs, and outputs so agents can decide whether a provider is worth calling.
• Stateless authentication. The agent does not need to maintain a session. Each paid call carries its own payment proof.

The flow looks like this:

1. Agent calls GET /agent/v1/profiles/satyanadella with no auth header.
2. Server responds 402 Payment Required with network, asset, amount, destination address, timeout, and resource metadata.
3. Agent signs an x402 v2 payment payload referencing those parameters.
4. Agent retries the same URL with a payment header.
5. Server verifies the payment, settles through the x402 flow, and returns the data with 200 OK.

You do not need to become the protocol expert to use the API. Most agents should use an SDK or HTTP client wrapper and let it handle the 402, signing, and retry. But understanding the wire flow helps when you debug the first integration.

The Agent Payment Flow, With Real Headers

Start with the naive call. It costs nothing because it does not include payment proof:

curl -i https://api.linkedpanda.com/agent/v1/profiles/satyanadella

Response:

HTTP/2 402
content-type: application/json; charset=utf-8
payment-required: <base64-encoded payment requirement>

{
  "x402Version": 2,
  "accepts": [
    {
      "scheme": "exact",
      "network": "eip155:8453",
      "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "amount": "50000",
      "payTo": "0xe740D5701749D262dA5E4Fcb9f814c5B6D91Cf46",
      "maxTimeoutSeconds": 300,
      "extra": {
        "name": "USD Coin",
        "version": "2"
      }
    }
  ],
  "resource": {
    "url": "https://api.linkedpanda.com/agent/v1/profiles/satyanadella",
    "description": "LinkedIn profile enrichment API for one B2B lead",
    "mimeType": "application/json",
    "serviceName": "Linked Panda",
    "providerName": "Linked Panda",
    "providerUrl": "https://linkedpanda.com",
    "category": "Data"
  }
}

The important fields are compact:

• amount: "50000" means 50,000 micro-USDC, or $0.05 with USDC's 6 decimals.
• network: "eip155:8453" is Base mainnet, chain ID 8453.
• asset is the USDC contract on Base.
• payTo is Linked Panda's settlement address.
• resource describes the endpoint the payment unlocks.

The signed call retries the same request with a payment payload:

curl -i \
  -H "PAYMENT-SIGNATURE: <base64-encoded x402 v2 payment payload>" \
  https://api.linkedpanda.com/agent/v1/profiles/satyanadella

On success, the response is 200 OK with the normalized profile JSON.

For signing, use whichever x402 client is stable in your stack at the time you build. The current ecosystem includes Coinbase's x402 packages, framework-specific wrappers, requests or fetch adapters, and direct signing patterns with viem, ethers.js, or eth-account when you want to own the flow.

x402 v2 is still young. Header names, SDK ergonomics, and payload helpers may keep moving. Treat our OpenAPI spec as the source of truth for Linked Panda's endpoint shape, and treat x402.org as the protocol reference.

For local development, Base Sepolia (eip155:84532) is the right place to test payment flows without spending mainnet USDC. The production Linked Panda endpoints currently settle on Base mainnet.

Quickstart: Enrich a LinkedIn Profile in Python

Here is the simplest working pattern with the Python x402 requests client. Pin the package version in production; x402 SDKs are moving quickly.

# pip install "x402[requests]" eth-account
import os
from eth_account import Account
from x402 import x402ClientSync
from x402.http.clients import x402_requests
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client

client = x402ClientSync()
account = Account.from_key(os.environ["AGENT_PRIVATE_KEY"])
register_exact_evm_client(client, EthAccountSigner(account))

with x402_requests(client) as session:
    response = session.get(
        "https://api.linkedpanda.com/agent/v1/profiles/satyanadella",
        timeout=60,
    )
    response.raise_for_status()

profile = response.json()
print(f"{profile['firstName']} {profile['lastName']} - {profile['headline']}")
print(f"Company: {profile['companyName']} ({profile['companyDomain']})")
print(f"Location: {profile['locationCity']}, {profile['locationCountryFull']}")
print(f"Hiring: {profile['hiring']}, Open to work: {profile['openToWork']}")

The client handles the 402, signs the payment payload, retries the request, and returns the paid response. Cost: $0.05 USDC.

For production loops, bulk enrichment is the default:

with x402_requests(client) as session:
    response = session.post(
        "https://api.linkedpanda.com/agent/v1/profiles/enrich",
        json={
            "profiles": [
                {"linkedinId": "satyanadella"},
                {"linkedinUrl": "https://www.linkedin.com/in/satyanadella/"},
            ]
        },
        timeout=120,
    )
    response.raise_for_status()

profiles = response.json()["profiles"]

Cost: $0.05 times the number of profiles, capped at $1.25 for the max batch of 25.

The practical advantage is not only price. Bulk keeps agent loops simpler. If your agent collects everyone who engaged with a post, it can enrich 25 profiles with one payment instead of running 25 separate payment handshakes.

The single-profile GET endpoint accepts a linkedinId query parameter, a linkedinUrl query parameter, or the path shortcut /agent/v1/profiles/{linkedinId}. Agents often have raw LinkedIn URLs from browsing tools. The linkedinUrl form means they do not need to parse the ID first.

Three Things to Build

The interesting part of an agent-payable B2B data API is not that you can call an endpoint. It is that you can compose small paid reads into workflows that used to require a SaaS login, a data contract, or a human operator.

Build 1: An Autonomous Warm Prospect Agent

The setup: an agent watches a list of LinkedIn posts from your own team, competitors, partners, or category creators. It turns engagers into qualified, contactable leads without waiting for a human to export a CSV.

The loop is straightforward:

1. Read post URLs from a config file or database.
2. For each post, call /agent/v1/posts/reactions to get reactors and commenters.
3. Bulk enrich the engager profiles with /agent/v1/profiles/enrich.
4. Filter enriched profiles against your ICP logic: title, seniority, company size, geography, industry, or account list.
5. For ICP-fit profiles, call /agent/v1/profiles/email to find a verified work email.
6. Write the result to the downstream system: CSV, CRM, outbound tool, queue, vector store, or research database.

def warm_prospect_run(post_urls, icp):
    leads = []
    for post_url in post_urls:
        engagement = paid_get(
            "/agent/v1/posts/reactions",
            params={"postUrl": post_url},
        )
        actors = [item["actor"] for item in engagement["reactions"]]
        actors += [item["actor"] for item in engagement["comments"]]

        for batch in chunks(actors, 25):
            profiles = paid_post(
                "/agent/v1/profiles/enrich",
                json={"profiles": linkedin_inputs(batch)},
            )["profiles"]
            for profile in profiles:
                if matches_icp(profile, icp):
                    email = paid_get(
                        "/agent/v1/profiles/email",
                        params={"linkedinId": profile["linkedinId"]},
                    )
                    leads.append({**profile, "email": email, "sourcePost": post_url})
    return leads

The economics are easy to reason about. A post with 100 engagers, of which 25 pass ICP filters, costs roughly $0.05 for engagement lookup, $5.00 for 100 profile enrichments, and $1.25 for 25 email lookups. Total: $6.30 for 25 ICP-fit, contactable warm leads.

The manual version of this workflow usually has four handoffs: export engagement, enrich profiles, filter in a spreadsheet, then import the survivors into a CRM or sequence tool. x402 removes the procurement and key-management layer so an agent can run the same loop directly.

Build 2: A LangChain Tool for LinkedIn Enrichment

If you build inside LangChain, LlamaIndex, or a similar framework, Linked Panda's API is a clean tool target because it is read-only, stateless, and micro-priced. The tool can declare its cost and return structured JSON that the agent can reason over.

from langchain.tools import StructuredTool

def enrich_linkedin_profile(linkedin_id: str) -> dict:
    """Enrich a LinkedIn profile by ID. Costs $0.05 USDC per call."""
    with x402_requests(client) as session:
        response = session.get(
            f"https://api.linkedpanda.com/agent/v1/profiles/{linkedin_id}",
            timeout=60,
        )
        response.raise_for_status()
        return response.json()

linkedin_tool = StructuredTool.from_function(
    func=enrich_linkedin_profile,
    name="enrich_linkedin_profile",
    description=(
        "Enriches a LinkedIn profile and returns name, role, company, "
        "location, work history, and public profile metadata."
    ),
)

From there, the agent prompt can decide when profile enrichment is worth spending $0.05. That budget awareness matters. Agent frameworks route better when tools are predictable: clear input, clear output, no session state, no hidden subscription boundary, and a small known marginal cost.

This is also a better fit for evaluation. If an agent enriches ten profiles during a run, you can measure exactly what it spent and whether the downstream output justified the calls. The tool either improved the research or it did not.

A private internal version can stay small: one enrichment function, one email lookup function, and one post engagement function exposed to a larger research agent. The wrapper is compact enough that the architecture decision is mostly about when the agent should spend, not how to connect.

Build 3: A Buying Committee Research Agent

A more interesting pattern starts from an account instead of a person.

Given a company domain, the agent searches for likely buying-committee members, enriches their LinkedIn profiles, checks which people have public engagement or hiring signals, and returns a structured account brief. The search layer is out of scope for Linked Panda's v1 API. Use your own search, browser automation, or a complementary provider for discovery. Linked Panda handles the profile and email enrichment once the agent has candidates.

The output might look like this:

{
  "company": "example.co",
  "committee": [
    {
      "name": "Alex Example",
      "role": "VP Sales",
      "persona": "economic buyer",
      "signals": ["hiring", "active on LinkedIn"],
      "email": "alex@example.co"
    },
    {
      "name": "Jamie Sample",
      "role": "Director of RevOps",
      "persona": "technical evaluator",
      "signals": ["owns routing", "commented on outbound tooling"]
    }
  ],
  "summary": "Sales leadership is expanding SDR capacity and RevOps appears involved in vendor evaluation."
}

The point is not that this exact agent is a packaged product. The point is that the building blocks are now cheap and composable enough that one engineer can build a useful version in an afternoon. A workflow that used to imply an Apollo or ZoomInfo contract can start as $1 to $2 of USDC and a focused script.

The human-in-the-loop version has the same shape: search manually, enrich manually, summarize manually, then write notes into a CRM. The agentic version is the same graph with paid data calls at the nodes.

What This Costs in Practice

Concrete numbers help before you put a wallet in an agent.

Network fees on Base vary, but they are usually small enough that the data cost dominates the unit economics. Settlement happens through the x402 flow rather than through an invoice, seat, or monthly minimum.

The comparison is not "is $0.05 cheaper than a database subscription?" A traditional B2B data tool might run $50 to $500 per month per seat. That same budget covers 1,000 to 10,000 x402 enrichments, with no commitment and no account portal. For an agent that builds lists or briefs on demand, that is the right shape.

If your agent needs 50,000 or more calls per month, reach out. There is a path to a metered relationship that stays usage-based but adds operational support.

Limits and What Is Not in v1

The API is intentionally narrow.

Currently supported:

• Read-only access to LinkedIn profile enrichment, post engagement, and work email lookup
• USDC on Base mainnet for production x402 calls
• Base Sepolia for payment-flow testing
• x402 v2 payment protocol
• Up to 25 profiles per bulk enrichment request

Not yet supported:

• Writing to LinkedIn, including DMs, posts, connection requests, or account-attached automation. This is not planned because it breaks the read-only architecture.
• Streaming or webhook endpoints. Agents need to poll today.
• Other networks beyond Base. Interest is useful signal, but v1 is Base-first.
• First-party integrations for every agent framework. Wrappers are small enough that we would rather see the community shape them.

Coming next:

• Company-level enrichment: firmographics, hiring activity, and account metadata.
• Larger bulk batches: 100 and 250 profiles per call.
• High-volume pricing for callers that need operational support without giving up pay-as-you-go economics.

We are not going to overpromise the roadmap. Engineers can smell vaporware. The production endpoints above are the thing to build against now.

How to Start

1. Read the OpenAPI spec. Every endpoint, schema, and response shape is there.
2. Try a free 402 call. Run curl https://api.linkedpanda.com/agent/v1/profiles/satyanadella and inspect the payment requirement. You only spend when you send valid payment proof.
3. Get USDC on Base. Coinbase, any Base-compatible wallet, or a bridge from Ethereum mainnet works. $5 to $10 in USDC is enough to test every endpoint and run a real agent loop.

For SaaS readers who landed here by accident: the same data powers Linked Panda's product. If you want LinkedIn engagement to turn into enriched leads and CRM-ready records without writing code, sign up here instead — your first payment comes with 3× credits as a one-time welcome bonus.

FAQ

Do I need a Linked Panda account to call the x402 API?

No. The x402 endpoints are designed for wallet-paid access without signup or an API key. Call an endpoint once to receive the 402 payment requirement, then retry with a valid x402 payment payload.

Which network and asset does the API use?

The production endpoints accept USDC on Base mainnet (eip155:8453). Base Sepolia is useful for testing payment flows, but the live Linked Panda data endpoints currently settle on Base mainnet.

Can agents write to LinkedIn through this API?

No. The API is read-only. It returns LinkedIn-derived profile, email, and post engagement data, but it cannot send DMs, create connection requests, post content, or act through a LinkedIn account.

Why We Did This

Linked Panda's bet is that the next wave of B2B tooling will not only be SaaS apps with logins. Some teams will keep wanting a no-code product, and that is what the main Linked Panda app is for. But more serious outbound, research, and data workflows are being built by engineers wiring together agents, and those builders should not have to fight an API key portal before they can test one endpoint.

Shipping an x402 LinkedIn API is a small bet on that future. If we are right, this is the fastest way to get production LinkedIn-derived data into an agent. If we are wrong, we still have the SaaS product, and the API still serves the developer audience that prefers code over UI.

Either way, the data is the data. Whether you call it through our app or through a $0.05 HTTP request, you get the same enriched LinkedIn profile, the same verified work email, and the same post engagement signal.

We will ship more endpoints as the protocol matures. If you are building something interesting, email us. We want to know what to build next.