> ## Documentation Index
> Fetch the complete documentation index at: https://docs.metronome.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Obtenez votre première facture
> Ce guide vous accompagne dans la configuration de la facturation, entièrement dans le tableau de bord Metronome.
**Vous cherchez le guide de l'API ?** Si votre équipe d'ingénierie configure Metronome par programmation, consultez le [démarrage rapide de l'API](/fr/guides/get-started/api-quickstart).
**Vous n'avez pas de compte Metronome ?** Inscrivez-vous pour un compte Sandbox [ici](https://signup.metronome.com/) !
## Étape 1 : comprendre comment les pièces s'assemblent
Avant de construire quoi que ce soit, voici comment les objets centraux de Metronome se connectent :
Metronome sépare la *mesure* (ce que vous mesurez) de la *tarification* (ce que vous facturez). Vous pouvez changer la tarification sans changer votre instrumentation d'événements, et vice versa.
Voici ce que fait chaque objet :
* **Événements d'utilisation** — Enregistrements bruts de l'activité du client envoyés à Metronome (par exemple, « le client X a utilisé 1 500 tokens d'entrée sur le modèle gpt-5 à l'horodatage Z »)
* **Métriques facturables** — Règles qui agrègent vos événements en quantités facturables (par exemple, « somme de la propriété `input_tokens` pour les événements de type `llm_request` »). C'est également là où vous définissez les **clés de groupe** — les propriétés que vous utiliserez pour tarifer ou afficher sur les factures.
* **Produits** — Postes nommés sur une facture.
* **Cartes tarifaires** — Un livre de prix centralisé attribuant un prix à chaque produit. Une seule carte tarifaire peut être partagée entre de nombreux clients, ce qui facilite le déploiement des mises à jour de tarification.
* **Contrats** — Accords spécifiques au client référençant une carte tarifaire, définissant la période de facturation et incluant optionnellement des crédits, engagements ou remplacements.
* **Packages** — Encode votre carte tarifaire et les détails du contrat dans un seul package à appliquer à de nouveaux clients.
* **Factures** — Générées automatiquement à chaque période de facturation en fonction des frais récurrents et de l'utilisation d'un client, tarifées par rapport au contrat.
**Ce que vous devez créer (dans cet ordre) :**
1. Une métrique facturable
2. Un produit
3. Une carte tarifaire avec des taux pour chaque produit
4. Un client
5. Un contrat reliant le client à la carte tarifaire
Ensuite, vous envoyez des événements et Metronome s'occupe du reste.
## Étape 2 : sachez ce que vous mesurez — vue d'ensemble du schéma d'événements
Avant de créer une métrique facturable, comprenez à quoi ressembleront vos événements d'utilisation. Consultez « [Concevoir des événements d'utilisation](/fr/guides/events/design-usage-events) » pour les détails complets du schéma d'événements et des exemples de charges utiles.
**Chaque événement inclut ces champs requis :**
* **`transaction_id`** — Doit être unique par événement (utilisé pour la déduplication)
* **`customer_id`** — L'UUID du client Metronome ou un alias d'ingestion
* **`event_type`** — Une chaîne qui connecte l'événement à une métrique facturable (doit correspondre exactement)
* **`timestamp`** — Quand l'utilisation s'est produite
**Et des propriétés optionnelles (la décision de conception clé) :**
* **`properties`** — Paires clé-valeur contenant des quantités à mesurer (par exemple, `tokens_usage`), des dimensions pour tarifer (par exemple, `model_name`, `region`), et des métadonnées pour l'affichage de facture ou l'analyse (par exemple, `user_id`, `project_id`, `cost`). Metronome prend en charge jusqu'à **2 000 propriétés** par événement.
Après avoir créé une métrique facturable à l'étape suivante, vous verrez un **exemple de charge utile d'événement** directement dans l'interface utilisateur qui vous montre le format attendu :
**CONSEIL**
Avant de créer une métrique facturable, décidez quelles propriétés inclure. Plus il y a de métadonnées, mieux c'est — des propriétés comme `user_id` (pour la facturation par siège), `region` (pour la tarification régionale), `project_id` (pour les ventilations de facture) et `cost` (pour l'analyse COGS) sont toutes précieuses même si vous ne les utilisez pas dès le premier jour.
## Étape 3 : créer une métrique facturable
Une métrique facturable définit *ce qu'il faut* mesurer. Accédez à **Offre → Métriques facturables → + Ajouter**.
Il existe deux types de métriques facturables :
* **Métrique streaming** — Couvre la plupart des cas d'usage. Optimisée pour la performance avec une agrégation en temps réel à mesure que les événements arrivent.
* **Métrique SQL** — Pour des calculs complexes comme les moyennes quotidiennes, les comptes uniques par période, ou les formules pondérées. [En savoir plus sur les BM SQL →](/fr/guides/implement-metronome/core-concepts/billable-metrics-sql-editor)
La configuration suivante est pour les métriques facturables streaming :
1. **Nommez** votre métrique (par exemple, « Input Tokens »).
2. Définissez le **filtre de type d'événement** — cela doit correspondre exactement à l'`event_type` que votre application envoie (par exemple, `tokens_usage`).
3. Définissez les propriétés. Incluez la propriété à utiliser comme **clé d'agrégation** (la propriété à agréger, par exemple, `num_tokens`).
Envoyez plus de propriétés que vous ne pensez en avoir besoin. Vous pouvez toujours ignorer les propriétés inutilisées, mais vous ne pouvez pas ajouter rétroactivement des clés de groupe à une métrique facturable.
4. Choisissez votre **type d'agrégation** :
| Type | Ce qu'il fait | Exemple de cas d'usage |
| ----- | ------------------------------------------------------ | -------------------------------- |
| Count | Compte les événements correspondants | Appels API, requêtes, messages |
| Sum | Somme une propriété numérique à travers les événements | Tokens, octets, secondes |
| Max | Valeur maximale dans une fenêtre | Connexions simultanées de pointe |
5. Sélectionnez les clés de groupe.
### Comprendre les clés de groupe
Les **clés de groupe** déterminent ce que vous pouvez tarifer et afficher sur les factures en aval. Pensez-y comme une clause `GROUP BY` en SQL — elles divisent votre utilisation agrégée en seaux.
**Ce que les clés de groupe permettent (sur le produit, à l'étape suivante) :**
| Utilisation en aval | Ce qu'elle fait | Exemple |
| ----------------------------- | --------------------------------------- | ----------------------------------------------------------------- |
| Clé de groupe de tarification | Prix différents par valeur de dimension | `model_name` → facturer \$1,50 pour model-A, \$0,30 pour model-B |
| Clé de groupe de présentation | Ventilations par poste sur la facture | `user_id` → afficher l'utilisation par utilisateur sur la facture |
**IMPORTANT : vous devez définir les clés de groupe ici sur la métrique facturable d'abord.** Elles ne peuvent pas être ajoutées plus tard, et elles doivent exister ici avant de pouvoir être assignées comme clés de tarification ou de présentation sur un produit.
**Exemples courants de clés de groupe :**
* `model_name` — tarification par modèle (clé de groupe de tarification)
* `region` — tarification par région (clé de groupe de tarification)
* `instance_type` — tarification par GPU/instance (clé de groupe de tarification)
* `user_id` — ventilations de facture par utilisateur, ou facturation par siège utilisant l'agrégation Unique (clé de groupe de présentation)
* `project_id` — ventilations de facture par projet (clé de groupe de présentation)
**Les métriques facturables ne peuvent pas être modifiées après la création**
Vous ne pouvez pas ajouter ou modifier les clés de groupe, les filtres de propriétés ou les paramètres d'agrégation. Si vous pensez que vous *pourriez* vouloir tarifer par ou afficher une dimension à l'avenir, incluez-la comme clé de groupe maintenant. Il est bonne pratique d'inclure toutes les propriétés comme clés de groupe.
1. Définissez vos **clés de groupe** en fonction des conseils ci-dessus.
2. **Examinez l'événement** dans la boîte d'exemple de charge utile d'événement pour valider vos filtres.
3. Cliquez sur **Enregistrer**.
Accédez à **Offre → Métriques facturables**. Votre nouvelle métrique devrait apparaître dans la liste. Cliquez dessus pour vérifier que l'agrégation, les filtres et les clés de groupe sont corrects.
## Étape 4 : créer un produit
Un **produit** est un poste nommé qui apparaît sur la facture de votre client. Accédez à **Offre → Produits → + Ajouter un nouveau produit**.
1. Entrez un **nom** — c'est ce qui apparaît sur la facture (par exemple, « Input Tokens »).
2. Sélectionnez le **type de produit** :
* **Utilisation** — Tarifé de manière variable en fonction de l'utilisation du client (nécessite une métrique facturable)
* **Abonnement** — Frais récurrents selon un calendrier (frais de plateforme, licences de sièges)
* **Composite** — Frais en pourcentage sur un groupe d'autres produits
* **Fixe** — Frais ponctuels ou planifiés (utilisés pour les engagements, crédits, frais ponctuels)
* Engagements vs crédits : les engagements ont une base de coût, tandis que les crédits sont toujours gratuits
3. Pour les produits d'utilisation, sélectionnez la **métrique facturable** que vous avez créée à l'étape 3. Vous pouvez échanger la métrique facturable sur un produit d'utilisation si nécessaire.
4. Attribuez des **clés de groupe** sur le produit :
| Je veux... | Utiliser | Exemple |
| ---------------------------------------------------- | -------------------------------- | ---------------------------------------- |
| Facturer des prix différents par dimension | Clé de groupe de tarification | `model_name` → prix différent par modèle |
| Afficher des ventilations sur la facture (même prix) | Clé de groupe de présentation | `user_id` → postes par utilisateur |
| Un prix fixe pour toute l'utilisation | Ne définissez ni l'un ni l'autre | Facturation simple basée sur le comptage |
Vous pouvez utiliser à la fois des clés de groupe de tarification et de présentation sur le même produit (par exemple, tarifer par `model_name`, afficher par `user_id`). Les clés de groupe ici doivent être un sous-ensemble des clés de groupe sur la métrique facturable sous-jacente.
*(Conversions optionnelles)* Ajoutez une **conversion de quantité** — par exemple, envoyez des tokens individuels mais affichez et tarifez par million de tokens sur la facture. Ajoutez une **conversion d'arrondi** — par exemple, envoyez des secondes mais arrondissez et affichez à la minute la plus proche sur la facture.
Accédez à **Offre → Produits**. Cliquez sur votre produit pour vérifier la métrique facturable et les clés de groupe.
## Étape 5 : créer une carte tarifaire
Une **carte tarifaire** est un tableau de tarification centralisé qui attribue des prix à vos produits. Les cartes tarifaires sont dans une seule devise fiduciaire. Accédez à **Offre → Cartes tarifaires → + Ajouter une nouvelle carte tarifaire**.
**Bonne pratique :** utilisez une seule carte tarifaire comme source de vérité pour la tarification standard. Lorsque vous mettez à jour les taux ici, les changements se propagent à tous les contrats qui référencent cette carte tarifaire. Vous pouvez remplacer les taux par client sur des contrats individuels.
1. **Nommez** votre carte tarifaire (par exemple, « Carte tarifaire standard »).
2. **Ajoutez des produits** et définissez leurs taux.
3. Si vous utilisez la **tarification dimensionnelle** (clés de groupe de tarification sur le produit), définissez des valeurs pour chaque dimension et fixez un taux par valeur. Par exemple, si `model_name` est votre clé de groupe de tarification, ajoutez des entrées pour `model-A` à \$1,50 et `model-B` à \$0,30.
**Fonctionnalités supplémentaires des cartes tarifaires :**
* **Tarification par paliers** — Définissez des paliers basés sur le volume sur n'importe quel produit. Sur la carte tarifaire, cliquez sur le produit → Ajouter des paliers. Par exemple, premiers 1M tokens à \$1,00, suivants 1M à \$0,80.
* **Unités de tarification personnalisées (conversions de crédits)** — Si vous facturez en crédits ou dans une unité personnalisée plutôt qu'en USD, créez d'abord une unité de tarification personnalisée sous **Offre → Unités de tarification**, puis configurez la conversion sur la carte tarifaire. [En savoir plus →](/fr/guides/pricing-packaging/make-pricing-changes/use-currency-custompricingunits)
* **Taux d'engagement** — Définissez des taux qui s'appliquent spécifiquement lorsque l'utilisation est tirée d'un engagement.
* **Modifier et ajouter des taux** — Modifiez le taux pour changer le taux et sélectionnez la date de début du nouveau taux. Ajoutez de nouveaux taux en cliquant sur « Ajouter un taux » sur la carte tarifaire.
## Étape 6 : créer un client et un contrat
Maintenant, attachez tout ensemble.
### Créer un client
Accédez à **Clients → + Ajouter un client.** Entrez le **nom** du client.
*(Optionnel)* Ajoutez des **alias d'ingestion** afin que votre équipe d'ingénierie puisse envoyer des événements en utilisant votre ID client interne au lieu de l'UUID de Metronome.
### Créer un contrat
Accédez à votre nouveau client → **+ Ajouter un contrat**.
1. Sélectionnez votre **carte tarifaire**.
2. Définissez la **date de début et de fin du contrat.**
3. *(Optionnel)* **Fournisseur de facturation** — Connectez une intégration de facture pour envoyer les factures finalisées à un système de paiement. Pour plus de détails, consultez :
* [Guide d'intégration Stripe](/fr/integrations/invoice-integrations/stripe)
* [AWS Marketplace](/fr/integrations/marketplace-integrations/aws) / [Azure Marketplace](/fr/integrations/marketplace-integrations/azure)
4. (Optionnel) **Incluez des conditions spécifiques au contrat.** Les contrats peuvent inclure des conditions spécifiques au client, comme des engagements prépayés et des remplacements. Consultez les liens suivants pour plus d'informations sur la configuration.
1. [Crédits et engagements](/fr/guides/pricing-packaging/apply-credits-and-commits/create-a-pre-paid-commit)
2. [Remplacements](/fr/guides/customers-billing/manage-customers/provision-a-customer#add-contract-discounts-and-overrides)
Accédez à **Clients → \[Votre client] → Contrat**. Vous devriez voir le contrat avec votre carte tarifaire assignée.
### Envoyer des événements de test (sandbox uniquement)
Maintenant que vous avez un client et un contrat, vous pouvez envoyer des événements de test directement depuis l'interface utilisateur.
Accédez à la vue contrat du client et cliquez sur le produit sur la carte tarifaire. Vous trouverez l'option d'envoyer des événements de test ici.
Lors de la composition d'un événement de test, gardez à l'esprit :
* Le **transaction\_id** doit être unique pour chaque événement
* Le **timestamp** doit être dans les 34 derniers jours
* L'**event\_type** et les **propriétés** doivent correspondre à la configuration de votre métrique facturable (filtres et clés de groupe)
Cette fonctionnalité est uniquement disponible en sandbox, pas en production. En production, votre équipe d'ingénierie [envoie des événements](/fr/api-reference/usage/ingest-events) via l'API.
## Étape 7 : vérifier votre facture
Metronome génère automatiquement des factures en fonction du calendrier de facturation sur le contrat.
**Pour voir une facture brouillon :** accédez à **Clients → Contrat → Factures**. La facture brouillon de la période de facturation actuelle devrait afficher votre utilisation et les frais calculés.
**Cycle de vie de la facture :**
1. **Brouillon** — Accumule l'utilisation tout au long de la période de facturation (visible dans Metronome).
2. **Finalisé** — Verrouillé à la fin de la période de facturation. Il y a une **période de grâce de 24 heures** à la fin de la période de facturation avant que les factures ne soient finalisées pour apporter toute modification nécessaire à une facture.
3. **Envoyé au fournisseur de facturation** — Si connecté (par exemple, Stripe), les factures sont poussées dans environ une heure après la finalisation. Le statut de paiement est géré dans le tableau de bord de votre fournisseur de facturation, pas dans Metronome.
4. **Payé / Échoué** — Recouvrement géré par votre fournisseur de facturation. Vous pouvez configurer des [webhooks](/fr/guides/platform-configuration/setup-webhooks#webhook-types) pour écouter les statuts de paiement pour les engagements à passerelle de paiement.
Vérifiez que la facture brouillon affiche des quantités et des frais d'utilisation corrects en fonction de votre ingestion d'événements et de la tarification de la carte tarifaire. Si vous voyez de l'utilisation (sous Connexions) mais aucun frais sur la facture, vérifiez que vos événements correspondent aux valeurs de clés de groupe de tarification sur votre carte tarifaire.
## Prêt pour plus ?
Vous avez créé votre première facture dans Metronome ! Voici des fonctionnalités supplémentaires à explorer :
* [**Tableaux de bord client intégrables**](/fr/guides/customers-billing/optimize-customer-experience/customer-dashboards-and-reporting) — Donnez à vos clients une visibilité en libre-service sur l'utilisation et les dépenses
* [**Webhooks**](/fr/guides/platform-configuration/setup-webhooks) — Soyez notifié des événements de cycle de vie de facture, des seuils de solde et des résultats de paiement
* [**Alertes et notifications**](/fr/guides/customers-billing/set-up-notifications/create-and-manage-notifications) — Alertes de dépenses, seuils de solde, jalons d'utilisation
* [**Crédits et engagements**](/fr/guides/pricing-packaging/apply-credits-and-commits/create-a-pre-paid-commit) — Soldes prépayés, engagements entreprise, crédits de niveau gratuit
* [**Reconnaissance des revenus**](/fr/guides/reporting-insights/financial-reporting/revenue-recognition) — Conformité ASC 606 / IFRS 15
* [**Liste de vérification de production**](/fr/guides/implement-metronome/production-checklist) — Quand vous êtes prêt à passer en production