DEV Community: James Bachini

How to Sell Services to AI Agents | x402 Goes Live On The Stellar Network

James Bachini — Tue, 17 Mar 2026 03:45:41 +0000

If you want to charge for an API you might issue API keys, set up a payment processor, manage rate limits, and hope your users don't churn. That model assumes a human is on the other side of the keyboard.

AI agents change the dynamic as they don’t have access or permissions to sign up for credit card based subscriptions. But what if you could give your agent access to a small amount of digital assets and they could use it to pay for metered access.

This is where x402 comes in. It revives the long reserved HTTP status code “402 Payment Required”.

Instead of redirecting to a checkout page, a server can respond with a machine readable payment request. The client signs a transaction providing authentication to route the digital assets and the resource is returned.

No dashboards. No credit cards. No humans in the loop. Just native payments via http.

Why The Stellar Network & USDC

Payment rails matter.

If you're charging $0.001 per API call, a $0.30 card processing fee is a non-starter. Settlement time measured in days doesn't work either when agents expect instant feedback.

The Stellar network provides the missing foundation:

Transactions settle in seconds
Fees are fractions of a cent
Native USDC support via Circle
Non custodial, on chain settlement

That combination makes micropayments via x402 viable. Not as a thought experiment, but as robust production architecture.

With x402 integrated on Stellar, an AI agent can find your endpoint, receive a structured payment request in USDC, sign a transaction, and proceed - all within a standard request/response cycle.

For the first time, the economics align with the automation, and it’s a great time to be a builder.

What Can You Sell to AI Agents?

The opportunity is not theoretical. Agents already consume:

Market data
Code analysis
Security scanning
Model inference
Compute cycles
Private datasets
Execution endpoints

Right now, most of these are gated by API keys or subscription contracts. That friction limits experimentation and composability.

With x402, you can expose a service and receive payment based directly on the volume of usage. The agent doesn't need an account or any intermediary.

Think about what Claude Code and OpenClaw are doing: they allow agents to navigate repositories, execute commands, install dependencies, and reason about systems.

Now imagine those agents discovering your paid endpoint in the process.

They attempt a request.Your server responds with 402 Payment Required.Payment options are provided in USDC on the Stellar network.The agent evaluates the cost.It signs and resubmits.You receive the digital assets to your wallet

No onboarding call. No SaaS sales funnel. No subscription churn.

Your API becomes economically composable.

Developers often talk about "the machine economy" in abstract terms. This is what it will look like in the next few years: small, verifiable, programmatic payments flowing between autonomous systems.

Simplicity For Developers

One of the more compelling aspects of x402 is how little it actually demands from developers.

On the server side, the logic is straightforward: when payment is required, the endpoint responds with a “402 Payment Required” status, includes structured payment instructions, and verifies on chain settlement before delivering the resource.

On the client side, the process is equally simple. The client detects the 402 response, signs the required transaction, and retries the request with proof of payment. Beyond that exchange, everything else continues to run on standard HTTP infrastructure, without introducing complex new layers or bespoke protocols.

And of course there is npm middleware available from Coinbase:

const app = express();
app.get("/", (_, res) => res.json({ route: ROUTE_PATH, price: PRICE, network: NETWORK }));
app.use(
  paymentMiddlewareFromConfig(
    {
      [`GET ${ROUTE_PATH}`]: {
        accepts: { scheme: "exact", price: PRICE, network: NETWORK, payTo: PAY_TO },
      },
    },
    new HTTPFacilitatorClient({url: FACILITATOR_URL}),
    [{ network: NETWORK, server: new ExactStellarScheme() }],
  ),
);

AI agents are becoming more capable, moving from passive assistants to active operators. As that shift accelerates, the demand for machine to machine services will grow with it. The developers who expose programmable, metered services early will shape that ecosystem.

x402 on the Stellar network provides the missing payment primitive to support it.

A small extension to HTTP backed by a network built for fast, low cost global settlement.

If you're building tools, datasets, models, or infrastructure that agents can use, the question is no longer whether machines will consume your services. It's whether they'll be able to pay you directly when they do.

