> ## Documentation Index
> Fetch the complete documentation index at: https://docs.smartbills.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Environnements

> Découvrez les environnements bac à sable et production de l'API Smartbills pour le développement et les tests

## Aperçu

Smartbills fournit deux environnements distincts pour vous aider à développer et tester votre intégration avant la mise en production. Chaque environnement est complètement isole avec ses propres données, clés API et configuration.

## Environnements disponibles

### Environnement bac à sable (Sandbox)

L'environnement bac à sable est un espace sécurisé pour le développement et les tests. Aucune donnée réelle n'est traitée ou stockée.

**URL de base :**

```
https://sandbox.api.smartbills.io/v1
```

**Caracteristiques :**

* Disponible immédiatement pour tous les comptes développeurs
* Utilisé des clés API de test (`sk_test_...`)
* Données de test séparées qui n'affectent pas la production
* Limites de débit plus elevees pour un développement plus rapide
* Pre-rempli avec des données d'exemple pour les tests
* Aucune charge ou transaction réelle

<Info>
  Tous les comptes développeurs ont un accès immédiat à l'environnement bac à sable. Aucune approbation requise.
</Info>

### Environnement de production

L'environnement de production est l'endroit où votre application en direct s'exécuté et traite des données réelles.

**URL de base :**

```
https://api.smartbills.io/v1
```

**Caracteristiques :**

* Utilisé des clés API de production (`sk_live_...`)
* Données réelles de clients et d'entreprises
* Limites de débit standard
* Traite les dépenses et rapports réels
* Nécessité l'approbation de l'application avant l'accès

<Note>
  Les clés API de production sont activées une fois que votre application à été examinee et approuvée.
</Note>

## Differences principales

| Caracteristique      | Bac à sable                 | Production                    |
| -------------------- | --------------------------- | ----------------------------- |
| **URL de base**      | `sandbox.api.smartbills.io` | `api.smartbills.io`           |
| **Clés API**         | `sk_test_...`               | `sk_live_...`                 |
| **Données**          | Données de test uniquement  | Données réelles des clients   |
| **Accès**            | Disponible immédiatement    | Nécessité une approbation     |
| **Limites de débit** | Plus indulgentes            | Limites standard              |
| **Webhooks**         | Envoyes aux URL de test     | Envoyes aux URL de production |
| **Transactions**     | Simulees                    | Réelles                       |

## Changer d'environnement

Vous pouvez changer d'environnement en modifiant l'URL de base et la clé API dans votre application :

<CodeGroup>
  ```bash cURL theme={null}
  # Bac à sable
  curl --request GET \
    --url https://sandbox.api.smartbills.io/v1/expenses \
    --header 'Authorization: Bearer sk_test_1234567890abcdef' \
    --header 'x-tenant-id: 123'

  # Production
  curl --request GET \
    --url https://api.smartbills.io/v1/expenses \
    --header 'Authorization: Bearer sk_live_1234567890abcdef' \
    --header 'x-tenant-id: 123'
  ```

  ```javascript JavaScript theme={null}
  import { SmartbillsClient } from '@smartbills/sdk';

  // Bac à sable
  const sandboxClient = new SmartbillsClient({
    accessToken: 'VOTRE_CLE_API',
    businessId: 123
  });

  // Ou configurer via des variables d'environnement
  const client = new SmartbillsClient({
    accessToken: process.env.SMARTBILLS_API_KEY,
    businessId: 123
  });
  ```

  ```python Python theme={null}
  from smartbills import SmartbillsClient
  import os

  # Bac à sable
  sandbox_client = SmartbillsClient(
      access_token="sk_test_1234567890abcdef",
      business_id=123
  )

  # Ou configurer via des variables d'environnement
  client = SmartbillsClient(
      access_token=os.environ.get("SMARTBILLS_API_KEY"),
      business_id=123
  )
  ```
</CodeGroup>

## Configuration des environnements

### Utiliser des variables d'environnement

Stockez vos clés API et URL de base comme variables d'environnement pour changer facilement d'environnement :

