# x402-Zahlungen

Verwenden Sie x402 für Maschine-zu-Maschine-Zahlungen.

[x402](https://x402.org) ist ein Protokoll für Internetzahlungen. Wenn ein Client eine bezahlte Ressource anfordert, gibt Ihr Server eine HTTP 402-Antwort mit Zahlungsdaten zurück. Der Client zahlt und wiederholt die Anfrage dann mit einer Autorisierung. Stripe verwaltet die Einzahlungsadressen und *erfasst* (Another way to say that you receive payment for a charge is to say that you "capture" the charge. Capturing the charge is often asynchronous and takes place after authorization. The capture is what transfers the money from the customer to you) den [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) automatisch, wenn Geldmittel direkt in der Blockchain verarbeitet werden.

Den [vollständigen Quellcode](https://github.com/stripe-samples/machine-payments) der App finden Sie auf GitHub.

## Before you begin

Maschinelle Zahlungen müssen für Ihr Konto aktiviert sein. Beantragen Sie den Zugang zu maschinellen Zahlungen [über das Anmeldeformular](https://docs.stripe.com/payments/machine.md#sign-up).

> Ihre Kundinnen und Kunden können Stablecoins weltweit zur Zahlung verwenden, doch derzeit können nur Unternehmen in den USA können Zahlungen mit Stablecoin akzeptieren.

So akzeptieren Sie Stablecoin-Zahlungen:

1. Stellen Sie sicher, dass Sie [Ihr Stripe-Konto eingerichtet](https://docs.stripe.com/get-started/account/set-up.md) haben.
1. Gehen Sie zu Ihren Einstellungen der [Zahlungsmethoden](https://dashboard.stripe.com/settings/payment_methods) im Dashboard und fordern Sie die Zahlungsmethode **Stablecoins und Krypto** an. Wenn Sie nur Stablecoin- oder Krypto-Zahlungen als [maschinelle Zahlungen](https://docs.stripe.com/payments/machine.md) akzeptieren möchten, empfehlen wir, eine separate [Zahlungsmethodenkonfiguration](https://docs.stripe.com/payments/payment-method-configurations.md) für maschinelle Zahlungen zu erstellen.
1. Stripe prüft Ihre Anfrage und kann Sie bei Bedarf für weitere Informationen kontaktieren. Die Zahlungsmethode wird während der Überprüfung als **ausstehend** angezeigt.
1. Nachdem wir Ihre Anfrage genehmigt haben, wird **Stablecoins und Krypto** im Dashboard aktiv.

## Zahlungszyklus

In diesem Leitfaden erstellen Sie den Server. Ihr Server gibt an, dass eine Zahlung erforderlich ist, und gibt den Inhalt nach erfolgreicher Zahlung zurück. Sie interagieren mit Stripe und einem Vermittler, um die Zahlung abzuschließen.
Ein Diagramm, das den x402-Zahlungsablauf zwischen Client, Server, Stripe und Vermittler zeigt (See full diagram at https://docs.stripe.com/payments/machine/x402)
## Ihren Endpoint erstellen

Fügen Sie Ihrem Endpoint eine Zahlungs-Middleware hinzu, um eine Zahlung anzufordern

In diesem Beispiel sind pro Anfrage an `/paid` 0,01 USD erforderlich, die in USDC gezahlt werden.

#### Node.js

```node
import { paymentMiddleware } from "@x402/hono";
import { x402ResourceServer, HTTPFacilitatorClient } from "@x402/core/server";
import { ExactEvmScheme } from "@x402/evm/exact/server";

app.use(
  paymentMiddleware(
    {
      "GET /paid": {
        accepts: [
          {
            scheme: "exact",
            price: "$0.01",
            network: "eip155:84532",
            payTo: createPayToAddress,
          }
        ],
        description: "Data retrieval endpoint",
        mimeType: "application/json",
      }
    },
    new x402ResourceServer(facilitatorClient).register(
      "eip155:84532",
      new ExactEvmScheme()
    )
  )
)
```

## PaymentIntent erstellen

Erstellen Sie zur Zahlungsabwicklung einen [PaymentIntent](https://docs.stripe.com/api/payment_intents.md), der die `Krypto`-*Zahlungsmethode* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) akzeptiert. Verwenden Sie die `payTo`-Methode von früher.

> #### API-Version
> 
> Für diese Funktion ist die API-Version `2026-03-04.preview` erforderlich. Setzen Sie den Header `Stripe-Version` bei der Initialisierung Ihres Stripe-Clients auf `2026-03-04.preview`.

#### Node.js

```node
import Stripe from "stripe";
import NodeCache from 'node-cache';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, {
  apiVersion: "2026-03-04.preview",
});

// In-memory cache for deposit addresses (TTL: 5 minutes)
// NOTE: For production, use a distributed cache like Redis instead of node-cache
const paymentCache = new NodeCache({ stdTTL: 300, checkperiod: 60 });

async function createPayToAddress(context) {
  // If a payment header exists, extract the destination address from it
  if (context.paymentHeader) {
    const decoded = JSON.parse(
      Buffer.from(context.paymentHeader, "base64").toString()
    );
    const toAddress = decoded.payload?.authorization?.to;

    if (toAddress && typeof toAddress === "string") {
      if (!paymentCache.has(toAddress)) {
        throw new Error("Invalid payTo address: not found in server cache");
      }
      return toAddress;
    }

    throw new Error(
      "PaymentIntent did not return expected crypto deposit details"
    );
  }

  // Create a new PaymentIntent to get a fresh crypto deposit address
  const decimals = 6; // USDC has 6 decimals
  const amountInCents = Number(10000) / Math.pow(10, decimals - 2);

  const paymentIntent = await stripe.paymentIntents.create({
    amount: amountInCents,
    currency: "usd",
    payment_method_types: ["crypto"],
    payment_method_data: {
      type: "crypto",
    },
    payment_method_options: {
      crypto: {
        mode: "deposit",
        deposit_options: {
          networks: ["base"],
        },
      },
    },
    confirm: true,
  });

  if (
    !paymentIntent.next_action ||
    !("crypto_display_details" in paymentIntent.next_action)
  ) {
    throw new Error(
      "PaymentIntent did not return expected crypto deposit details"
    );
  }

  // Extract the Base network deposit address from the PaymentIntent
  const depositDetails = paymentIntent.next_action
    .crypto_display_details;
  const payToAddress = depositDetails.deposit_addresses["base"].address;

  console.log(
    `Created PaymentIntent ${paymentIntent.id} for $${(
      amountInCents / 100
    ).toFixed(2)} -> ${payToAddress}`
  );

  paymentCache.set(payToAddress, true);
  return payToAddress;
}
```

Diese Funktion gibt eine Krypto-Einzahlungsadresse zurück, die der Client erhält und für die Zahlung verwendet.

Die Antwort des [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) enthält Einzahlungen mit `supported_tokens`, in denen die akzeptierten Token und deren Vertragsadressen für jedes Netzwerk aufgeführt sind:

```json
{
  "id": "pi_123",
  "amount": 5000,
  "currency": "usd",
  "status": "requires_action",
  "next_action": {
    "type": "crypto_display_details",
    "crypto_display_details": {
      "deposit_addresses": {
        "base": {
          "address": "0xbase_address",
          "supported_tokens": [
            {
              "token_currency": "usdc",
              "token_contract_address": "0x…"
            }
          ]
        }
      }
    }
  }
}
```

> #### Krypto-PaymentIntents
> 
> Weitere Informationen zur Funktionsweise von Kryptowährungs-PaymentIntents, einschließlich Einzahlungsadressen, Zahlungs-Lifecycle und unterstützter Netzwerke, finden Sie im [Leitfaden zur Einzahlungsmodus-Integration](https://docs.stripe.com/payments/deposit-mode-stablecoin-payments.md).

## Ihren Endpoint testen

Stellen Sie eine Anfrage an Ihren Server ohne berechtigten Client, um zu bestätigen, dass er einen `402`-Statuscode zurückgibt.

```bash
curl http://localhost:3000/paid
```

Sie sehen einen `402`-Statuscode.

Stellen Sie als Nächstes eine Anfrage an einen berechtigten Client. Verwenden Sie das [Purl](https://github.com/stripe/purl) von Stripe, um in der Befehlszeile zu testen.

```bash
purl http://localhost:3000/paid
```

> #### Sandboxes und Testnet
> 
> [PaymentIntents](https://docs.stripe.com/api/payment_intents/object.md), die Sie in einer [Sandbox](https://docs.stripe.com/sandboxes.md) erstellen, überwachen keine Krypto-Testnets, sodass wir die von Ihnen gesendeten Testnet-Transaktionen nicht automatisch erkennen können. Um Sandbox-`PaymentIntents` zu testen, verwenden Sie den [Testhelfer-Endpoint](https://docs.stripe.com/api/payment_intents/simulate_crypto_deposit.md?api-version=2026-03-04.preview), um Krypto-Einzahlungen zu simulieren. [Erfahren Sie mehr über das Testen Ihrer Integration](https://docs.stripe.com/payments/deposit-mode-stablecoin-payments.md#test-your-integration).

Wenn Sie eine Wallet verbunden haben, gibt der Server den Inhalt zurück und Sie können die Zahlung bestätigen. Besuchen Sie die Seite [Stripe Dashboard Payments](https://dashboard.stripe.com/payments), um die Transaktion anzuzeigen.

Alternativ können Sie auch curl verwenden, um die neuesten Zahlungen aus der Stripe-API abzurufen:

```bash
curl https://api.stripe.com/v1/payment_intents?limit=10 \
  -u <<YOUR_SECRET_KEY>>:
```

## Mainnet-Transaktionen ausführen

Um Mainnet-Transaktionen auszuführen, integrieren Sie einen x402-Facilitator, der das Mainnet unterstützt.

Sehen Sie sich die Anleitung der Coinbase Developer Platform an, [um den CDP-Facilitator zu verwenden](https://docs.cdp.coinbase.com/x402/quickstart-for-sellers#running-on-mainnet).

## Token- und Netzwerk-Support

`PaymentIntents` mit der Zahlungsmethode `Krypto` im `Modus: Einzahlung` unterstützen USDC in den folgenden Netzwerken:

| Netzwerk | Token | Token Vertragsadresse                          |
| -------- | ----- | ---------------------------------------------- |
| Tempo    | USDC  | `0x20c000000000000000000000b9537d11c60e8b50`   |
| Base     | USDC  | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`   |
| Solana   | USDC  | `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v` |