Dev Diaries Ep.6 | Launch Day

James Bachini — Mon, 13 Oct 2025 11:20:15 +0000

Startups in Web3 don’t launch like traditional products, there are no rollbacks, no "patch it later" second tries.

When you hit deploy on-chain, it's live and responsible for financial transactions.

In Episode 6 of the Stellar Dev Diaries, the Freelii team takes the leap every founder dreams about: launching on Stellar mainnet.

🎥 Check out Episode 6: Launch Day

📺 Watch it on YouTube

In this episode, the team reflects on the reality of launch day:

🚀 The emotions of finally going live after months of testing and preparation
😬 The nerves and risks of pushing code to an immutable blockchain
🛠 The last-minute fixes and checks before hitting deploy
🤝 How Stellar’s support—grants, feedback, and guidance—made launch possible
💡 Advice for other Web3 founders preparing for mainnet
🔮 Their vision for how Web3 and DeFi will evolve over the next decade
💳 What’s next for Freelii

Launch day isn't hype, it's execution. Freelii is live. Mainnet is real. And this is just the beginning.

🛠 Ready to build on Stellar? Dive into the dev docs:

🌐 https://developers.stellar.org/

👀 Catch up on the series:

Episode 1: How a Hackathon Project Became a Web3 Startup
Episode 2: How The Freeli Team Raised $70k+ In Funding
Episode 3: User Feedback & The Pivot That Saved The Project
Episode 4: Building Production Systems That Handle Real Money
Episode 5: Startup Life Isn't Always Glamorous
Episode 6: Launch Day

Dev Diaries Episode 5 – Startup Life Isn't Always Glamorous

James Bachini — Fri, 05 Sep 2025 11:34:24 +0000

Startups in Web3 don’t follow straight lines. The technology shifts under your feet, the rules are unclear, and the grind is relentless. In Episode 5 of the Stellar Dev Diaries, we step away from code and architecture to explore the human side of building Freelii.

🎥 Check out Episode 5: Startup Life Isn’t Always Glamorous

📺 Watch it on YouTube

In this episode, Jose and Joseph open up about the unseen struggles of startup life:

⚡ The pressure of shipping products that must work on-chain, with no safety net
💡 Features they dreamed of building if time and resources weren’t constraints
😓 The lowest points of the journey—and what kept them moving forward
🤝 Lessons in trust, persistence, and teamwork that made Freelii possible
🤖 How AI tools like ChatGPT helped (and sometimes failed) when building at the cutting edge
🌐 Why Stellar’s transparency and reliability made it the right home for Freelii

Startup life isn't always glamorous. It’s late nights, broken builds, and quiet persistence. Episode 5 shows what it really takes to keep going when the hype fades and the grind begins.

🛠 Ready to build on Stellar? Dive into the dev docs:
🌐 https://developers.stellar.org/

👀 Catch up on the series:

Episode 1: How a Hackathon Project Became a Web3 Startup
Episode 2: How The Freeli Team Raised $70k+ In Funding
Episode 3: User Feedback & The Pivot That Saved The Project
Episode 4: Building Production Systems That Handle Real Money
Episode 5: Startup Life Isn't Always Glamorous

Dev Diaries Episode 4 – Building A Reliable Payout System In DeFi

James Bachini — Fri, 08 Aug 2025 23:55:41 +0000

Ever wondered what it really takes to move money at scale using blockchain? In Episode 4 of the Stellar Dev Diaries, we go under the hood with the Freelii team as they tackle one of the hardest challenges in Web3: building a secure, reliable, cross-border payout system.

🎥 Check out Episode 4: Building a Reliable Payout System in DeFi

📺 Watch it on YouTube

Missed earlier episodes?
👉 Episode 1: How a Hackathon Project Became a Web3 Startup
👉 Episode 2: How The Freeli Team Raised $70k+ In Funding
👉 Episode 3: User Feedback & The Pivot That Saved The Project
👉 Episode 4: Building Production Systems That Handle Real Money

In Episode 4, we dive deep into the technical architecture behind Freelii’s payout system. The mission? Help businesses pay global teams without the pain of traditional banking delays and fees.