```bash theme={null}
# .env.development
SMARTBILLS_API_URL=https://sandbox.api.smartbills.io
SMARTBILLS_API_KEY=sk_test_votre_cle_sandbox

# .env.production
SMARTBILLS_API_URL=https://api.smartbills.io
SMARTBILLS_API_KEY=sk_live_votre_cle_production
```

## Données de test dans le bac à sable

L'environnement bac à sable est pre-rempli avec des données d'exemple pour vous aider à tester votre intégration :

* **Entreprises d'exemple** avec des paramètres pre-configurés
* **Dépenses d'exemple** dans divers statuts (en attente, approuvé, rejeté)
* **Rapports de dépenses d'exemple** avec des flux d'approbation complets
* **Catégories, départements et emplacements d'exemple**
* **Fournisseurs d'exemple** avec differentes configurations

Vous pouvez également créer vos propres données de test dans le bac à sable. Toutes les données de test sont périodiquement réinitialises.

<Warning>
  **Reinitialisation des données** : Les données du bac à sable peuvent être périodiquement réinitialises. Ne vous fiez pas aux données du bac à sable pour un stockage à long terme.
</Warning>

## Isolation des données

Les données entre les environnements sont complètement isolees :

* Les utilisateurs créés dans le bac à sable n'existent pas en production
* Les dépenses et rapports sont spécifiques à chaque environnement
* Les webhooks sont envoyes à des points d'accès differents par environnement
* Les clés API ne fonctionnent que dans leurs environnements respectifs

Cela garantit que vos activités de test n'affectent jamais vos données ou utilisateurs de production.

## Obtenir l'accès

### Accès au bac à sable

1. Créez un compte Smartbills à [smartbills.io](https://smartbills.io)
2. Visitez le [portail développeur](https://developers.smartbills.io)
3. Créez une nouvelle application
4. Vos clés API du bac à sable seront générées immédiatement

### Accès à la production

<Steps>
  <Step title="Compléter l'intégration dans le bac à sable">
    Construisez et testez votre intégration en utilisant les clés API du bac à sable.
  </Step>

  <Step title="Soumettre pour examen">
    Soumettez votre application pour examen via le portail développeur.
  </Step>

  <Step title="Processus d'examen">
    Notre équipe examine votre intégration pour s'assurer qu'elle respecte nos directives.
  </Step>

  <Step title="Clés de production activées">
    Une fois approuvées, vos clés API de production seront activées.
  </Step>
</Steps>

## Bonnes pratiques

<AccordionGroup>
  <Accordion title="Utiliser des variables d'environnement" icon="gear">
    Stockez les clés API et les URL de base comme variables d'environnement. Ne les codez jamais en dur.
  </Accordion>

  <Accordion title="Tester rigoureusement dans le bac à sable" icon="flask">
    Testez toujours votre intégration rigoureusement dans le bac à sable avant de deployer en production. Testez tous les points d'accès API, la gestion des erreurs, la livraison des webhooks et les formats de données.
  </Accordion>

  <Accordion title="Garder des clés API séparées" icon="key">
    Utilisez des clés API differentes pour chaque environnement et n'utilisez jamais les clés de production en développement ou en test.
  </Accordion>

  <Accordion title="Surveiller les deux environnements" icon="chart-line">
    Configurez la surveillance et la journalisation pour les deux environnements afin de détectér les problèmes tot.
  </Accordion>
</AccordionGroup>

## Ressources connexes

<CardGroup cols={2}>
  <Card title="Clés API" icon="key" href="/fr/api-reference/api-keys">
    Créer et gérer les clés API
  </Card>

  <Card title="Authentification" icon="shield" href="/fr/api-reference/authentication">
    Configuration de l'authentification
  </Card>

  <Card title="Introduction à l'API" icon="book" href="/fr/api-reference/introduction">
    Aperçu de l'API et premiers pas
  </Card>

  <Card title="Limites de débit" icon="gauge" href="/fr/api-reference/rate-limits">
    Limites de débit par environnement
  </Card>
</CardGroup>