[x402 Developer Documentation]

Build x402-enabled execution capabilities and integrate with the Nexus orchestration layer. Complete technical guide for developers.

The x402 protocol is the execution authorization and settlement layer used by Nexus. It enables pay-per-execution access to orchestrated AI runs, where each payment authorizes a complete execution cycle handled by the Nexus orchestration system.

Payments are settled to Nexus, not to individual execution capabilities: Nexus internalizes execution costs and revenue, then returns a single, unified result to the user. This documentation explains how to implement x402-compatible execution capabilities that are invoked by Nexus as part of a structured execution flow.

Overview

[x402 & Nexus]

Nexus Execution Model

Nexus operates as a central orchestration system: when execution is authorized, it interprets intent, plans execution, invokes the required execution capabilities, validates outputs, and assembles the final result.

Developers integrate with one execution surface, while Nexus handles orchestration, validation, and settlement. Execution capabilities are not public services and are not accessed directly by end users: they operate as internal or permissioned components within the Nexus execution environment.

The x402 Protocol

x402 extends the HTTP 402 Payment Required status code into an execution authorization mechanism.

It enables:

execution authorization through payment
per-request pricing
cryptographic proof of authorization
automated access to paid execution
settlement without subscriptions or API keys

Each x402 payment authorizes one complete execution cycle, executed and delivered by Nexus.

Protocol Flow

1. Client submits an execution request to Nexus

2. Nexus returns a 402 Payment Required response

3. The quote contains: execution price, asset and payment parameters, execution metadata

4. Client authorizes the blockchain payment

5. Client retries the request with a payment proof

6. Nexus verifies the proof

7. Nexus invokes the required execution capabilities

8. Nexus assembles and returns the final result

Execution is handled as a single, atomic process.

Execution Architecture

User Request
      │
      ▼
┌────────────────────┐
│ Nexus Orchestrator │
└─────────┬──────────┘
          │
   ┌──────┼──────────┐
   ▼      ▼          ▼
Capability A   Capability B   Capability C
 (Text)         (Vision)        (Verify)
          │
          ▼
     Result Assembly
          │
          ▼
      Final Output

Execution capabilities are coordinated internally and exposed as one unified execution outcome.

Developer Summary

From a developer perspective, Nexus provides:

a single execution surface
deterministic, per-request pricing
payment-authorized execution
unified orchestration and delivery

x402 enables execution-native access to AI capabilities, where requests become orchestrated executions, and executions produce verified, delivered results.

[Implementation Guide]

Express.js Execution Capability

This section shows how to implement an x402-compatible execution capability using Express.js. These examples illustrate execution authorization mechanics. In production, execution endpoints are invoked by Nexus as part of an orchestrated execution flow and do not directly monetize requests.

Installation

npm install express nexus-x402

Capability Setup

const express = require('express');
const { createQuote, verifyPayment } = require('nexus-x402');

const app = express();
app.use(express.json());

const EXECUTION_CONFIG = {
  name: "Text Analysis Capability",
  basePrice: 0.001,
  perToken: 0.0000005
};

Creating an x402 Quote

app.post('/analyze', (req, res) => {
  const { text } = req.body;

  const price =
    EXECUTION_CONFIG.basePrice +
    text.length * EXECUTION_CONFIG.perToken;

  const quote = createQuote(price);
  return res.status(402).json(quote);
});

The quote represents the execution authorization cost for the request.

Verifying Payment and Executing

app.post('/analyze/pay', async (req, res) => {
  const { proof, text } = req.body;

  const valid = await verifyPayment(proof);
  if (!valid) {
    return res.status(400).json({ error: "Invalid payment proof" });
  }

  const analysis = await analyzeText(text);
  return res.json({ analysis });
});

Execution begins once authorization is verified.

Dynamic Pricing

Pricing is computed per request based on:

input size
execution complexity
latency constraints
system load

Pricing is calculated before execution and settled once per execution cycle.

Echo x402 Execution Test

Echo x402 Execution Test is a minimal execution endpoint used to validate x402 authorization and settlement flows.

Server Setup

const express = require('express');
const { createQuote, verifyPayment } = require('nexus-x402');

const app = express();
app.use(express.json());

const PRICE = 0.001;

Returning a 402 Quote

app.get('/echo', (req, res) => {
  const message = req.query.message || "Hello Nexus";

  const quote = createQuote(PRICE, { metadata: { message } });
  return res.status(402).json(quote);
});

Processing an Authorized Execution

app.post('/echo/pay', async (req, res) => {
  const { proof, message } = req.body;

  const valid = await verifyPayment(proof);
  if (!valid) {
    return res.status(400).json({ error: "Payment verification failed" });
  }

  return res.json({
    echo: message,
    timestamp: Date.now()
  });
});