We explore:

🔧 How Freelii designed a system to handle real money, real users, and real risk
🌐 Solving the cross-border payment problem for influencer houses, remote teams, and digital businesses
🚀 Why they chose Stellar for its speed, low fees, and powerful anchor ecosystem
💡 How “policy signers” let them execute secure automated transactions without user interaction
🧪 The challenge of testing without a sandbox—and how the team used Stellar’s testnet and custom tools to bridge the gap
📊 How a serverless backend with Upstash queues ensures reliable transaction execution

🛠 Ready to build on Stellar? Dive into the dev docs:
🌐 https://developers.stellar.org/

Follow the Freelii team as they continue building toward launch. Episode 4 is all about going live on mainnet—don’t miss it!

👀 Watch the series:
🎬 Episode 1: How a Hackathon Project Became a Web3 Startup
🎬 Episode 2: How The Freeli Team Raised $70k+ In Funding
🎬 Episode 3: User Feedback & The Pivot That Saved The Project
🎬 Episode 4: Building Production Systems That Handle Real Money

Dev Diaries Episode 3 - User Feedback & The Pivot That Saved The Project

James Bachini — Tue, 24 Jun 2025 11:58:49 +0000

In the Stellar Dev Diaries series, we’re following the journey of a dev team building on the Stellar Network as they go from hackathon idea to funded startup, testing their product in the real world and adapting as they go.

🎥 Check out Episode 3: User Feedback & The Pivot That Saved The Project

📺 [Watch on YouTube]

Missed the earlier episodes?
👉 Episode 1: How a Hackathon Project Became a Web3 Startup
👉 Episode 2: How the Freelii Team Raised $70k+ In Funding

What’s It All About?

In this series, we go behind the scenes with the team at Freelii as they build and launch a new product on the Stellar Network. You’ll get a raw, unfiltered look at the process—ideation, feedback, failure, and pivots—all while working with the cutting-edge tools Web3 has to offer.

Each episode explores the team’s journey from prototype to product, sharing not only technical insights and code walkthroughs, but also the hard lessons learned when your ideas meet the real world.

Episode 3

Episode 3 is all about the pivot—and the power of listening.

After developing an early version of their chatbot-based remittance product, José and Joseph took it to the Philippines to test in one of the world’s largest remittance markets. The feedback was humbling. Users didn’t trust messaging apps for handling money. The team’s assumptions didn’t hold up, and it forced a tough but necessary shift in direction.

Instead of sticking to the original plan, the team listened. And that led them to a better opportunity: automating business payouts.

💡 “We stopped trying to get individuals to change their behaviour and started solving a real, painful problem for businesses.”

This episode covers:

Field-testing a Web3 prototype in the real world
Gathering user feedback in one of the world’s top remittance markets
Why cultural insights matter when designing fintech tools
Learning that trust and compliance are more important than tech novelty
Discovering a new use case by talking to business owners
Pivoting from a consumer remittance app to a B2B payout automation platform

This pivot plays directly to Stellar’s strengths—fast, low-cost transactions and seamless crypto-to-cash conversion—while giving the team a much clearer go-to-market strategy.

The Takeaway?

If you're building in Web3: talk to your users early and often.
Innovation means nothing if it doesn’t solve a real problem.

Freelii’s journey is a masterclass in adaptability—proof that the best ideas are often uncovered after launch, not before.

Next Up

In Episode 4, we dive into the technical side of the new payout system—how it works, what’s under the hood, and the Stellar features that power it.

Stay tuned.

🛠 Want to start building on Stellar? Check out the dev docs here:
https://developers.stellar.org/docs

🔐 Learn more about passkeys here:
https://jamesbachini.com/webauthn-passkey-smart-wallets/

👀 Catch up on the full series so far:

📺 Episode 1: How a Hackathon Project Became a Web3 Startup
📺 Episode 2: How the Freelii Team Raised $70k+ In Funding
📺 Episode 3: User Feedback & The Pivot That Saved The Project

Follow the journey. Learn by building.

