AI Payment Use Cases

Real-world applications of autonomous AI payments using nano-toolset. 7 tools, HTTP API or MCP the same wallet behind every transaction.

Use Case #1

AI Agent Marketplaces

Enable autonomous buying and selling of AI services in digital marketplaces without human intervention.

Data Processing Services

AI agents purchase data cleaning, transformation, or analysis from specialized agents

API Access Marketplace

Agents sell access to proprietary APIs on a pay-per-call basis

Compute Resource Trading

Agents with excess compute power sell it to agents needing temporary resources

ai_marketplace.py 
import requests

TOOLSET_URL = "http://127.0.0.1:3123"

# Service provider creates payment request
resp = requests.post(
    f"{TOOLSET_URL}/payment/request",
    json={
        "receive_address": "nano_3provider...",
        "amount": "0.5"
    }
).json()
# {"success": true, "data": {"transaction_id": "...", "amount": "0.500...", ...}}
tx_id = resp["data"]["transaction_id"]
amount = resp["data"]["amount"]

# Buyer sends EXACT amount
requests.post(
    f"{TOOLSET_URL}/wallet/send",
    json={
        "recipient_address": resp["data"]["receive_address"],
        "amount": amount
    }
)

# Provider checks payment status
status = requests.get(
    f"{TOOLSET_URL}/payment/status/{tx_id}"
).json()
print(status["data"]["is_paid"])  # True
model_monetization.py 
import requests

TOOLSET_URL = "http://127.0.0.1:3123"

def handle_inference(request):
    tokens = count_tokens(request.prompt)
    cost = tokens * 0.00001  # 0.00001 NANO per token

    # Create payment request via nano-toolset
    result = requests.post(
        f"{TOOLSET_URL}/payment/request",
        json={
            "receive_address": provider_address,
            "amount": str(cost)
        }
    ).json()
    tx_id   = result["data"]["transaction_id"]
    amount  = result["data"]["amount"]
    address = result["data"]["receive_address"]

    # Customer's toolset sends exact amount
    requests.post(
        f"{TOOLSET_URL}/wallet/send",
        json={"recipient_address": address, "amount": amount}
    )

    # Verify payment and serve inference
    status = requests.get(
        f"{TOOLSET_URL}/payment/status/{tx_id}"
    ).json()

    if status["data"]["is_paid"]:
        return run_inference(request.prompt)
Use Case #2

Pay-Per-Use AI Models

Monetize AI models with per-inference payments. Zero fees make microtransactions economically viable.

Dynamic Pricing

Calculate cost based on token usage, create payment request via POST /payment/request

Payment Verification

Poll GET /payment/status/{'{id}'} before serving inference is_paid: true

Unique Amount Matching

Payer should send the exact amount returned by the request for reliable transaction matching.

Use Case #3

Direct Agent Payments

AI agents send and receive Nano instantly for compute, data, or services no intermediaries.

Check Before Sending

GET /wallet/balance verify balance before committing to a payment

Instant Settlement

POST /wallet/send sub-second Nano finality, zero fees

Send Confirmation

Every send returns the recipient address and amount instant payment confirmation

direct_payment.py 
import requests

TOOLSET_URL = "http://127.0.0.1:3123"

# Agent A checks balance before paying
balance = requests.get(
    f"{TOOLSET_URL}/wallet/balance"
).json()
print(f"Balance: {balance['data']['balance']} NANO")

# Agent A sends payment to Agent B's address
result = requests.post(
    f"{TOOLSET_URL}/wallet/send",
    json={
        "recipient_address": "nano_3agentb...",
        "amount": "0.1"
    }
).json()
# {"success": true, "data": {"recipient": "nano_3agentb...", "amount": "0.1"}}

print(result["data"]["recipient"])
# Compute access granted to Agent A

Data Purchase Flow

1

Create Payment Request

Seller calls POST /payment/request gets transaction_id

2

Buyer Pays

Buyer calls POST /wallet/send with exact amount

3

Status Check

Buyer polls GET /payment/status/{'{id}'} until is_paid: true

4

Data Delivery

Application delivers the dataset after confirmed payment.

Seconds
Payment verification end-to-end
Use Case #4

Data Purchase Between AI Agents

Buy and sell datasets between AI agents with instant payment verification and delivery.

Transaction-ID Tracking

Unique transaction_id per purchase perfect audit trail for AI agent interactions

Instant Verification

Poll /payment/status no webhooks, no callbacks, just poll and proceed

No Intermediaries

Direct agent-to-agent settlement via Nano no payment processor, no custody

More AI Payment Scenarios

Recurring Subscriptions

Create a new payment request per billing cycle via POST /payment/request agents pay automatically each period

Multi-Agent Collaboration

Orchestrator sends contributor shares via multiple POST /wallet/send calls instant, zero-fee splits

Usage Tracking

Track usage through transaction_id and /payment/status build complete billing audit trails

Instant Refunds

Use POST /wallet/send to refund overpayments immediately no processing delays or fees

Pay-Per-Access

Grant access only after is_paid: true confirmed via GET /payment/status

Credit Topup Automation

Agents auto-topup credits when running low via GET /credits + POST /credits/topup/{'{n}'}

Open Source Rust

Powered by nano-toolset

All of the above use cases run on ifenpay nano-toolset a single Rust binary that exposes 7 Nano payment tools via HTTP API and MCP over stdio.

7 Tools

wallet.balance, wallet.send, payment.request, payment.status, credits.get, credits.topup, donate.send

2 Transports

HTTP API on 127.0.0.1:3123 and MCP over stdio both active from a single cargo run --release

Framework-Agnostic

Works with any language or agent framework Python, JavaScript, curl, LangChain, CrewAI, custom

Ready to Build Your AI Payment System?

Clone nano-toolset and run cargo run --release. On first start, .env is created from .env-example if missing.

nano-toolset on GitHub Integration Guide AI Agent Playbook
Discord Community @ifenpay