# Configurez un modèle de tarification à l’utilisation
Facturez les clients en fonction de leur utilisation de votre produit ou service :
La [tarification à l’utilisation](https://docs.stripe.com/subscriptions/pricing-models/usage-based-pricing.md#pay-as-you-go) est un modèle flexible et évolutif qui vous permet de facturer les clients à terme échu pour l’utilisation qu’ils accumulent. Les entreprises d’IA, les plateformes SaaS et les services cloud utilisent souvent ce modèle économique.
## Ce que vous allez créer
Ce guide explique comment mettre en place une tarification à l’usage sur Stripe pour une entreprise fictive appelée Hypernian. Hypernian facture ses clients selon les tarifs suivants pour ses modèles LLM :
| Utilisation | Frais |
| ----------- | ----------------------------- |
| Token | 0.04 USD pour 100 tokens |
Pour implémenter ce modèle de tarification, vous créez un compteur, configurez la tarification et la facturation et envoyez des événements de mesure pour enregistrer la consommation du client à l’aide de [Products](https://docs.stripe.com/api/products.md) et [Prices](https://docs.stripe.com/api/prices.md).
## Créer un compteur
Les compteurs indiquent comment regrouper les événements des compteurs au cours d’une période de facturation. Les événements de mesure représentent toutes les actions effectuées par les clients dans votre système (par exemple, les requêtes d’API). Les compteurs sont associés aux prix et constituent la base de ce qui est facturé.
Pour l’exemple d’Hypernian, les événements de mesure correspondent au nombre de tokens qu’un client utilise lors d’une requête. Le compteur correspond à la somme des tokens sur un mois.
Vous pouvez utiliser le Dashboard Stripe ou l’API pour configurer un compteur. Pour utiliser l’API avec la Stripe CLI pour créer un compteur, [démarrer avec la Stripe CLI](https://docs.stripe.com/stripe-cli.md).
#### Dashboard
1. Sur la page [Compteurs](https://dashboard.stripe.com/test/meters), cliquez sur **Créer un compteur**.
1. Dans l’éditeur de compteurs :
- Pour **Nom du compteur**, entrez le nom du compteur à des fins d’affichage et d’organisation. Pour l’exemple d’Hypernian, entrez « Hypernian tokens ».
- Pour **Nom de l’événement**, entrez le nom à afficher dans les événements de mesure lors du rapport d’utilisation à Stripe. Pour l’exemple d’Hypernian, entrez « hypernian_tokens ».
- Définissez la **Méthode d’agrégation** dans le menu déroulant :
- Pour l’exemple d’Hypernian, sélectionnez**Sum**. Cette option *additionnera les valeurs* indiquées (dans cet exemple, le nombre de tokens utilisés par un client) afin de déterminer l’utilisation à facturer.
- Choisissez **Compte** pour que la facturation soit établie en fonction du *nombre* d’événements signalés.
- Choisissez **Dernier** pour établir la facture sur la base de la *dernière valeur* déclarée.
- Utilisez le volet de version bêta pour définir des exemples d’événements d’utilisation et vérifier la méthode d’agrégation.
- Cliquez sur **Créer un compteur**.
- (Facultatif) Sous **Paramètres avancés**, indiquez les **Dimensions** que vous souhaitez utiliser pour marquer vos données d’utilisation. Cela vous permet de générer des alertes spécifiques par segment, ou de définir un tarif basé sur l’utilisation précis en fonction d’une combinaison d’attributs. Pour l’analyse et le reporting, soumettez vos données d’utilisation avec des dimensions prédéfinies. Exemples de dimensions : modèle LLM, type de token, région ou type d’événement.
#### API
```curl
curl https://api.stripe.com/v1/billing/meters \
-u "<>:" \
-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("<>")
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("<>")
# 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('<>');
$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("<>");
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')('<>');
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("<>")
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("<>");
var service = client.V1.Billing.Meters;
Stripe.Billing.Meter meter = service.Create(options);
```
## Créer un modèle tarifaire
Utilisez le Dashboard Stripe ou l’API pour créer un [modèle tarifaire](https://docs.stripe.com/products-prices/pricing-models.md) qui inclut vos [Products](https://docs.stripe.com/api/products.md) et leurs options tarifaires. Les [Prices](https://docs.stripe.com/api/prices.md) définissent le coût unitaire, la devise et la période de facturation.
Pour l’exemple d’Hypernian, créez un produit dont le tarif mesuré est de 0,04 USD par centaine d’unités, facturé mensuellement. Vous utilisez le compteur que vous avez créé à l’étape précédente.
#### Dashboard
1. Sur la page [Catalogue de produits](https://dashboard.stripe.com/products?active=true), cliquez sur **Créer un produit**.
1. Sur la page **Ajouter un produit**, procédez comme suit :
- Pour **Nom**, entrez le nom de votre produit. Pour l’exemple d’Hypernian, entrez `Utilisation d'Hypernian`.
- (Facultatif) Pour **Description**, ajoutez une description qui apparaîtra dans [Checkout](https://docs.stripe.com/payments/checkout.md), dans le[portail client](https://docs.stripe.com/customer-management.md) et dans [devis](https://docs.stripe.com/quotes.md).
- Sélectionnez **Récurrent**.
- Sous **Période de facturation**, sélectionnez **Autres options tarifaires**.
1. Sur la page **Ajouter un tarif**, procédez comme suit :
- Sous **Choisissez votre modèle de tarification**, sélectionnez **À l’usage**.
- Choisissez votre structure de prix :
- Pour l’exemple d’Hypernian, sélectionnez **Par lot**. Sous **Prix**, fixez le **Montant** à `0,04 USD` par `100` unités.
- Sélectionnez **Par unité** pour fixer le prix en fonction du nombre d’utilisateurs, d’unités ou de sièges.
- Sélectionnez **Par niveau** pour activer la [tarification échelonnée](https://docs.stripe.com/products-prices/pricing-models.md#tiered-pricing) puis modifiez le coût unitaire en fonction de la quantité ou de l’utilisation.
- Sous **Compteur**, sélectionnez le compteur que vous avez créé à l’étape 1. Pour l’exemple d’Hypernian, sélectionnez **Hypernian tokens** dans le menu déroulant.
- Sélectionnez la **Période de facturation** appropriée. Pour l’exemple d’Hypernian, sélectionnez **Mensuel**.
- Cliquez sur **Suivant**.
1. Sur la page **Ajouter un produit**, cliquez sur **Ajouter un produit**.
#### API
Vous pouvez trouver l’identifiant de votre compteur sur la page d’information du compteur.
```curl
curl https://api.stripe.com/v1/prices \
-u "<>:" \
-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("<>")
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("<>")
# 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('<>');
$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("<>");
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')('<>');
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("<>")
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("<>");
var service = client.V1.Prices;
Price price = service.Create(options);
```
## Créer un objet Customer
Si votre plateforme Connect utilise des [comptes configurés par le client](https://docs.stripe.com/api/v2/core/accounts/create.md#v2_create_accounts-configuration-customer), consultez notre [guide](https://docs.stripe.com/connect/use-accounts-as-customers.md) pour remplacer dans votre code les références `Customer` et événements par les références équivalentes de l’API Comptes v2.
Ensuite, créez un *client* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments).
#### Dashboard
1. Sur la page [Clients](https://dashboard.stripe.com/test/customers), cliquez sur **Ajouter un client**.
1. Sur la page **Créer un client**, procédez comme suit :
- Pour **Nom**, entrez le nom de votre client. Pour l’exemple d’Hypernian, entrez `Jean Martin`.
- (Optional) Ajoutez une adresse e-mail et une description pour votre client.
- Cliquez sur **Ajouter un client**.
#### API
```curl
curl https://api.stripe.com/v1/customers \
-u "<>:" \
-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("<>")
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("<>")
# 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('<>');
$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("<>");
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')('<>');
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("<>")
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("<>");
var service = client.V1.Customers;
Customer customer = service.Create(options);
```
## Créer un abonnement
[Subscriptions](https://docs.stripe.com/api/subscriptions.md) vous permet de débiter des montants récurrents en associant un client à un prix spécifique.
Utilisez le Dashboard Stripe ou l’API pour créer un abonnement qui comprend votre client, votre produit et un prix basé sur l’usage.
Pour l’exemple d’Hypernian, vous créez un abonnement pour le produit Hypernian, avec un prix mesuré de 0,04 USD pour 100 unités, facturé mensuellement à John Doe.
> Vous pouvez associer un tarif unique mesuré à un ou plusieurs abonnements.
>
> Lorsque vous créez un abonnement `billing_mode=flexible`, Stripe exclut les postes compteurs de la première facture, car il n’existe pas d’utilisation antérieure à facturer. Si l’abonnement est initialisé avec une utilisation déjà accumulée ou si des éléments de facture en attente existent, Stripe les facture. Lorsque vous créez un abonnement `billing_mode=classic`, Stripe génère une ligne d’élément de facture à valeur monétaire nulle pour chaque élément d’abonnement mesuré.
#### Dashboard
1. Sur la page [Abonnements](https://dashboard.stripe.com/test/subscriptions), cliquez sur **Créer un abonnement test**.
1. Sur la page **Créer un abonnement test**, procédez comme suit :
- Sous **Client**, sélectionnez le nom de votre client. Pour l’exemple d’Hypernian, sélectionnez **Jean Dupont**.
- Sous **Produit**, sélectionnez votre tarif. Pour l’exemple d’Hypernian, sélectionnez le tarif sous **Hypernian**.
- (Facultatif) Modifiez les informations et les paramètres de l’abonnement si nécessaire.
- Cliquez sur **Créer un abonnement test**.
#### API
Votre identifiant client se trouve sur la page d’information du client. Pour trouver votre identifiant de prix, rendez-vous sur la page d’information du produit et cliquez sur le menu déroulant (% icon type=“overflow” %) sous **Tarification**. Sélectionnez **Copier l’identifiant du prix**.
```curl
curl https://api.stripe.com/v1/subscriptions \
-u "<>:" \
-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("<>")
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("<>")
# 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('<>');
$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("<>");
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')('<>');
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("<>")
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
{
new SubscriptionItemOptions { Price = "{{PRICE_ID}}" },
},
};
var client = new StripeClient("<>");
var service = client.V1.Subscriptions;
Subscription subscription = service.Create(options);
```
## Envoyer un événement de test de compteur
Utilisez [Meter Events](https://docs.stripe.com/api/billing/meter-event.md) pour [enregistrer l’utilisation du client](https://docs.stripe.com/billing/subscriptions/usage-based/recording-usage.md) de votre compteur. À la fin de la période de facturation, Stripe facture l’utilisation déclarée.
Vous pouvez tester votre facturation à l’usage en envoyant un événement de mesure via le Dashboard Stripe ou l’API. Lorsque vous utilisez l’API, spécifiez l’ID du client et la valeur de `payload`.
Après avoir envoyé des événements de mesure, vous pouvez consulter les détails de l’utilisation de votre compteur sur la page [Compteurs](https://dashboard.stripe.com/test/meters) du Dashboard.
#### Dashboard
1. Sur la page [Compteurs](https://dashboard.stripe.com/test/meters), sélectionnez le nom du compteur. Pour l’exemple d’Hypernian, sélectionnez **Hypernian tokens**.
1. Sur la page du compteur, cliquez sur **Ajouter une utilisation** > **Saisie manuelle des données d’utilisation**.
1. Dans la page **Ajouter des données de consommation**, procédez comme suit :
- Dans le menu déroulant **Client**, sélectionnez votre client.
- For **Value**, entrez une valeur d’exemple. Pour l’exemple d’Hypernian, entrez `3 000`.
- Cliquez sur **Envoyer**.
#### API
```curl
curl https://api.stripe.com/v1/billing/meter_events \
-u "<>:" \
-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("<>")
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("<>")
# 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('<>');
$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("<>");
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')('<>');
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("<>")
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
{
{ "stripe_customer_id", "{{CUSTOMER_ID}}" },
{ "value", "25" },
},
};
var client = new StripeClient("<>");
var service = client.V1.Billing.MeterEvents;
Stripe.Billing.MeterEvent meterEvent = service.Create(options);
```
## Créer une version bêta de la facture
[Créez un aperçu de la facture](https://docs.stripe.com/api/invoices/create_preview.md) pour afficher une version bêta de la facture d’un client qui comprend des détails tels que le prix du compteur et la quantité d’utilisation.
#### Dashboard
1. Sur la page [Abonnements](https://dashboard.stripe.com/test/subscriptions), sélectionnez un abonnement. Pour l’exemple d’Hypernian, sélectionnez l’abonnement de **Jean Martin**.
1. Sur la page d’information de l’abonnement, descendez jusqu’à la section **Facture à venir**. La facture à venir indique le montant de l’abonnement à facturer au client à la date spécifiée.
1. En cliquant sur **Afficher la facture complète**, vous obtiendrez toutes les informations de la facture à venir, dont :
- Client
- Méthode de facturation
- Date de création
- Abonnement connecté
- Informations de l’abonnement (quantité d’utilisation et tarif du dispositif)
- Montant dû
Étant donné que Stripe traite les événements de mesure de manière asynchrone, les factures à venir risquent de ne pas afficher immédiatement les derniers événements de mesure.
#### API
```curl
curl https://api.stripe.com/v1/invoices/create_preview \
-u "<>:" \
-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("<>")
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("<>")
# 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('<>');
$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("<>");
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')('<>');
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("<>")
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("<>");
var service = client.V1.Invoices;
Invoice invoice = service.CreatePreview(options);
```
## Optional: Récupérer l'utilisation sur une période personnalisée
Utilisez [Meter Event Summary](https://docs.stripe.com/api/billing/meter-event-summary.md) pour récupérer l’utilisation totale d’un client sur une période personnalisée. Le récapitulatif des événements de mesure renvoie la consommation agrégée du client pour une période, selon la formule d’agrégation définie par le compteur.
Dans l’exemple d’Hypernian, le récapitulatif des événements de mesure indique la somme des tokens pour un client, un dispositif et une période spécifiques.
Étant donné que Stripe traite les événements de mesure de manière asynchrone, les récapitulatifs des événements de mesure risquent de ne pas afficher immédiatement les derniers événements de mesure.
```curl
curl -G https://api.stripe.com/v1/billing/meters/{{METER_ID}}/event_summaries \
-u "<>:" \
-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("<>")
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("<>")
# 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('<>');
$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("<>");
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 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')('<>');
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("<>")
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("<>");
var service = client.V1.Billing.Meters.EventSummaries;
StripeList meterEventSummaries = service.List(
"{{METER_ID}}",
options);
```
## Étapes suivantes
- [Accepter des paiements avec Stripe Checkout](https://docs.stripe.com/payments/checkout.md)
- [Définir des alertes et des seuils](https://docs.stripe.com/billing/subscriptions/usage-based/monitor.md)
- [Établir des crédits de facturation](https://docs.stripe.com/billing/subscriptions/usage-based/billing-credits/implementation-guide.md)