Rust + Web3 For All Your Backend Code

James Bachini — Sun, 01 Jun 2025 04:15:35 +0000

Introduction: Web3 Backends for Modern Developers

This tutorial will show you how to leverage a React frontend with a Rust smart contract for Soroban as a powerful alternative to traditional database backed applications.

React is the worlds most popular Javascript framework for frontend development
Stellar smart contract platform offers developers a way to build permissionless, decentralized applications with the performance and safety guarantees of Rust.

Why Web3?

Before we dive in, let's talk about why you might want to consider this approach:

Decentralization: Your data lives on the blockchain rather than a centralized server
Immutability: Once written, your data can't be tampered with
Transparency: All operations are public and verifiable
Safety: Rust's memory safety guarantees help prevent common programming errors
Performance: Soroban is designed for scalability and efficiency

Stellar has been around since 2014 and has proven itself as a reliable blockchain network with low transaction costs and fast settlement times.

Prerequisites

Basic knowledge of Rust (or willingness to learn!)
Familiarity with web development concepts
Node, Rust & Git installed

Setting Up Your Environment

Let's start by getting your development environment ready. We'll need the Soroban CLI to interact with the Stellar network and deploy our contracts.

# Install Rust if you haven't already
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Add the WebAssembly target
rustup target add wasm32-unknown-unknown

# Install Soroban CLI
cargo install --locked soroban-cli

# Verify installation
soroban --version

Project Structure: Stellar Soroban Boilerplate

We'll be working with a boilerplate that provides a solid foundation for building web3 applications. The repository includes both smart contract code written in Rust and a React frontend interface to interact with it.

All the code for this tutorial is available at: https://github.com/jamesbachini/Stellar-Soroban-Boilerplate

Let's clone the repository:

git clone https://github.com/jamesbachini/Stellar-Soroban-Boilerplate
cd Stellar-Soroban-Boilerplate

The project structure looks like this:

Stellar-Soroban-Boilerplate/
├── soroban/contracts/src
│   └── lib.rs   # A simple key-value store contract
│   └── test.rs  # Unit tests for the contract
├── src/
│   └── App.js   # Frontend example
└── README.md

Understanding the Key-Value Store Contract

At the heart of our Web3 backend is a key-value store contract. This serves as a simple database replacement that stores data on the Stellar blockchain instead of a traditional database server.

Let's look at the key parts of this contract:

#![no_std]
use soroban_sdk::{contract, contractimpl, Env, symbol_short, Symbol};

#[contract]
pub struct StarterContract;

#[contractimpl]
impl StarterContract {
    pub fn set(env: &Env, key: Symbol, value: Symbol) {
        env.storage().persistent().set(&key, &value);
        env.events().publish((symbol_short!("SET"), &key), &value);
    }

    pub fn get(env: &Env, key: Symbol) -> Option<Symbol> {
        env.storage().persistent().get(&key)
    }

    pub fn remove(env: &Env, key: Symbol) {
        env.storage().persistent().remove(&key);
    }
}

mod test;

This contract allows any user to:

Store data with set(key, value)
Retrieve data with get(key)

The set function stores the value on-chain and also fires an event which can be monitored on a frontend for real-time updates.

Building and Deploying Your Contract

Let's build and deploy our key-value store contract to the Soroban network:

cargo build --target wasm32-unknown-unknown --release

stellar keys generate mywallet

stellar keys fund mywallet

stellar contract deploy  --wasm target/wasm32-unknown-unknown/release/StarterContract.wasm --source YourWalletAlias --network testnet

The stellar keys commands generates a new wallet address or keypair and then funds it with testnet XLM to pay the deployment costs. You should see something like this:

Contract deployed successfully!
Contract ID: CABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF12345678

Take note of this Contract ID - You can view it at: https://stellar.expert/explorer/testnet

You'll need it later for the frontend to interact with your contract!

The Web3 Frontend

Now that we have our contract deployed, let's look at how to interact with it from a web application. The boilerplate includes a simple frontend that demonstrates this.

First, let's set up a react dev environment:

npm install
npm run dev

