# Using APIs and datasets from local agent harnesses

> Autonomous agents running in local Python or Node harnesses can discover and consume paid APIs and datasets directly through Sella. By initializing an MCP client and connecting a provisioned agent wallet, your local agent inspects schemas for free and executes pay-per-call queries settled in USDC over x402 on Base and Solana.

- Source: https://selltoagent.dev/blog/using-apis-and-datasets-from-local-harnesses
- Author: Maya
- Published: 2026-08-31
- Category: building
- Tags: building, mcp, protocols, x402, catalogue
- Written for: operators and agents

---

Most developers building autonomous agent loops run their code locally. Whether you are orchestrating agents in Python with LangChain and LlamaIndex, running custom TypeScript event loops, or working inside IDEs like Cursor and Claude Desktop, your agent needs real-world data and external tools to complete complex tasks.

Historically, giving a local agent access to third-party tools meant managing dozens of separate API accounts, signing up for monthly subscriptions, and hardcoding credit cards into local environment variables. If an agent needed to run three web searches, pull two blockchain state proofs, and download one training dataset, you had to subscribe to three different SaaS vendors and pay upfront minimums.

In an [agent marketplace](/answers/what-is-an-agent-marketplace), you connect your local harness to a single [Model Context Protocol](/answers/what-is-mcp) (MCP) endpoint. Your local agent searches the catalogue, inspects data schemas for free, and pays for API calls and dataset downloads on demand using x402 micropayments in USDC.

Here is the complete guide to initializing Sella inside a local agent harness, finding verified tools, and executing paid calls safely.

- Single MCP endpoint: Connect once to access thousands of APIs and datasets without managing individual vendor keys.
- Free sandbox discovery: Search the catalogue, inspect data schemas, and test tools without spending funds.
- Preflight price checks: Run dry-run calls to verify exact per-call USDC prices before committing budget.
- Automatic settlement: Payments clear per request on Base and Solana directly from your local agent wallet.

## How the local harness architecture works

When an agent runs in a local harness, it interacts with Sella through a standard JSON-RPC interface over MCP.

![A solid milled aluminum hardware bridge connected by a braided cable to a technical notebook.](/assets/blog/using-apis-and-datasets-from-local-harnesses.jpg)

_Bridging local execution loops to machine-payable infrastructure: local harnesses discover, inspect, and pay over MCP._

The interaction pattern divides into two distinct operational phases:

1. **Free discovery phase**: The agent calls `search_catalog`, `describe_catalog`, and `get_listing`. These tools run in a keyless, rate-limited sandbox and return complete Application Data Contract (ADC) metadata, schema types, and pricing terms without touching your balance.
2. **Paid execution phase**: When the agent calls `call_api` or `get_dataset`, the request is authenticated via the agent's API key. The Sella backend proxy checks operator spend limits and settles the micro-payment in USDC over x402 on Base or Solana.

Because the settlement is machine-native, your local harness does not need to handle invoicing, credit card forms, or vendor onboarding.

## Full initialization steps for your local harness

Connecting your local harness to Sella takes four sequential steps.

**Step 1: Onboard your agent and initialize the wallet**

Your agent needs an API key and a local wallet configuration. Choose one of the three supported onboarding methods:

- **Method A (Dashboard Setup Code)**: Open the Sella dashboard in your browser, generate a one-time setup code (such as `SELLA-XXXX-XXXX-XXXX-XXXX`), and pass it to your local agent.
- **Method B (In-Band Email Authentication)**: In your agent code, call `sella_auth_start` with your email. Check your inbox for the 6-digit verification code, and call `sella_auth_complete` to receive your credentials.
- **Method C (Command Line)**: Run `npx sella-cli init` in your terminal to generate credentials automatically.

When onboarding completes, save the returned `walletConfig` to `~/.sella-wallet.json` and keep the `apiKey` in your local `.env` file.

**Step 2: Configure your local MCP client**

Add the Sella MCP server to your local environment. If you are using a configuration file (like in Claude Desktop, Cursor, or a local harness runner), add the server definition:

```json
{
  "mcpServers": {
    "sella": {
      "url": "https://www.selltoagent.dev/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_SELLA_API_KEY"
      }
    }
  }
}
```

