# Richten Sie ein Pay-as-you-go-Preismodell ein.

Stellen Sie Ihren Kundinnen und Kunden Rechnungen auf Grundlage ihrer Nutzung Ihres Produkts oder Ihrer Dienstleistung.

[Nachträgliche Abrechnung (Pay-as-you-go)](https://docs.stripe.com/products-prices/pricing-models.md#pay-as-you-go) ist ein flexibles, skalierbares Modell, mit dem Sie Ihren Kundinnen und Kunden ihre jeweilige Nutzung nachträglich in Rechnung stellen können. KI-Unternehmen, SaaS-Plattformen und Cloud-Dienste verwenden dieses Preismodell häufig.

## Sie werden Folgendes entwickeln

In diesem Leitfaden wird beschrieben, wie Sie die nutzungsbasierte Preisgestaltung (Pay-as-you-go) auf Stripe für ein fiktives Unternehmen namens Hypernian implementieren. Hypernian berechnet seinen Kundinnen und Kunden die folgenden Preise für seine LLM-Modelle:

| Nutzung | Gebühr                      |
| ------- | --------------------------- |
| Token   | 0.04 USD pro 100 Token |

Um dieses Preismodell zu implementieren, erstellen Sie einen Zähler, richten Sie Preise und Abrechnung ein und senden Sie Zählerereignisse, um die Nutzung von Kund/innen unter Verwendung von [Produkten](https://docs.stripe.com/api/products.md) und [Preisen](https://docs.stripe.com/api/prices.md) aufzuzeichnen.

## Zähler erstellen

Zähler geben an, wie Zählerereignisse über einen Abrechnungszeitraum hinweg zusammengefasst werden. Zählerereignisse stellen alle Aktionen dar, die Kundinnen/Kunden in Ihrem System durchführen (beispielsweise API-Anfragen). Zähler sind an Preise gebunden und bilden die Grundlage für das, was in Rechnung gestellt wird.

Für das Hypernian-Beispiel sind Zählerereignisse die Anzahl der Token, die ein Kunde/eine Kundin in einer Abfrage verwendet. Der Zähler ist die Summe der Token über einen Monat.

Sie können das Stripe Dashboard oder die API verwenden, um einen Zähler zu konfigurieren. Um die API mit der Stripe CLI zum Erstellen eines Zählers zu verwenden, [starten sie mit der Stripe CLI](https://docs.stripe.com/stripe-cli.md).

#### Dashboard

1. Klicken Sie auf der Seite [Zähler](https://dashboard.stripe.com/test/meters) auf **Zähler erstellen**.
1. Im Zähler-Editor:
   - Geben Sie für **Zählername** den Namen des Zählers ein, der angezeigt wird und für organisatorische Zwecke dient. Für das Hypernian-Beispiel geben Sie „Hypernian-Token“ ein.
   - Geben Sie für **Ereignisname** den Namen ein, der in Zählerereignissen angezeigt werden soll, wenn die Nutzung an Stripe gemeldet wird. Für das Hypernian-Beispiel geben Sie „hypernian_tokens“ ein.
   - Legen Sie die **Aggregationsmethode** im Dropdown-Menü fest:
     - Wählen Sie im Hypernian-Beispiel **Summe** aus. Dadurch werden die *gemeldeten Werte addiert* (in diesem Beispiel die Anzahl der von einer Kundin oder einem Kunden verwendeten Token), um die abrechenbare Nutzung zu ermitteln.
     - Wählen Sie **Anzahl**, um Ereignisse auf Grundlage der gemeldeten *Anzahl* abzurechnen.
     - Wählen Sie **Zuletzt** für die auf dem *letzten* gemeldeten Wert basierende Rechnung.
     - Verwenden Sie den Vorschaubereich , um beispielhafte Nutzungsereignisse festzulegen und die Aggregationsmethode zu verifizieren.
   - Klicken Sie auf **Zähler erstellen**.
   - (Optional) Geben Sie unter **Erweiterte Einstellungen** die **Dimensionen** an, mit denen Sie Ihre Nutzungsdaten kennzeichnen möchten. Um granulare, segmentspezifische Warnungen zu generieren oder die Nutzung auf der Grundlage einer Kombination von Attributen zu bewerten, übermitteln Sie Ihre Nutzungsdaten mit Dimensionen, die für Analysen und Berichte ausgefüllt werden. Einige Beispiel-Dimensionen sind LLM-Modell, Token-Typ, Region und Ereignistyp.

#### API

```curl
curl https://api.stripe.com/v1/billing/meters \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d display_name="Hypernian tokens" \
  -d event_name=hypernian_tokens \
  -d "default_aggregation[formula]"=sum \
  -d "customer_mapping[event_payload_key]"=stripe_customer_id \
  -d "customer_mapping[type]"=by_id \
  -d "value_settings[event_payload_key]"=value
```

```cli
stripe billing meters create  \
  --display-name="Hypernian tokens" \
  --event-name=hypernian_tokens \
  -d "default_aggregation[formula]"=sum \
  -d "customer_mapping[event_payload_key]"=stripe_customer_id \
  -d "customer_mapping[type]"=by_id \
  -d "value_settings[event_payload_key]"=value
```

```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("<<YOUR_SECRET_KEY>>")

meter = client.v1.billing.meters.create({
  display_name: 'Hypernian tokens',
  event_name: 'hypernian_tokens',
  default_aggregation: {formula: 'sum'},
  customer_mapping: {
    event_payload_key: 'stripe_customer_id',
    type: 'by_id',
  },
  value_settings: {event_payload_key: 'value'},
})
```

```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("<<YOUR_SECRET_KEY>>")

# For SDK versions 12.4.0 or lower, remove '.v1' from the following line.
meter = client.v1.billing.meters.create({
  "display_name": "Hypernian tokens",
  "event_name": "hypernian_tokens",
  "default_aggregation": {"formula": "sum"},
  "customer_mapping": {"event_payload_key": "stripe_customer_id", "type": "by_id"},
  "value_settings": {"event_payload_key": "value"},
})
```

```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('<<YOUR_SECRET_KEY>>');

$meter = $stripe->billing->meters->create([
  'display_name' => 'Hypernian tokens',
  'event_name' => 'hypernian_tokens',
  'default_aggregation' => ['formula' => 'sum'],
  'customer_mapping' => [
    'event_payload_key' => 'stripe_customer_id',
    'type' => 'by_id',
  ],
  'value_settings' => ['event_payload_key' => 'value'],
]);
```

```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("<<YOUR_SECRET_KEY>>");

MeterCreateParams params =
  MeterCreateParams.builder()
    .setDisplayName("Hypernian tokens")
    .setEventName("hypernian_tokens")
    .setDefaultAggregation(
      MeterCreateParams.DefaultAggregation.builder()
        .setFormula(MeterCreateParams.DefaultAggregation.Formula.SUM)
        .build()
    )
    .setCustomerMapping(
      MeterCreateParams.CustomerMapping.builder()
        .setEventPayloadKey("stripe_customer_id")
        .setType(MeterCreateParams.CustomerMapping.Type.BY_ID)
        .build()
    )
    .setValueSettings(
      MeterCreateParams.ValueSettings.builder().setEventPayloadKey("value").build()
    )
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
Meter meter = client.v1().billing().meters().create(params);
```

```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

const meter = await stripe.billing.meters.create({
  display_name: 'Hypernian tokens',
  event_name: 'hypernian_tokens',
  default_aggregation: {
    formula: 'sum',
  },
  customer_mapping: {
    event_payload_key: 'stripe_customer_id',
    type: 'by_id',
  },
  value_settings: {
    event_payload_key: 'value',
  },
});
```

```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
sc := stripe.NewClient("<<YOUR_SECRET_KEY>>")
params := &stripe.BillingMeterCreateParams{
  DisplayName: stripe.String("Hypernian tokens"),
  EventName: stripe.String("hypernian_tokens"),
  DefaultAggregation: &stripe.BillingMeterCreateDefaultAggregationParams{
    Formula: stripe.String(stripe.BillingMeterDefaultAggregationFormulaSum),
  },
  CustomerMapping: &stripe.BillingMeterCreateCustomerMappingParams{
    EventPayloadKey: stripe.String("stripe_customer_id"),
    Type: stripe.String("by_id"),
  },
  ValueSettings: &stripe.BillingMeterCreateValueSettingsParams{
    EventPayloadKey: stripe.String("value"),
  },
}
result, err := sc.V1BillingMeters.Create(context.TODO(), params)
```

```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new Stripe.Billing.MeterCreateOptions
{
    DisplayName = "Hypernian tokens",
    EventName = "hypernian_tokens",
    DefaultAggregation = new Stripe.Billing.MeterDefaultAggregationOptions
    {
        Formula = "sum",
    },
    CustomerMapping = new Stripe.Billing.MeterCustomerMappingOptions
    {
        EventPayloadKey = "stripe_customer_id",
        Type = "by_id",
    },
    ValueSettings = new Stripe.Billing.MeterValueSettingsOptions
    {
        EventPayloadKey = "value",
    },
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Billing.Meters;
Stripe.Billing.Meter meter = service.Create(options);
```

## Preismodell erstellen

Verwenden Sie das Stripe-Dashboard oder die API, um ein [Preismodell](https://docs.stripe.com/products-prices/pricing-models.md) zu erstellen, das Ihre [Produkte](https://docs.stripe.com/api/products.md) und deren Preisoptionen umfasst. [Preise](https://docs.stripe.com/api/prices.md) legen die Stückkosten, die Währung und den Rechnungsstellungszeitraum fest.

Für das Hypernian-Beispiel erstellen Sie ein Produkt mit einem zählerverknüpften Preis von 0,04&nbsp;USD pro hundert Einheiten, das in einem monatlichen Intervall abgerechnet wird. Sie verwenden den Zähler, das Sie im vorherigen Schritt erstellt haben.

#### Dashboard

1. Klicken Sie auf der Seite [Product Catalog](https://dashboard.stripe.com/products?active=true) auf **Produkt erstellen**.
1. Gehen Sie auf der Seite **Produkt hinzufügen** wie folgt vor:
   - Geben Sie bei **Name** den Namen Ihres Produkts ein. Geben Sie für das Hypernian-Beispiel `Hypernian` ein.
   - (Optional) Fügen Sie als **Beschreibung** eine Beschreibung hinzu, die im [Bezahlvorgang](https://docs.stripe.com/payments/checkout.md), im [Kundenportal](https://docs.stripe.com/customer-management.md) und in [Angeboten](https://docs.stripe.com/quotes.md) angezeigt wird.
   - Wählen Sie **Wiederkehrend** aus.
   - Wählen Sie unter **Rechnungsstellungszeitraum** die Option **Weitere Preisoptionen** aus.
1. Gehen Sie auf der Seite **Preis hinzufügen** wie folgt vor:
   - Wählen Sie unter **Preismodell auswählen** die Option **Nutzungsbasiert** aus.
   - Wählen Sie Ihre Preisstruktur:
     - Wählen Sie für das Hypernian-Beispiel die Option **Pro Paket** aus. Legen Sie unter **Preis** den **Betrag** auf `0,04 USD` pro `100` Einheiten.
     - Wählen Sie **Pro Einheit** aus, um den Preis nach Anzahl der Nutzer/innen, Einheiten oder Plätze zu ermitteln.
     - Wählen Sie **Pro Stufe** aus, um die [gestaffelte Preisgestaltung](https://docs.stripe.com/products-prices/pricing-models.md#tiered-pricing) zu aktivieren und die Stückkosten je nach Menge oder Nutzung zu ändern.
   - Wählen Sie unter **Zähler** den Zähler aus, den Sie in Schritt 1 erstellt haben. Wählen Sie im Hypernian-Beispiel **Hypernian-Tokens** aus dem Dropdown-Menü.
   - Wählen Sie den entsprechenden **Rechnungsstellungszeitraum** aus. Wählen Sie für das Hypernian-Beispiel **Monatlich**.
   - Klicken Sie auf **Weiter**.
1. Klicken Sie auf der Seite **Ein Produkt hinzufügen** auf **Produkt hinzufügen**.

#### API

Sie können Ihre Zähler-ID auf der Detailseite für Zähler finden.

```curl
curl https://api.stripe.com/v1/prices \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d currency=usd \
  -d unit_amount=4 \
  -d billing_scheme=per_unit \
  -d "transform_quantity[divide_by]"=100 \
  -d "transform_quantity[round]"=up \
  -d "recurring[usage_type]"=metered \
  -d "recurring[interval]"=month \
  -d "recurring[meter]"={{METER_ID}} \
  -d "product_data[name]"="Hypernian tokens"
```

```cli
stripe prices create  \
  --currency=usd \
  --unit-amount=4 \
  --billing-scheme=per_unit \
  -d "transform_quantity[divide_by]"=100 \
  -d "transform_quantity[round]"=up \
  -d "recurring[usage_type]"=metered \
  -d "recurring[interval]"=month \
  -d "recurring[meter]"={{METER_ID}} \
  -d "product_data[name]"="Hypernian tokens"
```

```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("<<YOUR_SECRET_KEY>>")

price = client.v1.prices.create({
  currency: 'usd',
  unit_amount: 4,
  billing_scheme: 'per_unit',
  transform_quantity: {
    divide_by: 100,
    round: 'up',
  },
  recurring: {
    usage_type: 'metered',
    interval: 'month',
    meter: '{{METER_ID}}',
  },
  product_data: {name: 'Hypernian tokens'},
})
```

```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("<<YOUR_SECRET_KEY>>")

# For SDK versions 12.4.0 or lower, remove '.v1' from the following line.
price = client.v1.prices.create({
  "currency": "usd",
  "unit_amount": 4,
  "billing_scheme": "per_unit",
  "transform_quantity": {"divide_by": 100, "round": "up"},
  "recurring": {"usage_type": "metered", "interval": "month", "meter": "{{METER_ID}}"},
  "product_data": {"name": "Hypernian tokens"},
})
```

```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('<<YOUR_SECRET_KEY>>');

$price = $stripe->prices->create([
  'currency' => 'usd',
  'unit_amount' => 4,
  'billing_scheme' => 'per_unit',
  'transform_quantity' => [
    'divide_by' => 100,
    'round' => 'up',
  ],
  'recurring' => [
    'usage_type' => 'metered',
    'interval' => 'month',
    'meter' => '{{METER_ID}}',
  ],
  'product_data' => ['name' => 'Hypernian tokens'],
]);
```

```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("<<YOUR_SECRET_KEY>>");

PriceCreateParams params =
  PriceCreateParams.builder()
    .setCurrency("usd")
    .setUnitAmount(4L)
    .setBillingScheme(PriceCreateParams.BillingScheme.PER_UNIT)
    .setTransformQuantity(
      PriceCreateParams.TransformQuantity.builder()
        .setDivideBy(100L)
        .setRound(PriceCreateParams.TransformQuantity.Round.UP)
        .build()
    )
    .setRecurring(
      PriceCreateParams.Recurring.builder()
        .setUsageType(PriceCreateParams.Recurring.UsageType.METERED)
        .setInterval(PriceCreateParams.Recurring.Interval.MONTH)
        .setMeter("{{METER_ID}}")
        .build()
    )
    .setProductData(
      PriceCreateParams.ProductData.builder().setName("Hypernian tokens").build()
    )
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
Price price = client.v1().prices().create(params);
```

```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

const price = await stripe.prices.create({
  currency: 'usd',
  unit_amount: 4,
  billing_scheme: 'per_unit',
  transform_quantity: {
    divide_by: 100,
    round: 'up',
  },
  recurring: {
    usage_type: 'metered',
    interval: 'month',
    meter: '{{METER_ID}}',
  },
  product_data: {
    name: 'Hypernian tokens',
  },
});
```

```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
sc := stripe.NewClient("<<YOUR_SECRET_KEY>>")
params := &stripe.PriceCreateParams{
  Currency: stripe.String(stripe.CurrencyUSD),
  UnitAmount: stripe.Int64(4),
  BillingScheme: stripe.String(stripe.PriceBillingSchemePerUnit),
  TransformQuantity: &stripe.PriceCreateTransformQuantityParams{
    DivideBy: stripe.Int64(100),
    Round: stripe.String(stripe.PriceTransformQuantityRoundUp),
  },
  Recurring: &stripe.PriceCreateRecurringParams{
    UsageType: stripe.String(stripe.PriceRecurringUsageTypeMetered),
    Interval: stripe.String(stripe.PriceRecurringIntervalMonth),
    Meter: stripe.String("{{METER_ID}}"),
  },
  ProductData: &stripe.PriceCreateProductDataParams{
    Name: stripe.String("Hypernian tokens"),
  },
}
result, err := sc.V1Prices.Create(context.TODO(), params)
```

```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new PriceCreateOptions
{
    Currency = "usd",
    UnitAmount = 4,
    BillingScheme = "per_unit",
    TransformQuantity = new PriceTransformQuantityOptions
    {
        DivideBy = 100,
        Round = "up",
    },
    Recurring = new PriceRecurringOptions
    {
        UsageType = "metered",
        Interval = "month",
        Meter = "{{METER_ID}}",
    },
    ProductData = new PriceProductDataOptions { Name = "Hypernian tokens" },
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Prices;
Price price = service.Create(options);
```

## Kundin/Kunden erstellen

Erstellen Sie als Nächstes eine/n *Kunden/Kundin* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments).

#### Dashboard

1. Klicken Sie auf der [Kundenseite](https://dashboard.stripe.com/test/customers) auf **Kund/in hinzufügen**.
1. Gehen Sie auf der Seite **Kunden/Kundin erstellen** wie folgt vor:
   - Geben Sie für **Name** den Namen Ihres Kunden oder Ihrer Kundin ein. Für das Hypernian-Beispiel geben Sie `John Doe` ein.
   - (Optional) Fügen Sie eine E-Mail-Adresse und eine Beschreibung für Ihre/n Kund/in hinzu.
   - Klicken Sie auf **Kunden/Kundin hinzufügen**.

#### API

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d name="John Doe"
```

```cli
stripe customers create  \
  --name="John Doe"
```

```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("<<YOUR_SECRET_KEY>>")

customer = client.v1.customers.create({name: 'John Doe'})
```

```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("<<YOUR_SECRET_KEY>>")

# For SDK versions 12.4.0 or lower, remove '.v1' from the following line.
customer = client.v1.customers.create({"name": "John Doe"})
```

```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('<<YOUR_SECRET_KEY>>');

$customer = $stripe->customers->create(['name' => 'John Doe']);
```

```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("<<YOUR_SECRET_KEY>>");

CustomerCreateParams params = CustomerCreateParams.builder().setName("John Doe").build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
Customer customer = client.v1().customers().create(params);
```

```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

const customer = await stripe.customers.create({
  name: 'John Doe',
});
```

```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
sc := stripe.NewClient("<<YOUR_SECRET_KEY>>")
params := &stripe.CustomerCreateParams{Name: stripe.String("John Doe")}
result, err := sc.V1Customers.Create(context.TODO(), params)
```

```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new CustomerCreateOptions { Name = "John Doe" };
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Customers;
Customer customer = service.Create(options);
```

## Abo erstellen

Mit [Abos](https://docs.stripe.com/api/subscriptions.md) können Sie wiederkehrende Beträge berechnen, indem Sie Kund/innen bestimmte Preise zuweisen.

Verwenden Sie das Stripe Dashboard oder die API, um ein Abo zu erstellen, das den/die Kund/in, das Produkt und den nutzungsbasierten Preis umfasst.

Für das Hypernian-Beispiel erstellen Sie ein Abo für das Hypernian-Produkt mit einem nutzungsbasierten Preis von 0,04&nbsp;USD pro 100 Einheiten, das monatlich an John Doe abgerechnet wird.

> Sie können einen einzelnen Zählerpreis mit einem oder mehreren Abos verknüpfen.
> 
> Wenn Sie ein `billing_mode=flexible`-Abo erstellen, schließt Stripe nutzungsbasierte Rechnungsposten von der ersten Rechnung aus, da keine vorherige Nutzung zur Abrechnung vorliegt. Stripe erstellt eine Rechnung nur, wenn das Abo mit der zuvor aufgelaufenen Nutzung rückdatiert wird oder ausstehende Rechnungen vorhanden sind. Wenn Sie ein `billing_mode=classic`-Abo erstellen, generiert Stripe für jeden nutzungsbasierten Posten einen Rechnungsposten ohne Geldwert.

#### Dashboard

1. Klicken Sie auf der Seite [Abos](https://dashboard.stripe.com/test/subscriptions) auf **Test-Abo erstellen**.
1. Gehen Sie auf der Seite **Testabo erstellen** wie folgt vor:
   - Wählen Sie unter **Kundin/Kunde** den Namen Ihres Kunden oder Ihrer Kundin aus. Wählen Sie im Hypernian-Beispiel **John Doe**.
   - Wählen Sie unter **Produkt** Ihren Preis aus. Wählen Sie im Hypernian-Beispiel den Preis unter **Hypernian**.
   - (Optional) Ändern Sie die Abodetails und -einstellungen nach Bedarf.
   - Klicken Sie auf **Testabo erstellen**.

#### API

Sie können Ihre Kunden-ID auf der Seite mit den Kundendetails finden. Um Ihre Preis-ID zu finden, gehen Sie auf die Seite mit den Produktdetails und klicken Sie unter **Preisgestaltung** auf das Überlaufmenü (⋯. Wählen Sie **Preis-ID kopieren**.

```curl
curl https://api.stripe.com/v1/subscriptions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d customer={{CUSTOMER_ID}} \
  -d "items[0][price]"={{PRICE_ID}}
```

```cli
stripe subscriptions create  \
  --customer={{CUSTOMER_ID}} \
  -d "items[0][price]"={{PRICE_ID}}
```

```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("<<YOUR_SECRET_KEY>>")

subscription = client.v1.subscriptions.create({
  customer: '{{CUSTOMER_ID}}',
  items: [{price: '{{PRICE_ID}}'}],
})
```

```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("<<YOUR_SECRET_KEY>>")

# For SDK versions 12.4.0 or lower, remove '.v1' from the following line.
subscription = client.v1.subscriptions.create({
  "customer": "{{CUSTOMER_ID}}",
  "items": [{"price": "{{PRICE_ID}}"}],
})
```

```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('<<YOUR_SECRET_KEY>>');

$subscription = $stripe->subscriptions->create([
  'customer' => '{{CUSTOMER_ID}}',
  'items' => [['price' => '{{PRICE_ID}}']],
]);
```

```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("<<YOUR_SECRET_KEY>>");

SubscriptionCreateParams params =
  SubscriptionCreateParams.builder()
    .setCustomer("{{CUSTOMER_ID}}")
    .addItem(SubscriptionCreateParams.Item.builder().setPrice("{{PRICE_ID}}").build())
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
Subscription subscription = client.v1().subscriptions().create(params);
```

```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

const subscription = await stripe.subscriptions.create({
  customer: '{{CUSTOMER_ID}}',
  items: [
    {
      price: '{{PRICE_ID}}',
    },
  ],
});
```

```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
sc := stripe.NewClient("<<YOUR_SECRET_KEY>>")
params := &stripe.SubscriptionCreateParams{
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  Items: []*stripe.SubscriptionCreateItemParams{
    &stripe.SubscriptionCreateItemParams{Price: stripe.String("{{PRICE_ID}}")},
  },
}
result, err := sc.V1Subscriptions.Create(context.TODO(), params)
```

```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new SubscriptionCreateOptions
{
    Customer = "{{CUSTOMER_ID}}",
    Items = new List<SubscriptionItemOptions>
    {
        new SubscriptionItemOptions { Price = "{{PRICE_ID}}" },
    },
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Subscriptions;
Subscription subscription = service.Create(options);
```

## Test-Zählerereignis senden

Verwenden Sie [Zählerereignisse](https://docs.stripe.com/api/billing/meter-event.md) zur [Aufzeichnung der Kundennutzung](https://docs.stripe.com/billing/subscriptions/usage-based/recording-usage.md) für Ihren Zähler. Am Ende des Rechnungsstellungszeitraums stellt Stripe die gemeldete Nutzung in Rechnung.

Sie können Ihre nutzungsbasierte Abrechnung testen, indem Sie ein Zählerereignis über das Stripe-Dashboard oder die API senden. Wenn Sie die API verwenden, geben Sie die Kunden-ID und den Wert für die `payload` an.

Nachdem Sie Zählerereignisse gesendet haben, können Sie die Nutzungsdetails für Ihren Zähler auf der Seite [Zähler](https://dashboard.stripe.com/test/meters) im Dashboard anzeigen.

#### Dashboard

1. Wählen Sie auf der Seite [Zähler](https://dashboard.stripe.com/test/meters) den Namen des Zählers aus. Wählen Sie im Hypernian-Beispiel **Hypernian-Token**.
1. Klicken Sie auf der Seite des Zählers auf **Nutzung hinzufügen** > **Nutzung manuell eingeben**.
1. Gehen Sie auf der Seite **Nutzung hinzufügen** wie folgt vor:
   - Wählen Sie Ihren Kunden/Ihre Kundin aus der Dropdown-Liste **Kunde/Kundin** aus.
   - Geben Sie für **Wert** einen Beispielwert ein. Geben Sie für das Hypernian-Beispiel `3000` ein.
   - Klicken Sie auf **Absenden**.

#### API

```curl
curl https://api.stripe.com/v1/billing/meter_events \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d event_name=hypernian_tokens \
  -d "payload[stripe_customer_id]"={{CUSTOMER_ID}} \
  -d "payload[value]"=25
```

```cli
stripe billing meter_events create  \
  --event-name=hypernian_tokens \
  -d "payload[stripe_customer_id]"={{CUSTOMER_ID}} \
  -d "payload[value]"=25
```

```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("<<YOUR_SECRET_KEY>>")

meter_event = client.v1.billing.meter_events.create({
  event_name: 'hypernian_tokens',
  payload: {
    stripe_customer_id: '{{CUSTOMER_ID}}',
    value: '25',
  },
})
```

```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("<<YOUR_SECRET_KEY>>")

# For SDK versions 12.4.0 or lower, remove '.v1' from the following line.
meter_event = client.v1.billing.meter_events.create({
  "event_name": "hypernian_tokens",
  "payload": {"stripe_customer_id": "{{CUSTOMER_ID}}", "value": "25"},
})
```

```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('<<YOUR_SECRET_KEY>>');

$meterEvent = $stripe->billing->meterEvents->create([
  'event_name' => 'hypernian_tokens',
  'payload' => [
    'stripe_customer_id' => '{{CUSTOMER_ID}}',
    'value' => '25',
  ],
]);
```

```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("<<YOUR_SECRET_KEY>>");

MeterEventCreateParams params =
  MeterEventCreateParams.builder()
    .setEventName("hypernian_tokens")
    .putPayload("stripe_customer_id", "{{CUSTOMER_ID}}")
    .putPayload("value", "25")
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
MeterEvent meterEvent = client.v1().billing().meterEvents().create(params);
```

```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

const meterEvent = await stripe.billing.meterEvents.create({
  event_name: 'hypernian_tokens',
  payload: {
    stripe_customer_id: '{{CUSTOMER_ID}}',
    value: '25',
  },
});
```

```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
sc := stripe.NewClient("<<YOUR_SECRET_KEY>>")
params := &stripe.BillingMeterEventCreateParams{
  EventName: stripe.String("hypernian_tokens"),
  Payload: map[string]string{"stripe_customer_id": "{{CUSTOMER_ID}}", "value": "25"},
}
result, err := sc.V1BillingMeterEvents.Create(context.TODO(), params)
```

```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new Stripe.Billing.MeterEventCreateOptions
{
    EventName = "hypernian_tokens",
    Payload = new Dictionary<string, string>
    {
        { "stripe_customer_id", "{{CUSTOMER_ID}}" },
        { "value", "25" },
    },
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Billing.MeterEvents;
Stripe.Billing.MeterEvent meterEvent = service.Create(options);
```

## Erstellen Sie eine Rechnungsvorschau

[Erstellen Sie eine Rechnungsvorschau](https://docs.stripe.com/api/invoices/create_preview.md), um eine Vorschau einer Kundenrechnung zu sehen, die Details wie Zählerpreis und Nutzungsmenge enthält.

#### Dashboard

1. Wählen Sie auf der Seite [Abonnements](https://dashboard.stripe.com/test/subscriptions) ein Abo aus. Wählen Sie im Hypernian-Beispiel das Abo für **John Doe**.

1. Scrollen Sie auf der Seite mit den Abonnementdetails nach unten zum Abschnitt **Anstehende Rechnung**. In der Vorschau der Rechnung wird der Abonnementbetrag angezeigt, der dem Kunden/der Kundin zum angegebenen Datum in Rechnung gestellt werden soll.

1. Klicken Sie auf **Vollständige Rechnung anzeigen**, um die vollständigen Details für die anstehende Rechnung anzuzeigen, einschließlich:

   - Kunde/Kundin
   - Abrechnungsmethode
   - Erstellungsdatum
   - Verbundenes Abo
   - Abo-Details (Verbrauchsmenge und Zählerpreis)
   - Fälliger Betrag

   Stripe verarbeitet Zählerereignisse asynchron, sodass anstehende Rechnungen möglicherweise kürzlich empfangene Zählerereignisse nicht sofort widerspiegeln.

#### API

```curl
curl https://api.stripe.com/v1/invoices/create_preview \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d subscription="{{SUBSCRIPTION_ID}}"
```

```cli
stripe invoices create_preview  \
  --subscription="{{SUBSCRIPTION_ID}}"
```

```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("<<YOUR_SECRET_KEY>>")

invoice = client.v1.invoices.create_preview({subscription: '{{SUBSCRIPTION_ID}}'})
```

```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("<<YOUR_SECRET_KEY>>")

# For SDK versions 12.4.0 or lower, remove '.v1' from the following line.
invoice = client.v1.invoices.create_preview({
  "subscription": "{{SUBSCRIPTION_ID}}",
})
```

```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('<<YOUR_SECRET_KEY>>');

$invoice = $stripe->invoices->createPreview([
  'subscription' => '{{SUBSCRIPTION_ID}}',
]);
```

```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("<<YOUR_SECRET_KEY>>");

InvoiceCreatePreviewParams params =
  InvoiceCreatePreviewParams.builder()
    .setSubscription("{{SUBSCRIPTION_ID}}")
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
Invoice invoice = client.v1().invoices().createPreview(params);
```

```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

const invoice = await stripe.invoices.createPreview({
  subscription: '{{SUBSCRIPTION_ID}}',
});
```

```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
sc := stripe.NewClient("<<YOUR_SECRET_KEY>>")
params := &stripe.InvoiceCreatePreviewParams{
  Subscription: stripe.String("{{SUBSCRIPTION_ID}}"),
}
result, err := sc.V1Invoices.CreatePreview(context.TODO(), params)
```

```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new InvoiceCreatePreviewOptions
{
    Subscription = "{{SUBSCRIPTION_ID}}",
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Invoices;
Invoice invoice = service.CreatePreview(options);
```

## Optional: Rufen Sie die Nutzung für einen spezifischen Zeitraum ab

Verwenden Sie die [Zählerereignisübersicht](https://docs.stripe.com/api/billing/meter-event-summary.md), um die Nutzung für einen benutzerdefinierten Zeitraum abzurufen. Die Zählerereignisübersicht gibt die zusammengefasste Nutzung eines Kunden/einer Kundin für einen Zeitraum zurück, der auf der vom Zähler definierten Aggregationsformel basiert.

Im Hypernian-Beispiel gibt die Zählerereignis-Zusammenfassung die Summe der Tokens für eine bestimmte Kundin oder einen bestimmten Kunden, einen bestimmten Zähler und ein bestimmtes Zeitfenster zurück.

Da Stripe Zählerereignisse asynchron verarbeitet, spiegeln anstehende Rechnungen möglicherweise kürzlich empfangene Zählerereignisse nicht sofort wider.

```curl
curl -G https://api.stripe.com/v1/billing/meters/{{METER_ID}}/event_summaries \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d customer={{CUSTOMER_ID}} \
  -d start_time=1717249380 \
  -d end_time=1717249440
```

```cli
stripe billing meter_event_summaries list {{METER_ID}} \
  --customer={{CUSTOMER_ID}} \
  --start-time=1717249380 \
  --end-time=1717249440
```

```ruby
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = Stripe::StripeClient.new("<<YOUR_SECRET_KEY>>")

meter_event_summaries = client.v1.billing.meters.event_summaries.list(
  '{{METER_ID}}',
  {
    customer: '{{CUSTOMER_ID}}',
    start_time: 1717249380,
    end_time: 1717249440,
  },
)
```

```python
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
client = StripeClient("<<YOUR_SECRET_KEY>>")

# For SDK versions 12.4.0 or lower, remove '.v1' from the following line.
meter_event_summaries = client.v1.billing.meters.event_summaries.list(
  "{{METER_ID}}",
  {"customer": "{{CUSTOMER_ID}}", "start_time": 1717249380, "end_time": 1717249440},
)
```

```php
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
$stripe = new \Stripe\StripeClient('<<YOUR_SECRET_KEY>>');

$meterEventSummaries = $stripe->billing->meters->allEventSummaries(
  '{{METER_ID}}',
  [
    'customer' => '{{CUSTOMER_ID}}',
    'start_time' => 1717249380,
    'end_time' => 1717249440,
  ]
);
```

```java
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeClient client = new StripeClient("<<YOUR_SECRET_KEY>>");

MeterEventSummaryListParams params =
  MeterEventSummaryListParams.builder()
    .setCustomer("{{CUSTOMER_ID}}")
    .setStartTime(1717249380L)
    .setEndTime(1717249440L)
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
StripeCollection<MeterEventSummary> stripeCollection =
  client.v1().billing().meters().eventSummaries().list("{{METER_ID}}", params);
```

```node
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

const meterEventSummaries = await stripe.billing.meters.listEventSummaries(
  '{{METER_ID}}',
  {
    customer: '{{CUSTOMER_ID}}',
    start_time: 1717249380,
    end_time: 1717249440,
  }
);
```

```go
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
sc := stripe.NewClient("<<YOUR_SECRET_KEY>>")
params := &stripe.BillingMeterEventSummaryListParams{
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  StartTime: stripe.Int64(1717249380),
  EndTime: stripe.Int64(1717249440),
  ID: stripe.String("{{METER_ID}}"),
}
result := sc.V1BillingMeterEventSummaries.List(context.TODO(), params)
```

```dotnet
// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
var options = new Stripe.Billing.MeterEventSummaryListOptions
{
    Customer = "{{CUSTOMER_ID}}",
    StartTime = DateTimeOffset.FromUnixTimeSeconds(1717249380).UtcDateTime,
    EndTime = DateTimeOffset.FromUnixTimeSeconds(1717249440).UtcDateTime,
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Billing.Meters.EventSummaries;
StripeList<Stripe.Billing.MeterEventSummary> meterEventSummaries = service.List(
    "{{METER_ID}}",
    options);
```

## Nächste Schritte

- [Zahlungen mit Stripe Checkout annehmen](https://docs.stripe.com/payments/checkout.md)
- [Warnungen und Schwellenwerte einrichten](https://docs.stripe.com/billing/subscriptions/usage-based/monitor.md)
- [Abrechnungsguthaben einrichten](https://docs.stripe.com/billing/subscriptions/usage-based/billing-credits/implementation-guide.md)