Now let's edit src/App.js and modify lines 13, 15 & 16 to replace the contract ID and wallet keys which you can get via the stellar keys tool.

Let's examine the set function:

const handleSet = async (e) => {
  e.preventDefault();
  try {
    const inputKey = StellarSdk.nativeToScVal(key, { type: "symbol" });
    const inputValue = StellarSdk.nativeToScVal(value, { type: "symbol" });
    const account = await rpc.getAccount(accountPublicKey);
    const tx = new StellarSdk.TransactionBuilder(account, {
        fee: StellarSdk.BASE_FEE,
        networkPassphrase: StellarSdk.Networks.TESTNET,
      })
      .addOperation(contract.call("set", inputKey, inputValue))
      .setTimeout(30)
      .build();
    const preparedTx = await rpc.prepareTransaction(tx);
    preparedTx.sign(accountKeypair);
    const txResult = await rpc.sendTransaction(preparedTx);
    console.log('txResult', txResult);
    setKey('');
    setValue('');
  } catch (err) {
    setError('Failed to set value: ' + err.message);
  }
};

The handleSet function first prevents the default form submission behavior and converts the key and value from form inputs into a special Contract Value format as symbol types. It then retrieves the user's Stellar account and constructs a new transaction using the Stellar SDK. This transaction includes an operation to call the "set" method on a smart contract, passing in the converted key and value parameters.

After setting a timeout and building the transaction, it's prepared for submission, signed using the user's keypair, and sent to the Stellar network.

Note that when updating on-chain we have to pay a tx fee to modify the state and cover network/storage costs. When reading data there is no cost and we can just simulate the tx as we will see in the next snippet for the get function.

const handleGet = async (e) => {
  e.preventDefault();
  try {
    const inputGetKey = StellarSdk.nativeToScVal(getKey, { type: "symbol" });
    const account = await rpc.getAccount(accountPublicKey);
    const tx = new StellarSdk.TransactionBuilder(account, {
        fee: StellarSdk.BASE_FEE,
        networkPassphrase: StellarSdk.Networks.TESTNET,
      })
      .addOperation(contract.call("get", inputGetKey))
      .setTimeout(30)
      .build();
    rpc.simulateTransaction(tx).then((sim) => {
      const decoded = StellarSdk.scValToNative(sim.result?.retval);
      setGetValue(decoded);
    });
  } catch (err) {
    setError('Failed to get value: ' + err.message);
  }
};

In this function we are using the rpc.simulateTransaction function to ask our RPC node which is our entry point to the network to return the data from it's copy of the blockchain state.

This data is decoded and returned to be displayed on the frontend.

Next Steps

While our example uses a simple key-value store, you can build much more sophisticated data models. Here is an example of a function that has access control meaning only a certain account can update the ledger.

In this example the admin: Address variable would be set in the constructor or somewhere else and then we check that they are the ones that are calling the set function so that only they can update data.

#[contractimpl]
pub fn set(env: &Env, key: Symbol, value: Symbol) {
    let store = env.storage().persistent();
    let admin: Address = store.get(&symbol_short!("admin")).unwrap();
    admin.require_auth();
    store.set(&key, &value);
    env.events().publish((symbol_short!("SET"), &key), &value);
}

Handling Data Limitations

Blockchains in their current form are good for storing small amounts of critical data. Scaling efforts are constantly pushing the boundaries of what we can do within a smart contract.

Here are some strategies for managing larger datasets:

Store Hashes: For large files or datasets, store only a hash or reference on-chain, with the full data in IPFS or a centralized service
Paginate Data: If you have collections, implement pagination to retrieve data in chunks. Avoid iterating over an array of unknown size i.e. user data
Use Events: For historical data, use blockchain events rather than storing everything. These can be indexed and referred back to as required.

For web developers looking to step into Web3, Soroban provides a gentle learning curve with familiar concepts and excellent documentation. The Stellar network efficiency makes it practical for real-world applications beyond simple experiments.

Additional Resources

🚀 Stellar Dev Diaries: Episode 2 - Becoming Fundable