If you are using the Python MCP SDK in a custom agent harness, connect to the endpoint using an asynchronous HTTP session:

```python
import os
from mcp import ClientSession
from mcp.client.sse import sse_client

async def init_sella():
    api_key = os.getenv("SELLA_API_KEY")
    headers = {"Authorization": f"Bearer {api_key}"}
    async with sse_client("https://www.selltoagent.dev/api/mcp", headers=headers) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            return session
```

**Step 3: Discover endpoints and inspect schemas**

Before spending funds, have your agent search the catalogue for relevant capabilities using `search_catalog`:

```json
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "search_catalog",
    "arguments": {
      "query": "solana rpc archive",
      "kind": "api"
    }
  }
}
```

The agent inspects candidate listings with `get_listing`. As detailed in our post on [what an agent reads on a listing](/blog/what-an-agent-reads-on-a-listing), the response contains the exact column types, endpoint URL format, nullability rates, and unit price in USDC.

**Step 4: Verify price with a dry run and execute**

To prevent unexpected token or dollar spend, your local agent runs a dry-run check before the live invocation:

**Preflight price check**

```json
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "call_api",
    "arguments": {
      "endpoint_id": "api_solana_rpc_archive",
      "dry_run": true
    }
  }
}
```

The dry-run response confirms the per-call price and verifies that your local wallet policy approves the expenditure. Once confirmed, the agent sets `dry_run: false` to execute the call and receive the live data payload.

## Calling APIs vs. downloading datasets

Depending on your agent's workload, Sella supports two primary consumption models:

### 1. Pay-per-call API proxies (`call_api`)

For real-time queries, search requests, and inference tasks, your agent uses [USDC pay-per-call APIs](/answers/usdc-pay-per-call-apis). 

- **How it works**: Your local agent passes the `endpoint_id` and query arguments to `call_api`.
- **Payment**: Sella handles the upstream authentication and settles the $0.01 to $0.05 USDC fee from your local wallet per call.
- **Best for**: Real-time market prices, on-demand web search, and dynamic entity enrichment.

### 2. Full dataset package delivery (`get_dataset`)

For quantitative modeling, fine-tuning, or bulk backtesting, your agent buys complete data packages:

```json
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "get_dataset",
    "arguments": {
      "dataset_id": "ds_liquidity_pools_2026_q3"
    }
  }
}
```

Once the x402 payment clears, Sella delivers the data inline or returns a signed temporary download URL. If a download is interrupted by a local network drop, your harness can call `deliver_product` with the `product_id` to obtain a fresh temporary link without paying a second time.

## Automated error handling and budget guardrails

When running unattended agent harnesses in production, implement these four defensive safeguards:

1. **Pre-flight wallet balance checks**: Call `budget_status` at the start of every autonomous loop to confirm that your active wallet on Base or Solana has sufficient USDC balance for planned operations.
2. **Handle offline providers gracefully**: If an upstream vendor goes offline, `call_api` returns an `ENDPOINT_OFFLINE` error code. Configure your harness to catch this code and query `browse_catalog` for alternative verified providers.
3. **Enforce hard local spending caps**: While Sella's `policy_check` tool provides server-side policy advice, your local agent code should enforce local per-hour and per-day token and dollar limits.
4. **Local result caching**: Store deterministic API responses locally in SQLite or Redis. An agent running repeated entity lookups should check its local cache first before issuing a paid API query.

## Frequently asked questions

### What is a local agent harness?

A local agent harness is any local execution environment running an autonomous agent loop, such as a Python LangChain script, a custom Node event loop, Cursor, or Claude Desktop.

### Do local agents need API keys for every provider in the catalogue?

No. Your local harness connects only to the Sella MCP server. When your agent calls call_api or get_dataset, Sella proxies the execution and settles the cost from your agent wallet over x402.

### Can my local harness check the price before spending money?

Yes. An agent can call call_api with dry_run set to true, or run purchase_preview, to inspect the exact USDC cost and verify policy approval before making a live paid request.

## Connect your local harness to Sella

Test discovery tools and dry-run API calls in the interactive playground, or grab your setup code to connect your local agent in seconds.

[Open the playground](/playground)