Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Solde et recharges automatiques

Nodarbība 11 no 14 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Surveiller et automatiser les recharges
  2. Vérifier les détails du solde
  3. Système de recharge automatique
  4. Prévision de la consommation
  5. Tableau de bord de suivi intégré
  6. Galvenās atziņas

Surveiller et automatiser les recharges

Combiner le suivi du solde prépayé avec les analyses d’utilisation te permet de mettre en place un système de recharge intelligent. Au lieu de recharger manuellement, tu peux automatiser le processus en fonction de seuils et de prévisions de consommation.

Vérifier les détails du solde

Le point de terminaison renvoie deux éléments qu’il ne faut pas confondre : le solde instantané et l’historique des transactions. Le premier répond à la question « Puis-je encore appeler l’API ? », le second à « À quelle vitesse est-ce que je consomme ? ». C’est le second qui te permet d’anticiper, et donc le seul sur lequel tu peux baser une automatisation.

curl "https://management-api.x.ai/v1/billing/teams/$TEAM_ID/prepaid/balance" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY"

La réponse contient le solde actuel et l’historique des transactions (achats et consommation).

Système de recharge automatique

Une recharge automatique bien configurée repose sur deux chiffres, dont l’un est souvent oublié. Le seuil de déclenchement doit couvrir ta consommation pendant le temps de réaction : si tu vérifies une fois par jour, tu as besoin d’au moins un jour de crédit d’avance, sinon l’automatisation se déclenchera après la coupure. Le plafond mensuel est la sauvegarde la plus souvent absente : sans lui, une boucle défectueuse dans ton application peut déclencher recharge sur recharge, et les crédits xAI ne sont pas remboursables.

Ces deux valeurs ne sont pas fixées arbitrairement : la section suivante montre comment les calculer en fonction de ta consommation réelle.

import requests
from datetime import datetime, timedelta

MANAGEMENT_API = "https://management-api.x.ai"
MGMT_KEY = "xai-mgmt-..."
TEAM_ID = "team-..."

# Configuration
MIN_BALANCE = 50.00      # Seuil de recharge
TOP_UP_AMOUNT = 200.00   # Montant de la recharge
MAX_MONTHLY = 1000.00    # Plafond mensuel

def get_balance():
    """Obtenir le solde prépayé actuel."""
    resp = requests.get(
        f"{MANAGEMENT_API}/v1/billing/teams/{TEAM_ID}/prepaid/balance",
        headers={"Authorization": f"Bearer {MGMT_KEY}"}
    )
    return resp.json().get("balance", 0)

def get_monthly_top_ups():
    """Calculer le total des recharges pour le mois en cours."""
    resp = requests.get(
        f"{MANAGEMENT_API}/v1/billing/teams/{TEAM_ID}/prepaid/balance",
        headers={"Authorization": f"Bearer {MGMT_KEY}"}
    )
    # Filtrer les transactions pour le mois en cours
    transactions = resp.json().get("transactions", [])
    current_month = datetime.now().strftime("%Y-%m")
    monthly_total = sum(
        t.get("amount", 0)
        for t in transactions
        if t.get("type") == "top-up" and t.get("date", "").startswith(current_month)
    )
    return monthly_total

def top_up(amount):
    """Effectuer une recharge."""
    resp = requests.post(
        f"{MANAGEMENT_API}/v1/billing/teams/{TEAM_ID}/prepaid/top-up",
        headers={
            "Authorization": f"Bearer {MGMT_KEY}",
            "Content-Type": "application/json"
        },
        json={"amount": amount}
    )
    return resp.status_code == 200

# Logique de recharge
balance = get_balance()
monthly_spent = get_monthly_top_ups()

if balance < MIN_BALANCE:
    remaining_budget = MAX_MONTHLY - monthly_spent
    if remaining_budget >= TOP_UP_AMOUNT:
        if top_up(TOP_UP_AMOUNT):
            print(f"Recharge de ${TOP_UP_AMOUNT:.2f}. Nouveau solde estimé : ${balance + TOP_UP_AMOUNT:.2f}")
        else:
            print("Erreur lors de la recharge")
    else:
        print(f"Plafond mensuel atteint (${monthly_spent:.2f} / ${MAX_MONTHLY:.2f})")