James Bachini — Thu, 08 May 2025 07:06:50 +0000

Ever wondered what it takes to build a Web3 startup from scratch? In the Stellar Dev Diaries series, we’re following the journey of a team of developers building on the Stellar Network as they go from hackathon wins to getting funded and launching their product on mainnet.

Check out Episode 2: Becoming Fundable

Missed Episode 1: Watch it here

What’s It All About?

In this series, we take a deep dive into the experiences of the Freelii team as they build and launch their product on the Stellar Network.

Throughout the series, you'll get an inside look at what it takes to go from zero to one: turning ideas into products, getting funded, and scaling a startup in a fast-moving space. Each episode will feature real code examples with walkthroughs of the features the team used and the challenges they encountered along the way.

Episode 2

In Episode 2, we explore how the team pivoted from their initial idea into something with broader appeal to secure more hackathon wins. We also hear more about their experiences navigating the grant application process to secure funding from the Stellar Community Fund.

On the technical side, we go deeper into the tools that Jose and Joseph used to build the first version of the Freelii remittance chatbot, discussing some key Stellar features that made it possible.

In this episode, we dive into:

The experience of going from hackathon partners to full-blown entrepreneurs
Building a Telegram mini app
Leveraging Stellar Anchors for seamless on-ramping
Successfully applying for a grant from the Stellar Community Fund
Managing early-stage costs to maximize runway

Want to know what it takes to build and launch a product in Web3? Then keep watching as we follow José and Joseph on their journey from idea to mainnet.

To learn more about the Stellar Anchors feature that we discussed in the episode, check out the tutorials here:

✒️ https://jamesbachini.com/stellar-anchor-platform/

📺 https://youtu.be/57iZMxAr_1Y

To start building on Stellar, check out the developer docs here.

Follow the Freelii team as they build, adapt, and prepare to launch their product on the Stellar Network. Check out all the episodes here:

Episode 1: How a Hackathon Project Became a Web3 Startup
Episode 2: How The Freeli Team Raised $70k+ In Funding
Episode 3: User Feedback & The Pivot That Saved The Project

🚀 Stellar Dev Diaries Series: Episode 1 is LIVE!

James Bachini — Wed, 09 Apr 2025 19:52:43 +0000

Ever wondered what it takes to build a web3 startup from scratch? In the Stellar Dev Diaries series, we follow the journey of a team of developers building on the Stellar Network as they go from hackathon win to getting funded and launching on mainnet.

Check out Episode 1: How a Hackathon Project Became a Web3 Startup

What’s It All About?

In the Stellar Dev Diaries, we take a dive deep into the experiences of the Freelii team as they build and launch their product on the Stellar Network.

As we follow their journey, you'll get the insider's playbook: turning ideas into products, getting funded, transitioning from Web2 to Web3, and scaling a startup in a space that's still being defined. On top of that, each episode will feature real code examples with walkthroughs of the features they used and challenges they encountered.

Episode 1

In Episode 1, we meet José Toscano and Joseph Anthony, the brains behind Freelii, a startup that started as a hackathon win right here on Dev.to and went on to win again at Stellar’s Hack Meridian in London.
Realizing that they had a winning partnership and a great product idea, José and Joseph secured funding, quit their 9-to-5 jobs, and went all in on Freelii.

In this episode, we dive into:

The hackathon wins that sparked the journey.
The moment José and Joseph decided to go all-in.
Building a working prototype on Stellar.
Using the PassKeys feature of Soroban.
Getting funded via the Stellar Community Fund.

Want to know what it takes to build and launch a product in Web3? Then keep watching as we follow José and Joseph on their journey from idea to mainnet.

If you want to learn more about the PassKeys feature that we discussed in the episode, check out the tutorials here:

If you want to start building on Stellar, check out the developer docs here.

Follow the Freelii team as they build, adapt, and prepare to launch their product on the Stellar Network. Check out all the episodes here:

Episode 1: How a Hackathon Project Became a Web3 Startup
Episode 2: How The Freeli Team Raised $70k+ In Funding
Episode 3: User Feedback & The Pivot That Saved The Project