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

# Obtenir un jeton d'accès

> Échange des identifiants client contre un jeton Bearer de courte durée (3600s).

Accepte les identifiants via :
- `Authorization: Basic base64(client_id:client_secret)` avec
  `grant_type=client_credentials` dans le corps de la requête (RFC 6749)
- Corps JSON avec `client_id`, `client_secret` et `grant_type`




## OpenAPI

````yaml api-reference/energy-management/openapi.fr.yaml POST /oauth/token
openapi: 3.1.0
info:
  title: RiDERgy Energy Management API
  version: '1.0'
  license:
    name: Proprietary
    identifier: LicenseRef-Proprietary
  description: >
    Contrôle programmatique des limites de puissance de charge sur les sites,

    les bornes individuelles, les organisations et les clusters multi-sites.


    ## Authentification

    Tous les endpoints sauf `GET /health` et `POST /oauth/token` nécessitent un

    jeton Bearer obtenu via le flux OAuth 2.0 client_credentials :


    1. Créez des identifiants client OAuth dans le tableau de bord RiDERgy.

    2. Échangez-les contre un jeton d'accès de courte durée via `POST
    /oauth/token`.

    3. Transmettez le jeton en tant que `Authorization: Bearer <token>` à chaque
    requête.


    Les jetons expirent après 3600 secondes. Votre tenant est intégré dans le

    jeton et ne peut pas être usurpé. Les identifiants d'un tenant ne peuvent

    pas accéder à un autre.


    Votre tenant doit avoir la fonctionnalité Energy Management API activée,

    sinon les requêtes échouent avec `403 FEATURE_NOT_ENABLED`. Contactez
    RiDERgy

    pour l'activer.


    ## Scopes

    Les jetons contiennent des scopes qui contrôlent quels endpoints sont

    accessibles : `locations:read`, `locations:write`, `clusters:read`,

    `clusters:write`, `chargers:write`, `org:write`. Les requêtes vers des

    endpoints nécessitant un scope que le jeton ne possède pas échoueront avec

    `403 INSUFFICIENT_SCOPE`.


    ## Modèle de priorité

    Les limites de site et de borne sont contrôlées via des **profils à fenêtres

    de priorité** :


    - Les priorités vont de **0 (la plus basse) à 10 (la plus haute)**, dans le
      style de la pile OCPP.
    - Une cible (site ou connecteur de borne) peut avoir jusqu'à 11 profils, un
      par niveau de priorité, chacun avec sa propre fenêtre `[startTime, endTime)`.
    - À tout moment, la **limite effective** est le `limitKw` du profil de
      priorité la plus élevée dont la fenêtre est actuellement active.
    - Si aucun profil n'est actif, un site revient à son `permanentLimitKw`.

    - Soumettre un profil à une priorité qui en possède déjà un pour cette cible
      le **remplace**.
    - Les profils sont appliqués et annulés automatiquement à leurs
      `startTime`/`endTime`. Aucun appel d'API supplémentaire n'est nécessaire
      une fois le profil créé. Les enregistrements de profils ne sont jamais
      supprimés, l'historique reste donc consultable.

    ## Erreurs

    Toutes les erreurs partagent cette forme :


    ```json

    {
      "error": {
        "code": "LOCATION_NOT_FOUND",
        "message": "Location 123 was not found for the provided tenant",
        "requestId": "b1f6e6b0-..."
      }
    }

    ```
servers:
  - url: https://api.ridergy.com/v1
    description: Production
security:
  - BearerAuth: []
tags:
  - name: Auth
    description: Endpoint de jeton OAuth 2.0 pour le grant client_credentials.
  - name: Health
    description: Vérification de l'état du service, sans authentification.
  - name: Locations
    description: >-
      Lire et définir les limites de puissance et les profils de priorité au
      niveau du site.
  - name: Chargers
    description: >-
      Verrouiller des connecteurs de borne individuels sur une limite de
      puissance fixe pour une fenêtre temporelle.
  - name: Organizations
    description: >-
      Profils de plafond à l'échelle du tenant (enregistrés uniquement,
      l'application n'est pas encore active).
  - name: Clusters
    description: >-
      Regrouper des sites sous un plafond kW partagé et appliquer des plannings
      à l'ensemble du groupe.
paths:
  /oauth/token:
    post:
      tags:
        - Auth
      summary: Obtain an access token
      description: >
        Échange des identifiants client contre un jeton Bearer de courte durée
        (3600s).


        Accepte les identifiants via :

        - `Authorization: Basic base64(client_id:client_secret)` avec
          `grant_type=client_credentials` dans le corps de la requête (RFC 6749)
        - Corps JSON avec `client_id`, `client_secret` et `grant_type`
      operationId: createToken
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - grant_type
              properties:
                grant_type:
                  type: string
                  enum:
                    - client_credentials
                client_id:
                  type: string
                  description: Obligatoire si l'en-tête Basic auth n'est pas utilisé.
                  example: emcl_a1b2c3d4e5f67890a1b2c3d4e5f67890
                client_secret:
                  type: string
                  description: Obligatoire si l'en-tête Basic auth n'est pas utilisé.
                  example: emcs_...
            examples:
              jsonBody:
                value:
                  grant_type: client_credentials
                  client_id: emcl_a1b2c3d4e5f67890a1b2c3d4e5f67890
                  client_secret: emcs_a1b2c3d4...
      responses:
        '200':
          description: Jeton d'accès émis
          content:
            application/json:
              schema:
                type: object
                properties:
                  access_token:
                    type: string
                    description: Jeton Bearer JWT
                    example: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
                  token_type:
                    type: string
                    example: Bearer
                  expires_in:
                    type: integer
                    description: Durée de vie du jeton en secondes
                    example: 3600
                  scope:
                    type: string
                    description: Liste des scopes accordés séparés par des espaces
                    example: >-
                      locations:read locations:write clusters:read
                      clusters:write chargers:write org:write
        '400':
          description: Requête invalide (grant_type manquant ou grant non supporté)
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    example: unsupported_grant_type
                  error_description:
                    type: string
                    example: Only client_credentials grant type is supported
        '401':
          description: Identifiants client invalides
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    example: invalid_client
                  error_description:
                    type: string
                    example: Invalid client credentials
      security: []
components:
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: >
        Jeton d'accès OAuth 2.0 obtenu via `POST /oauth/token` avec le grant
        client_credentials.

        Le tenant et les scopes sont intégrés dans le JWT. Aucun en-tête
        supplémentaire n'est nécessaire.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.