# Legen Sie das Erneuerungsdatum für die Abrechnungen des Abos fest

So legen Sie das Abrechnungsdatum für Abonnements fest.

Der Rechnungsstellungszeitraum eines Abos hängt von zwei Faktoren ab:

- Das wiederkehrende Intervall des [Preises](https://docs.stripe.com/products-prices/overview.md) oder der Preise, zum Beispiel monatlich, jährlich, wöchentlich usw.
- Der [Abrechnungszyklusanker](https://docs.stripe.com/api/subscriptions/object.md#subscription_object-billing_cycle_anchor) ist der Referenzpunkt, an dem zukünftige Rechnungsstellungszeiträume ausgerichtet werden. Er legt für `week`-Intervalle den Wochentag, für `month`- und `year`-Intervalle den Tag des Monats sowie für `year`-Intervalle den Monat des Jahres fest. Der Standardwert ist entweder das Erstellungsdatum des Abos oder das Ende der Testzeitraums (falls Sie einen solchen nutzen). Sie können diesen Wert auch ausdrücklich beim Erstellen des Abos festlegen.

> Abrechnungszyklusanker sind Unix-Zeitstempel in Sekunden, beginnend ab der aktuellen Epoche.

Im Folgenden finden Sie Beispiele für monatliche Abos mit unterschiedlichen Rechnungsstellungszeiträumen:

- Ein monatliches Abonnement mit einem Abrechnungszyklusanker am 2. September wird immer am 2. Tag des Monats abgerechnet.
- Bei einem monatlichen Abonnement mit dem 31. Januar als Datum des Abrechnungszyklusankers wird der letzte Tag des Monats in Rechnung gestellt, der am nächsten beim Ankerdatum liegt, also der 28. Februar (bzw. 29. Februar in einem Schaltjahr) und dann der 31. März, der 30. April usw.
- Ein wöchentliches Abonnement mit einem Abrechnungszyklusankerdatum am Freitag, dem 3. Juni wird anschließend jeden Freitag abgerechnet.

Vollständige Abrechnungszeiträume beginnen am ersten vollständigen *Rechnungsdatum* (Invoices are statements of amounts owed by a customer. They track the status of payments from draft through paid or otherwise finalized. Subscriptions automatically generate invoices, or you can manually create a one-off invoice), das oft mit dem Abrechnungszyklusanker übereinstimmt und immer intervallmäßig darauf ausgerichtet ist.

## Abrechnungszyklusanker für neue Abonnements bestimmen

> Der Zeitpunkt der Erstellung des Abonnements stimmt mit dem Zeitpunkt der Anfrage überein. Es ist nicht identisch mit dem Startdatum des Abonnements. Erfahren Sie mehr über [Rückdatierung und Abrechnungszyklusanker](https://docs.stripe.com/billing/subscriptions/backdating.md#backdating-billing-cycle).

Es gibt zwei Möglichkeiten, den Abrechnungszyklusanker für neue Abonnements festzulegen:

- Verwenden Sie `billing_cycle_anchor_config`, um den Zeitstempel für Sie zu berechnen (nur Monats- oder Jahresabonnements).
- Verwenden Sie `billing_cycle_anchor`, um den Zeitstempel direkt zu akzeptieren.

Wenn Sie ein monatliches oder jährliches Abo erstellen, empfehlen wir die Verwendung des Parameters `billing_cycle_anchor_config`, da dieser automatisch kurze Monate und Schaltjahre berücksichtigt. Wenn Sie ein tägliches oder wöchentliches Abo erstellen oder das Verlängerungsdatum Ihres Abos mithilfe eines Zeitstempels festlegen möchten, verwenden Sie den Parameter `billing_cycle_anchor` direkt.

### billing_cycle_anchor_config verwenden

Um eine Integration mit monatlichen und jährlichen Abonnements zu erstellen, verwenden Sie `billing_cycle_anchor_config` beim [Erstellen eines Abonnements](https://docs.stripe.com/api.md#create_subscription), um den Tag des Monats anzugeben, an dem Sie den Anker setzen möchten.

Legen Sie `day_of_month` auf `31` fest, um ein monatliches Abo zu erstellen, das am Monatsende verlängert wird – auch in Monaten mit weniger als 31 Tagen. Hat ein Monat weniger als 31 Tage, verlängert sich das Abo am letzten Tag dieses Monats.

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

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

```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}}'}],
  billing_cycle_anchor_config: {day_of_month: 31},
})
```

```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}}"}],
  "billing_cycle_anchor_config": {"day_of_month": 31},
})
```

```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}}']],
  'billing_cycle_anchor_config' => ['day_of_month' => 31],
]);
```

```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()
    )
    .setBillingCycleAnchorConfig(
      SubscriptionCreateParams.BillingCycleAnchorConfig.builder()
        .setDayOfMonth(31L)
        .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}}',
    },
  ],
  billing_cycle_anchor_config: {
    day_of_month: 31,
  },
});
```

```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}}")},
  },
  BillingCycleAnchorConfig: &stripe.SubscriptionCreateBillingCycleAnchorConfigParams{
    DayOfMonth: stripe.Int64(31),
  },
}
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}}" },
    },
    BillingCycleAnchorConfig = new SubscriptionBillingCycleAnchorConfigOptions
    {
        DayOfMonth = 31,
    },
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Subscriptions;
Subscription subscription = service.Create(options);
```

Sie können auch `month` angeben, um den Monat des Jahres für den Anker bei mehrmonatigen und jährlichen Abonnements zu steuern.

Um Ihre Jahresabonnements am ersten Juli zu verlängern, erstellen Sie ein Jahresabonnement mit einem `month` = `7` und `day_of_month` = `1`.

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

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

```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}}'}],
  billing_cycle_anchor_config: {
    month: 7,
    day_of_month: 1,
  },
})
```

```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}}"}],
  "billing_cycle_anchor_config": {"month": 7, "day_of_month": 1},
})
```

```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}}']],
  'billing_cycle_anchor_config' => [
    'month' => 7,
    'day_of_month' => 1,
  ],
]);
```

```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()
    )
    .setBillingCycleAnchorConfig(
      SubscriptionCreateParams.BillingCycleAnchorConfig.builder()
        .setMonth(7L)
        .setDayOfMonth(1L)
        .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}}',
    },
  ],
  billing_cycle_anchor_config: {
    month: 7,
    day_of_month: 1,
  },
});
```

```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}}")},
  },
  BillingCycleAnchorConfig: &stripe.SubscriptionCreateBillingCycleAnchorConfigParams{
    Month: stripe.Int64(7),
    DayOfMonth: stripe.Int64(1),
  },
}
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}}" },
    },
    BillingCycleAnchorConfig = new SubscriptionBillingCycleAnchorConfigOptions
    {
        Month = 7,
        DayOfMonth = 1,
    },
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Subscriptions;
Subscription subscription = service.Create(options);
```

Mit `billing_cycle_anchor_config` können Sie den genauen Monat, den Tag, die Stunde, die Minute und die Sekunde für den Abrechnungszyklusanker angeben. Wenn Sie Stunde, Minute und Sekunde nicht angeben, werden standardmäßig die Werte für die Erstellungszeit des Abonnements verwendet.

Für den Abrechnungszyklusanker wird die Koordinierte Weltzeit (UTC) verwendet. Wenn Sie beispielsweise ein Abonnement mit `billing_cycle_anchor_config` um 17&nbsp;Uhr EST erstellen, ohne die Stunde anzugeben, wird die Zeit im System als 22&nbsp;Uhr UTC aufgezeichnet.

`billing_cycle_anchor_config` unterstützt keine Verankerung auf einem rückdatierten Startdatum.

Wenn Sie beispielsweise ein bestehendes Monatsabonnement mit einem `billing_cycle_anchor`-Zeitstempel haben, der den Tag des Monats, die Stunde, die Minute und die Sekunde von 15, 12, 30 und 0 enthält, können Sie ein neues Monatsabonnement darauf ausrichten. Legen Sie dafür `day_of_month` `hour` `minute` `second` so fest, dass sie jeweils den gleichen Werten entsprechen.

```curl
curl https://api.stripe.com/v1/subscriptions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d customer="{{CUSTOMER_ID}}" \
  -d "items[0][price]"="{{PRICE_ID}}" \
  -d "billing_cycle_anchor_config[day_of_month]"=15 \
  -d "billing_cycle_anchor_config[hour]"=12 \
  -d "billing_cycle_anchor_config[minute]"=30 \
  -d "billing_cycle_anchor_config[second]"=0
```

```cli
stripe subscriptions create  \
  --customer="{{CUSTOMER_ID}}" \
  -d "items[0][price]"="{{PRICE_ID}}" \
  -d "billing_cycle_anchor_config[day_of_month]"=15 \
  -d "billing_cycle_anchor_config[hour]"=12 \
  -d "billing_cycle_anchor_config[minute]"=30 \
  -d "billing_cycle_anchor_config[second]"=0
```

```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}}'}],
  billing_cycle_anchor_config: {
    day_of_month: 15,
    hour: 12,
    minute: 30,
    second: 0,
  },
})
```

```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}}"}],
  "billing_cycle_anchor_config": {
    "day_of_month": 15,
    "hour": 12,
    "minute": 30,
    "second": 0,
  },
})
```

```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}}']],
  'billing_cycle_anchor_config' => [
    'day_of_month' => 15,
    'hour' => 12,
    'minute' => 30,
    'second' => 0,
  ],
]);
```

```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()
    )
    .setBillingCycleAnchorConfig(
      SubscriptionCreateParams.BillingCycleAnchorConfig.builder()
        .setDayOfMonth(15L)
        .setHour(12L)
        .setMinute(30L)
        .setSecond(0L)
        .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}}',
    },
  ],
  billing_cycle_anchor_config: {
    day_of_month: 15,
    hour: 12,
    minute: 30,
    second: 0,
  },
});
```

```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}}")},
  },
  BillingCycleAnchorConfig: &stripe.SubscriptionCreateBillingCycleAnchorConfigParams{
    DayOfMonth: stripe.Int64(15),
    Hour: stripe.Int64(12),
    Minute: stripe.Int64(30),
    Second: stripe.Int64(0),
  },
}
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}}" },
    },
    BillingCycleAnchorConfig = new SubscriptionBillingCycleAnchorConfigOptions
    {
        DayOfMonth = 15,
        Hour = 12,
        Minute = 30,
        Second = 0,
    },
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Subscriptions;
Subscription subscription = service.Create(options);
```

Wenn Sie `billing_cycle_anchor_config` verwenden, kann dies zu einem `billing_cycle_anchor` führen, der mehr als einen Abrechnungszeitraum in der Zukunft umfasst. Das Datum für die erste vollständige Rechnung liegt jedoch immer innerhalb eines Abrechnungszeitraums ab Erstellung des Abonnements oder Ende eines kostenlosen Testzeitraums.

Angenommen, Sie erstellen im Februar ein Abonnement mit zweimonatigem Intervall und schließen es am Ende jedes Monats ab, indem Sie `day_of_month` auf `31` setzen. Der nächste Monat mit 31&nbsp;Tagen im Zweimonatsintervall ab Februar ist der August, was zu einem Rechnungszyklusanker am 31.&nbsp;August führt. Das Datum der ersten vollständigen Rechnung für dieses Abonnement liegt jedoch immer noch im Februar. Es gibt einen anfänglichen , anteiligen Zeitraum von der Erstellung des Abonnements bis zum 28. Februar (oder 29. in einem Schaltjahr), gefolgt von einem zweimonatigen Abrechnungszeitraum.

### billing_cycle_anchor verwenden

Ein Abonnement können Sie mit einem expliziten Abrechnungszyklusanker über die Subscriptions API oder Checkout erstellen.

#### Subscriptions API

Rufen Sie [Abonnement erstellen](https://docs.stripe.com/api.md#create_subscription) auf und legen Sie einen Zeitstempel für `billing_cycle_anchor` fest.

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

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

```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}}'}],
  billing_cycle_anchor: 1611008505,
})
```

```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}}"}],
  "billing_cycle_anchor": 1611008505,
})
```

```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}}']],
  'billing_cycle_anchor' => 1611008505,
]);
```

```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()
    )
    .setBillingCycleAnchor(1611008505L)
    .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}}',
    },
  ],
  billing_cycle_anchor: 1611008505,
});
```

```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}}")},
  },
  BillingCycleAnchor: stripe.Int64(1611008505),
}
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}}" },
    },
    BillingCycleAnchor = DateTimeOffset.FromUnixTimeSeconds(1611008505).UtcDateTime,
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Subscriptions;
Subscription subscription = service.Create(options);
```

### Anteilmäßige Verrechnung konfigurieren

Unabhängig davon, welchen API-Parameter Sie verwenden, erstellt Stripe automatisch eine anteilige Rechnung für den Zeitraum zwischen dem Erstellungsdatum des Abonnements und dem ersten vollständigen Rechnungsdatum.

Wenn Sie einem Kunden/einer Kundin den Zeitraum zwischen der Erstellung des Abonnements und dem Datum der ersten vollständigen Rechnung nicht sofort in Rechnung stellen möchten, können Sie:

- Deaktivieren Sie die [anteilmäßige Verrechnung](https://docs.stripe.com/billing/subscriptions/prorations.md#disable-prorations), indem Sie `proration_behavior` auf `none` setzen, wodurch der anfängliche Zeitraum bis zum ersten vollständigen Rechnungsdatum kostenlos ist. Diese Aktion erzeugt bis zum ersten Rechnungsstellungszeitraum überhaupt keine Rechnung.
- [Kombinieren Sie einen kostenlosen Testzeitraum mit dem billing_cycle_anchor](https://docs.stripe.com/billing/subscriptions/trials.md#combine-trial-anchor), indem Sie `trial_end` einen Zeitstempel zuweisen, der das Enddatum des kostenlosen Testzeitraums darstellt. Je nach Dauer des kostenlosen Testzeitraums und der Anzahl der Tage bis zum Datum der ersten vollständigen Rechnung kann diese Option nach Ende des Testzeitraums eine anteilmäßige Rechnung mit sich bringen. Beispiel: Ein kostenloser Testzeitraum läuft 7&nbsp;Tage und der Abrechnungszyklus ist der 1.&nbsp;des Monats. Wenn das Abo am 15.&nbsp;abgeschlossen wird, erstellen wir am 22.&nbsp;eine anteilmäßige Rechnung für den Zeitraum zwischen dem 22.&nbsp;und dem 1.&nbsp;und stellen dann den vollen Betrag jeweils am 1.&nbsp;des Folgemonats in Rechnung. Wird das Abo am 28.&nbsp;abgeschlossen, so verlängert sich der kostenlose Testzeitraum über den 1.&nbsp;hinaus bis zum nächsten Monat.

#### Checkout

Verwenden Sie den Stripe Checkout-Aufruf zum [Erstellen einer Sitzung](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session) mit einem Zeitstempel für `subscription_data.billing_cycle_anchor`:

#### cURL

```bash
curl https://api.stripe.com/v1/checkout/sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -d "line_items[][price]"="{{PRICE_ID}}" \
  -d "line_items[][quantity]"=1 \
  -d "mode"="subscription" \
  -d "success_url"="https://example.com/success?session_id={CHECKOUT_SESSION_ID}" \-d "subscription_data[billing_cycle_anchor]"=1611008505
```

#### Ruby

```ruby

# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
Stripe.api_key = '<<YOUR_SECRET_KEY>>'

session = Stripe::Checkout::Session.create(
  line_items: [{
    price: '{{PRICE_ID}}',
    quantity: 1
  }],
  mode: 'subscription',
  success_url: 'https://example.com/success?session_id={CHECKOUT_SESSION_ID}',subscription_data: { billing_cycle_anchor:1611008505}
)

# Record the session ID in your system
session_id = session.id

# 303 redirect to session.url
```

#### Python

```python

# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
stripe.api_key = '<<YOUR_SECRET_KEY>>'

session = stripe.checkout.Session.create(
  line_items=[{
    'price': '{{PRICE_ID}}',
    'quantity': 1
  }],
  mode='subscription',
  success_url='https://example.com/success?session_id={CHECKOUT_SESSION_ID}',subscription_data={ 'billing_cycle_anchor':1611008505}
)

# Record the session ID in your system
session_id = session.id

# 303 redirect to session.url
```

#### PHP

```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\Stripe::setApiKey('<<YOUR_SECRET_KEY>>');

$session = \Stripe\Checkout\Session::create([
  'line_items' => [[
    'price' => '{{PRICE_ID}}',
    'quantity' => 1
    ]],
  'mode' => 'subscription',
  'success_url' => 'https://example.com/success?session_id={CHECKOUT_SESSION_ID}','subscription_data' => [ 'billing_cycle_anchor' =>1611008505]
]);

// Record the session ID in your system
$session_id = $session->id

// 303 redirect to $session->url
```

#### Java

```java

// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
Stripe.apiKey = "<<YOUR_SECRET_KEY>>";

SessionCreateParams params =
  SessionCreateParams.builder()
    .addLineItem(
      SessionCreateParams.LineItem.builder()
        .setQuantity(1L)
        .setPrice(""{{PRICE_ID}}"")
        .build())
    .setMode(SessionCreateParams.Mode.SUBSCRIPTION)
    .setSuccessUrl("https://example.com/success?session_id={CHECKOUT_SESSION_ID}").setSubscriptionData(
      SessionCreateParams.SubscriptionData.builder()
        .setBillingCycleAnchor(1611008505L)
        .build())
    .build();

Session session = Session.create(params);

// Record the session ID in your system
String sessionId = session.getId();

// 303 redirect to session.getUrl()
```

#### Node.js

```javascript

// 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 session = await stripe.checkout.sessions.create({
  line_items: [{
    price: '{{PRICE_ID}}',
    quantity: 1
  }],
  mode: 'subscription',
  success_url: 'https://example.com/success?session_id={CHECKOUT_SESSION_ID}',subscription_data: { billing_cycle_anchor:1611008505},
});

// Record the session ID in your system
const session_id = session.id

// 303 redirect to session.url
```

#### Go

```go

// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
stripe.Key = "<<YOUR_SECRET_KEY>>"

params := &stripe.CheckoutSessionParams{
    LineItems: []*stripe.CheckoutSessionLineItemParams{
        &stripe.CheckoutSessionLineItemParams{
            Price: stripe.String(""{{PRICE_ID}}""),
            Quantity: stripe.Int64(1)
        }
    },
    Mode: stripe.String("subscription"),
    SuccessURL: stripe.String("https://example.com/success?session_id={CHECKOUT_SESSION_ID}"),SubscriptionData: &stripe.CheckoutSessionSubscriptionDataParams{
      BillingCycleAnchor: stripe.Int64(1611008505)
    },

}

session, err := session.New(params)

// Record the session ID in your system
session_id := session.ID

// 303 redirect to session.URL
```

#### .NET

```dotnet

// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
StripeConfiguration.ApiKey = "<<YOUR_SECRET_KEY>>";

var options = new SessionCreateOptions {
    LineItems = new List<SessionLineItemOptions>
    {
        new SessionLineItemOptions
        {
            Price = ""{{PRICE_ID}}"",
            Quantity = 1
        }
    },
    Mode = "subscription",
    SuccessUrl = "https://example.com/success?session_id={CHECKOUT_SESSION_ID}",SubscriptionData = new SessionSubscriptionDataOptions
    {
        BillingCycleAnchor = DateTimeOffset.FromUnixTimeSeconds(1611008505).UtcDateTime
    },
};

var service = new SessionService();
Session session = service.Create(options);

// Record the session ID in your system
string sessionId = session.getId()

// 303 redirect to session.Url
```

Checkout muss sich im `subscription`-Modus befinden, damit ein Abrechnungszyklusanker definiert werden kann.

### Anteilmäßige Verrechnung konfigurieren

Sie können mithilfe des Parameters `proration_behavior` konfigurieren, wie Sie mit dem Zeitraum zwischen der Erstellung des Abonnements und dem Datum der ersten vollständigen Rechnung verfahren möchten. In Checkout können Testzeiträume nicht mit einem Abrechnungszyklusanker kombiniert werden.

- Lassen Sie die Standardeinstellung `create_prorations` aktiviert. Dadurch kann Stripe den Kundinnen/Kunden sofort eine Rechnung für den Zeitraum zwischen dem Abonnementdatum und dem Datum der ersten vollständigen Rechnung stellen.
- [Deaktivieren Sie die anteilmäßige Verrechnung](https://docs.stripe.com/payments/checkout/billing-cycle.md?ui=embedded-form#disable-prorations), indem Sie `proration_behavior` auf `none` setzen, wodurch der anfängliche Zeitraum (bis zum ersten vollständigen Rechnungsdatum) kostenlos ist. Diese Aktion erzeugt bis zum ersten Rechnungsstellungszeitraum überhaupt keine Rechnung.

> Sie können keine einmaligen Preise in Checkout-Sitzungen verwenden, wenn `proration_behavior` den Wert `none` hat.

## Ändern Sie den Rechnungsstellungszeitraum bei bestehenden Abos

Verwenden Sie die [Subscriptions API](https://docs.stripe.com/api/subscriptions/update.md) oder das [Dashboard](https://dashboard.stripe.com/subscriptions), um das Abrechnungsdatum eines bestehenden Abonnements über eine der folgenden Optionen zu ändern:

- Setzen Sie den Abrechnungszyklusanker auf den aktuellen Zeitpunkt zurück.
- Fügen Sie einen [kostenlosen Testzeitraum](https://docs.stripe.com/billing/subscriptions/trials.md) hinzu. Dadurch wird das Ankerdatum automatisch auf das Ende des Testzeitraums festgelegt. Testzeiträume starten in der Regel, wenn ein Abonnement erstellt wird, sie können aber auch auf bestehende Abonnements angewendet werden. In dem Fall können Sie Kundinnen/Kunden verbleibende Tage aus dem vorherigen Zyklus, die bereits bezahlt wurden, gutschreiben.

Das Datum Ihres Abrechnungszyklus ändert sich in diesen Szenarien. Wenn Sie jedoch ein Abonnement mit `billing_mode[type]=flexible` erstellen oder aktualisieren, bleibt der Abrechnungszyklusanker unverändert. Erfahren Sie mehr über das [Konfigurieren des flexiblen Abrechnungsmodus](https://docs.stripe.com/billing/subscriptions/billing-mode.md) und die damit verbundenen [Einschränkungen](https://docs.stripe.com/billing/subscriptions/billing-mode.md#limitations).

- Wenn alle Preise Nullbeträge sind, wird durch das Hinzufügen eines oder mehrerer bezahlter Preise der Rechnungsstellungszeitraum sofort zurückgesetzt. Weitere Informationen finden Sie in der Anleitung [Preise für Abonnements ändern](https://docs.stripe.com/billing/subscriptions/change-price.md#handle-zero-amount-prices-and-quantities).
- Der `billing_cycle_anchor` wird auf das [cancel_at](https://docs.stripe.com/api/subscriptions/object.md#subscription_object-cancel_at)-Datum zurückgesetzt, wenn ein Abo mit einem `cancel_at`-Datum erstellt wird, das vor der nächsten Verlängerung des Abos liegt oder wenn ein bestehendes `cancel_at`-Datum bei einem Abo geändert wird, dessen `billing_cycle_anchor` nach dem neuen `cancel_at`-Datum liegt.
- Der `billing_cycle_anchor` wird auf den aktuellen Zeitpunkt zurückgesetzt, wenn zu einem Preis mit einem anderen [recurring.interval](https://docs.stripe.com/api/prices/object.md#price_object-recurring) gewechselt wird.

### Setzen Sie den Rechnungsstellungszeitraum auf die aktuelle Zeit zurück

Um den Abrechnungszyklusanker auf die aktuelle Zeit zurückzusetzen, stellen Sie eine Aktualisierungsanfrage mit `billing_cycle_anchor` auf `now`. Dadurch wird der Abrechnungszyklusanker auf den Zeitpunkt der Aktualisierungsanforderung gesetzt. Nachdem Sie den Abrechnungszyklusanker zurückgesetzt haben, sendet Stripe sofort eine Rechnung. Aktivieren Sie [anteilmäßige Verrechnung](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-proration_behavior), um der Kundin oder dem Kunden die Tage gutzuschreiben, die bereits in dem vorherigen Zeitraum bezahlt wurden. Wenn Sie die anteilmäßige Verrechnung deaktivieren, kann dies zu überhöhten Preisen für Ihre Kundinnen und Kunden führen.

#### API

Rufen Sie auf [Abonnement aktualisieren](https://docs.stripe.com/api.md#update_subscription) auf, setzen `billing_cycle_anchor` auf `now` und `proration_behavior` auf `create_prorations`. So verhindern Sie, dass Kundinnen/Kunden für Tage aus dem vorherigen Zyklus doppelt bezahlen.

```curl
curl https://api.stripe.com/v1/subscriptions/sub_49ty4767H20z6a \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d billing_cycle_anchor=now \
  -d proration_behavior=create_prorations
```

```cli
stripe subscriptions update sub_49ty4767H20z6a \
  --billing-cycle-anchor=now \
  --proration-behavior=create_prorations
```

```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.update(
  'sub_49ty4767H20z6a',
  {
    billing_cycle_anchor: 'now',
    proration_behavior: 'create_prorations',
  },
)
```

```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.update(
  "sub_49ty4767H20z6a",
  {"billing_cycle_anchor": "now", "proration_behavior": "create_prorations"},
)
```

```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->update(
  'sub_49ty4767H20z6a',
  [
    'billing_cycle_anchor' => 'now',
    'proration_behavior' => 'create_prorations',
  ]
);
```

```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>>");

SubscriptionUpdateParams params =
  SubscriptionUpdateParams.builder()
    .setBillingCycleAnchor(SubscriptionUpdateParams.BillingCycleAnchor.NOW)
    .setProrationBehavior(SubscriptionUpdateParams.ProrationBehavior.CREATE_PRORATIONS)
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
Subscription subscription =
  client.v1().subscriptions().update("sub_49ty4767H20z6a", 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.update(
  'sub_49ty4767H20z6a',
  {
    billing_cycle_anchor: 'now',
    proration_behavior: 'create_prorations',
  }
);
```

```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 SubscriptionUpdateOptions
{
    BillingCycleAnchor = SubscriptionBillingCycleAnchor.Now,
    ProrationBehavior = "create_prorations",
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Subscriptions;
Subscription subscription = service.Update("sub_49ty4767H20z6a", options);
```

```go
params := &stripe.SubscriptionParams{
  BillingCycleAnchor: stripe.String("now"),
  ProrationBehavior: stripe.String("create_prorations"),
};
result, _ := subscription.Update("sub_49ty4767H20z6a", params);
```

#### Dashboard

1. Klicken Sie in der [Abonnement-Übersicht](https://docs.stripe.com/api/subscriptions.md) auf das Überlaufmenü ⋯ und wählen Sie **Abonnement aktualisieren** aus.
1. Scrollen Sie zu **Erweiterte Optionen** und wählen Sie **Abrechnungszeitraum zurücksetzen**.
1. Aktivieren Sie die Umschaltfläche **Änderungen anteilmäßig verrechnen**, um zu verhindern, dass sie Kundinnen/Kunden für bereits bezahlte Tage aus dem vorherigen Zyklus zu viel berechnen.
1. Klicken Sie auf **Abo aktualisieren**.

### Ändern Sie den Rechnungsstellungszeitraum mit einem Testzeitraum

Sie können den Abrechnungszyklusanker ändern, indem Sie eine [kostenlose Testversion](https://docs.stripe.com/abrechnung/abonnements/trials.md) verwenden, um das Ankerdatum des Abrechnungszyklus automatisch auf das Datum `trial_end` zu setzen.

Wenn eine Kundin oder ein Kunde beispielsweise ein aktives Abonnement abgeschlossen hat, das ursprünglich am 23.&nbsp;Juli in Rechnung gestellt werden sollte, und Sie am 15.&nbsp;Juli einen Testzeitraum einführen, der am 1.&nbsp;August endet:

- Die Kundin oder der Kunde erhält am 15.&nbsp;Juli eine Rechnung über 0&nbsp;USD. Sie haben bereits im vorherigen Zyklus bis zum 23.&nbsp;Juli gezahlt, daher gilt der „kostenlose“ Zeitraum nur vom 24.&nbsp;Juli bis zum 31.&nbsp;Juli.
- Der Kundin/dem Kunden wird am 23.&nbsp;Juli keine Rechnung gestellt.
- Der neue Zyklus, der am 1.&nbsp;August in Rechnung gestellt wird, ist ein voller Zyklus zum Normaltarif, danach wieder am 1.&nbsp;eines jeden Monats.

Optional können Sie die anteilige Verrechnung verhindern, wenn Sie ein Abo aktualisieren, um einen kostenlosen Testzeitraum zu starten, indem Sie`proration_behavior=none` verwenden. Wenn Sie den Testzeitraum nutzen, um den Rechnungsstellungszeitraum zu ändern, ohne eine anteilige Rechnung auszustellen, deaktivieren Sie in den meisten Fällen die anteilige Verrechnung, da die Länge des Testzeitraums den bereits gezahlten Teil des vorherigen Rechnungsstellungszeitraums berücksichtigt.

#### API

Rufen Sie [Abonnement aktualisieren](https://docs.stripe.com/api.md#update_subscription) auf, legen `trial_end` auf einen Unix-Zeitstempel fest, der das Enddatum für den Testzeitraum angibt, und setzen Sie `proration_behavior` auf `none`. Durch das Setzen von `trial_end` wird der Abrechnungszyklusanker auf das gleiche Datum gesetzt.

```curl
curl https://api.stripe.com/v1/subscriptions/sub_49ty4767H20z6a \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d trial_end=1627801200 \
  -d proration_behavior=none
```

```cli
stripe subscriptions update sub_49ty4767H20z6a \
  --trial-end=1627801200 \
  --proration-behavior=none
```

```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.update(
  'sub_49ty4767H20z6a',
  {
    trial_end: 1627801200,
    proration_behavior: 'none',
  },
)
```

```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.update(
  "sub_49ty4767H20z6a",
  {"trial_end": 1627801200, "proration_behavior": "none"},
)
```

```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->update(
  'sub_49ty4767H20z6a',
  [
    'trial_end' => 1627801200,
    'proration_behavior' => 'none',
  ]
);
```

```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>>");

SubscriptionUpdateParams params =
  SubscriptionUpdateParams.builder()
    .setTrialEnd(1627801200L)
    .setProrationBehavior(SubscriptionUpdateParams.ProrationBehavior.NONE)
    .build();

// For SDK versions 29.4.0 or lower, remove '.v1()' from the following line.
Subscription subscription =
  client.v1().subscriptions().update("sub_49ty4767H20z6a", 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.update(
  'sub_49ty4767H20z6a',
  {
    trial_end: 1627801200,
    proration_behavior: 'none',
  }
);
```

```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.SubscriptionUpdateParams{
  TrialEnd: stripe.Int64(1627801200),
  ProrationBehavior: stripe.String("none"),
}
result, err := sc.V1Subscriptions.Update(context.TODO(), "sub_49ty4767H20z6a", 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 SubscriptionUpdateOptions
{
    TrialEnd = DateTimeOffset.FromUnixTimeSeconds(1627801200).UtcDateTime,
    ProrationBehavior = "none",
};
var client = new StripeClient("<<YOUR_SECRET_KEY>>");
var service = client.V1.Subscriptions;
Subscription subscription = service.Update("sub_49ty4767H20z6a", options);
```

#### Dashboard

1. Wählen Sie in der [Abonnement-Übersicht](https://docs.stripe.com/api/subscriptions.md) das Abonnement aus, das Sie ändern möchten, um die zugehörige Detailseite zu öffnen.
1. Klicken Sie auf **Aktionen** > **Abonnement aktualisieren**.
1. Klicken Sie auf **Testzeitraum hinzufügen** und geben Sie die Anzahl der gewünschten Tage für den Zeitraum ein. Das Ende des Testzeitraums wird zum Ankerdatum des neuen Abrechnungszyklus.
1. Deaktivieren Sie die Option **Änderungen anteilmäßig verrechnen**, um zu verhindern, dass Sie Kundinnen/Kunden bereits bezahlte Tage gutschreiben.
1. Klicken Sie auf **Abo aktualisieren**.

## Nutzungsbasierte Abrechnung

Bei der [nutzungsbasierten Abrechnung](https://docs.stripe.com/products-prices/pricing-models.md) variiert der von der Kundin/vom Kunden gezahlte Preis je nach Konsum im Rechnungsstellungszeitraums. Wenn durch die Änderung des Rechnungsstellungszeitraums der Servicezeitraum eines Abos vorzeitig endet, berechnen Sie der Kundin/dem Kunden die Nutzung, die während des verkürzten Rechnungsstellungszeitraums angefallen ist.

### Abrechnungsschwellen

Zusätzlich zum regulären Zyklus können Sie Abonnements für die Abrechnung konfigurieren, wenn der fällige Betrag einen bestimmten [Schwellenwert](https://docs.stripe.com/billing/subscriptions/usage-based/thresholds.md) erreicht.

Wenn Sie ein Abo so konfiguriert haben, dass es auf diese Weise in Rechnung gestellt wird, können Sie es so einrichten, dass der Servicezeitraum des Abos beim Erreichen des Schwellenwerts zurückgesetzt wird.

## See also

- [Testphasen verwenden](https://docs.stripe.com/billing/subscriptions/trials.md)
- [Abonnement aktualisieren](https://docs.stripe.com/api.md#update_subscription)