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

# Mouvements

> Rend le relevé du portefeuille, mouvement par mouvement, avec le solde après chacun. En JSON ou en CSV.

Portée de la clé : `portefeuille:lire`.



## OpenAPI

````yaml openapi/v1.json GET /v1/portefeuille/mouvements
openapi: 3.1.0
info:
  title: API Umeme pour les intégrateurs
  version: 1.0.0
  description: >-
    Contrat de l'API Umeme pour les intégrateurs : vendre de l'électricité
    prépayée et des abonnements TV depuis le portefeuille de votre revendeur.
servers:
  - url: https://sandbox.umeme.app
    description: Sandbox d'intégration
  - url: https://api.umeme.app
    description: Production
security:
  - cle: []
tags:
  - name: Ventes
  - name: Compteurs
  - name: Portefeuille
  - name: Outils
paths:
  /v1/portefeuille/mouvements:
    get:
      tags:
        - Portefeuille
      summary: Mouvements
      description: >-
        Rend le relevé du portefeuille, mouvement par mouvement, avec le solde
        après chacun. En JSON ou en CSV.


        Portée de la clé : `portefeuille:lire`.
      operationId: lireMouvements
      parameters:
        - name: du
          in: query
          required: true
          description: Premier jour, inclus.
          schema:
            type: string
            format: date
          example: '2026-11-01'
        - name: au
          in: query
          required: true
          description: Dernier jour, inclus.
          schema:
            type: string
            format: date
          example: '2026-11-07'
        - name: format
          in: query
          required: false
          description: '`json` par défaut, ou `csv`.'
          schema:
            type: string
            enum:
              - json
              - csv
            default: json
      responses:
        '200':
          description: Le relevé.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Mouvements'
              example:
                mouvements:
                  - rang: 41
                    date: '2026-11-07T08:26:44Z'
                    type: VENTE
                    montant: -5
                    soldeApres: 995
                  - rang: 42
                    date: '2026-11-07T08:31:10Z'
                    type: REMBOURSEMENT
                    montant: 5
                    soldeApres: 1000
            text/csv:
              schema:
                type: string
              example: |
                rang,date,type,montant,soldeApres
                41,2026-11-07T08:26:44Z,VENTE,-5,995
                42,2026-11-07T08:31:10Z,REMBOURSEMENT,5,1000
        '400':
          description: Dates absentes ou inversées.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Erreur'
              example:
                code: PERIODE_INVALIDE
                message: La date de fin précède la date de début.
        '401':
          $ref: '#/components/responses/NonAuthentifie'
      x-codeSamples:
        - lang: bash
          label: cURL
          source: |-
            curl -G "$UMEME_BASE_URL/portefeuille/mouvements" \
              -H "Authorization: Bearer $UMEME_CLE" \
              --data-urlencode "du=2026-11-01" \
              --data-urlencode "au=2026-11-07"
        - lang: javascript
          label: Node.js · fetch
          source: >-
            // Node.js 18 et plus : fetch est intégré.

            const baseUrl = process.env.UMEME_BASE_URL;


            const params = new URLSearchParams({
              du: "2026-11-01",
              au: "2026-11-07",
            });


            const reponse = await
            fetch(`${baseUrl}/portefeuille/mouvements?${params}`, {
              headers: {
                Authorization: `Bearer ${process.env.UMEME_CLE}`,
              },
            });

            const donnees = await reponse.json();
        - lang: javascript
          label: Node.js · Axios
          source: |-
            // npm install axios
            import axios from "axios";

            const umeme = axios.create({
              baseURL: process.env.UMEME_BASE_URL,
              headers: { Authorization: `Bearer ${process.env.UMEME_CLE}` },
              timeout: 30000,
            });

            const { data } = await umeme.get("/portefeuille/mouvements", {
              params: {
                du: "2026-11-01",
                au: "2026-11-07",
              },
            });
        - lang: python
          label: Python
          source: |-
            import os

            import requests

            BASE_URL = os.environ["UMEME_BASE_URL"]
            ENTETES = {"Authorization": f"Bearer {os.environ['UMEME_CLE']}"}

            reponse = requests.get(
                f"{BASE_URL}/portefeuille/mouvements",
                headers=ENTETES,
                params={
                    "du": "2026-11-01",
                    "au": "2026-11-07",
                },
                timeout=30,
            )
            donnees = reponse.json()
        - lang: php
          label: PHP
          source: |-
            // composer require guzzlehttp/guzzle
            $client = new GuzzleHttp\Client([
                'base_uri' => getenv('UMEME_BASE_URL') . '/',
                'headers' => ['Authorization' => 'Bearer ' . getenv('UMEME_CLE')],
                'timeout' => 30,
            ]);

            $reponse = $client->get('portefeuille/mouvements', [
                'query' => [
                    'du' => '2026-11-01',
                    'au' => '2026-11-07',
                ],
            ]);
            $donnees = json_decode($reponse->getBody(), true);
        - lang: java
          label: Java
          source: >-
            // Java 15 et plus : java.net.http et blocs de texte.

            var baseUrl = System.getenv("UMEME_BASE_URL");

            var client = HttpClient.newHttpClient();


            var params = Map.of("du", "2026-11-01", "au",
            "2026-11-07").entrySet().stream()
                .map(p -> p.getKey() + "=" + URLEncoder.encode(p.getValue(), StandardCharsets.UTF_8))
                .collect(Collectors.joining("&"));

            var requete = HttpRequest.newBuilder(URI.create(baseUrl +
            "/portefeuille/mouvements" + "?" + params))
                .header("Authorization", "Bearer " + System.getenv("UMEME_CLE"))
                .GET()
                .build();

            var reponse = client.send(requete,
            HttpResponse.BodyHandlers.ofString());
components:
  schemas:
    Mouvements:
      type: object
      required:
        - mouvements
      properties:
        mouvements:
          type: array
          description: Les mouvements, dans l'ordre.
          items:
            type: object
            required:
              - rang
              - date
              - type
              - montant
              - soldeApres
            properties:
              rang:
                type: integer
                description: Numéro du mouvement, sans trou.
              date:
                type: string
                format: date-time
                description: Heure du mouvement, en UTC.
              type:
                type: string
                enum:
                  - VENTE
                  - REMBOURSEMENT
                  - APPROVISIONNEMENT
              montant:
                type: number
                description: En dollars ; négatif pour un débit.
              soldeApres:
                type: number
                description: Le solde après ce mouvement.
    Erreur:
      type: object
      required:
        - code
        - message
      properties:
        code:
          type: string
          description: 'Stable : il ne se renomme jamais. C''est lui que votre code compare.'
        message:
          type: string
          description: En français, pour vos journaux. Il peut changer.
  responses:
    NonAuthentifie:
      description: >-
        Clé absente, inconnue, révoquée, ou de l'autre environnement :
        `CLE_INVALIDE`, `CLE_REVOQUEE`, `CLE_MAUVAIS_ENVIRONNEMENT`.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Erreur'
          example:
            code: CLE_INVALIDE
            message: La clé est absente ou inconnue.
  securitySchemes:
    cle:
      type: http
      scheme: bearer
      description: >-
        Votre clé d'API : `umeme_test_…` dans la sandbox, `umeme_live_…` en
        production.

````

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