else:
    print(f"Solde suffisant : ${balance:.2f}")

Prévision de la consommation

La prévision transforme la surveillance en anticipation. Une moyenne sur sept jours suffit pour la plupart des cas d’usage ; elle te donne une date d’épuisement, ce qui te laisse le temps d’agir. Méfie-toi cependant de la saisonnalité de ton propre trafic : une moyenne calculée sur une semaine creuse promet une autonomie qui disparaîtra dès que le trafic reprendra.

import requests
from datetime import datetime, timedelta

MANAGEMENT_API = "https://management-api.x.ai"
MGMT_KEY = "xai-mgmt-..."
TEAM_ID = "team-..."

# Consommation sur les 7 derniers jours
end = datetime.now()
start = end - timedelta(days=7)

usage_resp = requests.post(
    f"{MANAGEMENT_API}/v1/billing/teams/{TEAM_ID}/usage",
    headers={
        "Authorization": f"Bearer {MGMT_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "analyticsRequest": {
            "timeRange": {
                "startTime": start.strftime("%Y-%m-%d %H:%M:%S"),
                "endTime": end.strftime("%Y-%m-%d %H:%M:%S"),
                "timezone": "Europe/Paris"
            },
            "timeUnit": "DAY",
            "values": [{"name": "cost", "aggregation": "SUM"}]
        }
    }
)

# Calculer la moyenne quotidienne
data_points = usage_resp.json().get("dataPoints", [])
daily_costs = [p.get("value", 0) for p in data_points]
avg_daily_cost = sum(daily_costs) / len(daily_costs) if daily_costs else 0

# Estimer les jours restants
balance_resp = requests.get(
    f"{MANAGEMENT_API}/v1/billing/teams/{TEAM_ID}/prepaid/balance",
    headers={"Authorization": f"Bearer {MGMT_KEY}"}
)
current_balance = balance_resp.json().get("balance", 0)

if avg_daily_cost > 0:
    days_remaining = current_balance / avg_daily_cost
    exhaustion_date = datetime.now() + timedelta(days=days_remaining)
    print(f"Consommation moyenne : ${avg_daily_cost:.2f}/jour")
    print(f"Solde actuel : ${current_balance:.2f}")
    print(f"Épuisement estimé : {exhaustion_date.strftime('%m/%d/%Y')} ({days_remaining:.0f} jours)")

Tableau de bord de suivi intégré

Le tableau de bord rassemble ce que trois points de terminaison différents savent de tes coûts : le solde prépayé, les facturations mensuelles et les limites configurées. Séparément, chacun raconte une histoire incomplète : un solde confortable ne dit rien de la consommation postpayée qui s’exécute en parallèle. C’est la réconciliation qui donne le coût réel du mois en cours.

#!/bin/bash
echo "=== Tableau de bord xAI - $(date '+%m/%d/%Y %H:%M') ==="

# Solde prépayé
BALANCE=$(curl -s "https://management-api.x.ai/v1/billing/teams/$TEAM_ID/prepaid/balance" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY" | python3 -c "import sys,json; print(json.load(sys.stdin).get('balance', 'N/A'))")
echo "Solde prépayé : \$${BALANCE}"

# Frais postpayés
POSTPAID=$(curl -s "https://management-api.x.ai/v1/billing/teams/$TEAM_ID/postpaid/invoice/preview" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY" | python3 -c "import sys,json; print(json.load(sys.stdin).get('totalAmount', 'N/A'))")
echo "Frais postpayés : \$${POSTPAID}"

# Limite de dépenses
LIMIT=$(curl -s "https://management-api.x.ai/v1/billing/teams/$TEAM_ID/postpaid/spending-limits" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY" | python3 -c "import sys,json; print(json.load(sys.stdin).get('monthlyLimit', 'N/A'))")
echo "Limite mensuelle : \$${LIMIT}"

Galvenās atziņas

  • Automatise les recharges avec un seuil minimum et un plafond mensuel
  • Utilise les analyses pour prévoir les dates d’épuisement du crédit
  • Combine solde prépayé, frais postpayés et limites dans un tableau de bord unifié
  • Les crédits ne sont pas remboursables : calibre les recharges automatiques avec prudence
  • Intègre ces scripts dans ton cron ou ta pipeline CI/CD