How to Give an AI Agent Solana RPC Access Without Signup

An AI agent that needs to read and write Solana hits a wall before it makes a single call: every mainstream RPC provider requires a human to create an account first. Email, email verification, a dashboard, a credit card, an API key copied by hand. A person finishes that in two minutes. Software can't do it at all — an agent can't pass a CAPTCHA, verify an email, or type card digits into a checkout form.

This guide is the working answer. It shows how an agent (or the person deploying one) gets Solana RPC access with no signup, no dashboard, and no card — where a funded Solana keypair is the entire account. This is the approach used by Nodius, the only Solana RPC built so a machine can provision and pay for it end-to-end.

Every read and write an agent makes goes through an RPC node. The dependency chain looks like this:

Agent needs chain data → needs an RPC endpoint
RPC endpoint requires an account → requires a human
Therefore the agent's most basic dependency requires a human

That third step quietly breaks the "autonomous" claim in most agent setups. The agent can hold a wallet, sign transactions, and execute a strategy — but it can't get the RPC access those actions depend on without a human provisioning it first.

The fix is to authenticate the way Solana already works: with a wallet signature instead of an account. No email, no password — the agent proves it controls a keypair, deposits USDC, and credits attach to its public key. The keypair is the account.

The three ways an agent can authenticate (and which works)

Method	Human needed?	Works for an agent?
Email + dashboard + card (Helius, QuickNode)	Yes — signup, verify, card	❌ No
Free public RPC	No	⚠️ Rate-limited to uselessness for a real bot
Wallet signature + prepaid USDC (Nodius)	No	✅ Yes — the only self-provisionable option

The public RPC needs no signup but enforces hard rate limits — fine for a manual test, fatal for a bot that bursts during a volatility spike. The wallet-signature model is the only one that's both self-provisionable and production-grade.

Step by step: agent provisions its own RPC

This is the actual sequence. Every step is something software can do with no human keystrokes.

1. Generate or load a keypair

The keypair is the agent's identity and its billing account.

import { Keypair } from "@solana/web3.js";
import bs58 from "bs58";

// Load from env in production — never hardcode secrets
const secret = bs58.decode(process.env.SECRET_KEY_BASE58!);
const keypair = Keypair.fromSecretKey(secret);
console.log("Agent wallet:", keypair.publicKey.toBase58());

2. Fund it with SOL and USDC

The agent needs a small amount of SOL (for transaction fees) and USDC (to buy RPC credits). Initial funding is the one bootstrap step — it can come from a treasury wallet, a deployment script, or an exchange withdrawal. After that the agent self-sustains.

Critical: credits attach to the wallet that transfers the USDC (the SPL transfer authority), not the fee payer. Send USDC from the same wallet the agent authenticates with.

3. Connect and make the first call

npm install @nodiusxyz/sdk

import { NodiusClient } from "@nodiusxyz/sdk";

const rpc = NodiusClient.fromSecretKey(
  "https://rpc.nodius.xyz",
  process.env.SECRET_KEY_BASE58!
);

const slot = await rpc.getSlot();
console.log("Current slot:", slot);

If the wallet has no credits yet, the call returns HTTP 402 Payment Required — that's a billing signal, not an auth failure. The agent's wallet is already authenticated; it just needs funds.

4. Fund the account (two ways)

Option A — prepay. Generate an API key, read the deposit address, send USDC, confirm. Once credits land, calls don't wait on-chain.

const { api_key } = await rpc.generateApiKey();
const billing = await rpc.getBillingAccount();
console.log("Deposit USDC to:", billing.deposit_address);

// After sending USDC on-chain:
const conf = await rpc.confirmDeposit(depositSignature);
console.log("Balance:", conf.new_balance);

Option B — x402 auto-payment. The agent responds to a 402 by paying for more access on the spot and retrying — fully autonomous top-up.

const rpc = new NodiusClient("https://rpc.nodius.xyz", {
  keypair,
  autoPay: true,   // SDK settles a USDC payment when it sees a 402
});

5. Run the strategy loop

With credits in place, the agent reads state, decides, and transacts — and tops itself up when it runs low. No human touches it again.

What this unlocks

Once RPC access stops requiring a human, the whole system becomes genuinely autonomous: the agent holds its own wallet, pays for its own infrastructure, and runs its own strategy. The only thing a human ever did was the one-time bootstrap funding.

That's the difference between a bot operated by a person and a bot that operates itself.

The full method reference and per-call costs are in the API reference. To go from zero to a first call in five minutes, use the quickstart. Nodius is the Solana RPC built for this — a funded keypair is the account, prepaid in USDC, no signup.