📆 Publié le 3 mai 2026

9 min de lecture

par Macktireh

Exploiter les API dans Power BI : Authentification JWT et Pagination avec Power Query

---

Table des matières

• Introduction
• Exploration de l’API DummyJSON
• Configuration des paramètres et des fonctions Power Query
  • 1. Paramètres globaux
  • 2. Fonctions utilitaires HTTP
  • 3. Gestion de l’authentification
  • 4. Récupération et pagination
• Utilisation pratique
• Conclusion

Introduction

Si vous utilisez Power BI, vous avez probablement déjà eu besoin d’importer des données depuis une API REST. Et vous savez quoi ? Ce n’est pas toujours une partie de plaisir ! Entre l’authentification, les en-têtes HTTP, la pagination… on peut vite se perdre.

Dans cet article, je vais vous montrer concrètement comment importer des données d’une API dans Power BI en utilisant Power Query. On va voir ensemble comment gérer l’authentification JWT et la pagination, le tout avec un exemple pratique basé sur l’API DummyJSON . C’est une API gratuite et simple qui simule parfaitement les cas d’usage réels.

Avant de commencer, j’imagine que vous :

• Connaissez déjà les bases de Power BI Desktop
• Avez déjà ouvert l’éditeur Power Query au moins une fois
• Comprenez les concepts de base des API REST (GET, POST, en-têtes, JSON)

Si c’est le cas, parfait ! On peut y aller.

Exploration de l’API DummyJSON

Avant de plonger dans le code, prenons quelques minutes pour comprendre comment fonctionne l’API qu’on va utiliser. DummyJSON est une ressource géniale qui fournit des données fictives (produits, utilisateurs, articles, etc.) et simule les mécanismes typiques des vraies API : authentification, pagination, etc.

Voici le processus général pour récupérer des données depuis une API protégée :

Étape 1 : L’authentification

Envoi des identifiants

La première chose à faire, c’est s’authentifier. On envoie une requête POST à l’endpoint /auth/login avec nos identifiants au format JSON :

1
{
2
  "username": "emilys",
3
  "password": "emilyspass"
4
}

Réception des jetons

En retour, l’API nous donne un objet JSON avec deux jetons importants :

• accessToken : c’est notre sésame pour accéder aux données protégées
• refreshToken : il servira à renouveler l’access token quand il expirera

Étape 2 : Récupération des données

Envoi de la requête avec le jeton

Maintenant qu’on a notre accessToken, on peut demander les données ! On envoie une requête GET à /auth/products en incluant le jeton dans l’en-tête Authorization comme ceci : Bearer votre_access_token.

Réception des données

L’API nous renvoie un objet JSON contenant :

• La liste des produits dans le champ products
• Des infos sur la pagination : total (nombre total d’éléments), skip (combien on en a sauté), limit (combien on en récupère par page)

Voici un exemple de réponse simplifiée :

1
{
2
  "products": [
3
    {
4
      "id": 1,
5
      "title": "iPhone 13 Pro",
6
      "description": "Latest iPhone model with advanced features",
7
      "category": "Electronics",
8
      "price": 999.99,
9
      "discountPercentage": 10.5,
10
      "rating": 4.7,
11
      "stock": 50,
12
      "brand": "Apple",
13
      ...
14
    },
15
    ...
16
  ],
17
  "total": 80,
18
  "skip": 0,
19
  "limit": 20
20
}

Vous voyez le principe ? Maintenant qu’on comprend le fonctionnement, passons à l’implémentation dans Power Query !

Configuration des paramètres et des fonctions Power Query

C’est parti pour le code ! On va construire notre solution étape par étape en créant des paramètres et des fonctions réutilisables. L’idée, c’est de faire les choses proprement dès le départ pour faciliter la maintenance et les évolutions futures.

1. Configuration des paramètres globaux Power Query

Commençons par créer des paramètres qui vont centraliser toutes nos configurations. Comme ça, si vous devez changer l’URL de l’API ou vos identifiants, vous n’aurez qu’un seul endroit à modifier !

Comment faire :

1. Dans l’Éditeur Power Query, allez dans l’onglet Accueil

2. Cliquez sur Gérer les paramètres > Nouveau paramètre

3. Créez les paramètres suivants :

   • API_BASE_URL :
     • Description : L’URL de base de l’API
     • Type : Texte
     • Valeur : https://dummyjson.com
   • API_LOGIN_USERNAME :
     • Description : Votre nom d’utilisateur
     • Type : Texte
     • Valeur : emilys
   • API_LOGIN_PASSWORD :
     • Description : Votre mot de passe
     • Type : Texte
     • Valeur : emilyspass
   • API_PAGINATION_SKIP :
     • Description : Point de départ pour la pagination
     • Type : Nombre décimal
     • Valeur : 0
   • API_PAGINATION_LIMIT :
     • Description : Nombre d’éléments par page
     • Type : Nombre décimal
     • Valeur : 20

2. Fonctions utilitaires pour les requêtes HTTP

Maintenant, on va créer quatre fonctions “briques de base” qui vont nous simplifier la vie pour tous nos appels API. Ces fonctions vont gérer les en-têtes, les paramètres de requête, et les appels HTTP eux-mêmes.

Comment créer une fonction :

1. Dans l’Éditeur Power Query, onglet Accueil
2. Cliquez sur Nouvelle source > Requête vide
3. Ouvrez l’éditeur avancé
4. Collez le code de la fonction
5. Donnez-lui un nom explicite

2.1 GetHeaderParameters : Préparer les en-têtes HTTP

Cette fonction configure les en-têtes de base nécessaires pour nos requêtes HTTP. Elle définit par défaut le type de contenu en JSON et peut accepter des en-têtes supplémentaires si besoin.

1
let
2
    GetHeadersParameters = (optional Headers as record) =>
3
        let
4
            Headers = Record.Combine({
5
                [#"Content-Type" = "application/json"],
6
                (Headers ?? [])
7
            })
8
        in
9
            Headers
10
in
11
    GetHeadersParameters

Elle crée un enregistrement avec Content-Type: application/json et fusionne avec d’éventuels en-têtes supplémentaires que vous passez en paramètre.

2.2 GetQueryParameters : Gérer les paramètres de pagination

Cette fonction prépare les paramètres d’URL pour la pagination. Elle utilise les paramètres globaux qu’on a définis plus tôt.

1
let
2
    GetQueryParameters = (optional Skip as number, optional Query as record) =>
3
        let
4
            Query = Record.Combine({
5
                [
6
                    skip = Number.ToText(Skip ?? API_PAGINATION_SKIP),
7
                    limit = Number.ToText(API_PAGINATION_LIMIT)
8
                ],
9
                (Query ?? [])
10
            })
11
        in
12
            Query
13
in
14
    GetQueryParameters

Elle construit un objet avec les paramètres skip et limit pour la pagination, et peut inclure d’autres paramètres si vous en passez.

2.3 HttpClientGetRequest : Effectuer les requêtes GET

Voici notre fonction pour les requêtes GET. Elle utilise Web.Contents de Power Query pour faire l’appel HTTP.

1
let
2
    HttpClientGetRequest = (
3
        RelativePath as text,
4
        optional Query as record,
5
        optional Headers as record
6
    ) =>
7
        let
8
            Options = [
9
                RelativePath = RelativePath,
10
                Query = (Query ?? []),
11
                Headers = (Headers ?? [])
12
            ],
13
            RawData = Web.Contents(API_BASE_URL, Options),
14
            Json = Json.Document(RawData)
15
        in
16
            Json
17
in
18
    HttpClientGetRequest

Elle combine l’URL de base avec le chemin relatif, ajoute les paramètres de requête et les en-têtes, fait l’appel HTTP, et retourne le résultat en JSON.

2.4 HttpClientPostRequest : Effectuer les requêtes POST

Même principe que pour GET, mais pour les requêtes POST qui incluent un corps de requête.

1
let
2
    HttpClientPostRequest = (
3
        RelativePath as text,
4
        optional Query as record,
5
        optional Headers as record,
6
        optional Body as record
7
    ) =>
8
        let
9
            Options = [
10
                RelativePath = RelativePath,
11
                Query = (Query ?? []),
12
                Headers = (Headers ?? []),
13
                Content = Json.FromValue(Body ?? [])
14
            ],
15
            RawData = Web.Contents(API_BASE_URL, Options),
16
            Json = Json.Document(RawData)
17
        in
18
            Json
19
in
20
    HttpClientPostRequest

Pareil que GET, mais avec un paramètre Body en plus. Le fait d’ajouter Content à l’option transforme automatiquement la requête en POST.

1
let
2
    HttpClient = (
3
        RelativePath as text,
4
        optional Query as record,
5
        optional Headers as record,
6
        optional Body as record
7
    ) =>
8
        let
9
            GetOptions = [
10
                RelativePath = RelativePath,
11
                Query = (Query ?? []),
12
                Headers = (Headers ?? [])
13
            ],
14
            PostOptions = [
15
                RelativePath = RelativePath,
16
                Query = (Query ?? []),
17
                Headers = (Headers ?? []),
18
                Content = Json.FromValue(Body ?? [])
19
            ],
20
            Options = if Body <> null and Record.FieldCount(Body) > 0
21
                then PostOptions
22
                else GetOptions,
23
            RawData = Web.Contents(API_BASE_URL, Options),
24
            Json = Json.Document(RawData)
25
        in
26
            Json
27
in
28
    HttpClient

3. Gestion de l’authentification

Maintenant qu’on a nos fonctions de base, occupons-nous de l’authentification JWT.

3.1 GetJwtTokens : Obtenir les jetons d’accès

Cette fonction se connecte à l’API et récupère nos précieux jetons.

1
let
2
    GetJwtTokens = () =>
3
        let
4
            Headers = GetHeadersParameters(),
5
            Query = [],
6
            Body = [
7
                username = API_LOGIN_USERNAME,
8
                password = API_LOGIN_PASSWORD
9
            ],
10
            Response = HttpClientPostRequest("auth/login", Query, Headers, Body),
11
            JwtTokens = [
12
                accessToken = Record.Field(Response, "accessToken"),
13
                refreshToken = Record.Field(Response, "refreshToken")
14
            ]
15
        in
16
            JwtTokens
17
in
18
    GetJwtTokens

Elle envoie une requête POST avec vos identifiants à /auth/login et extrait les jetons d’accès et de rafraîchissement de la réponse.

3.2 GetHeadersParametersWithAccessToken : Ajouter le jeton aux en-têtes

Cette fonction combine tout ce qu’on a fait jusqu’ici : elle récupère le jeton et l’ajoute aux en-têtes HTTP.

1
let
2
    GetHeadersParametersWithAccessToken = (optional Headers as record) =>
3
        let
4
            JwtTokens = GetJwtTokens(),
5
            accessToken = Record.Field(JwtTokens, "accessToken"),
6
            Headers = Record.Combine({
7
                GetHeadersParameters((Headers ?? [])),
8
                [Authorization = Text.Format("Bearer #{0}", {accessToken})]
9
            })
10
        in
11
            Headers
12
in
13
    GetHeadersParametersWithAccessToken

Elle appelle GetJwtTokens(), récupère l’access token, et l’ajoute dans un en-tête Authorization: Bearer token. Comme ça, toutes vos requêtes authentifiées sont prêtes !

4. Récupération des données et gestion de la pagination

On arrive au cœur du système : la fonction qui va tout orchestrer pour récupérer les données, page par page.

1
let
2
    FetchDataFromApi = (
3
        RelativePath as text,
4
        ResultsFieldName as text,
5
        TotalFieldName as text
6
    ) =>
7
        let
8
            // Fonction interne : récupère le nombre total d'éléments
9
            RetrieveTotalCount = (FieldName as text) =>
10
                let
11
                    ApiResponse = HttpClientGetRequest(
12
                        RelativePath,
13
                        GetQueryParameters(),
14
                        GetHeadersParametersWithAccessToken()
15
                    ),
16
                    TotalCount = Record.Field(ApiResponse, FieldName)
17
                in
18
                    TotalCount,
19

20
            // Fonction interne : récupère une page spécifique
21
            FetchPage = (FieldName as text, PageIndex as number) =>
22
                let
23
                    Offset = (PageIndex ?? 0) * API_PAGINATION_LIMIT,
24
                    QueryParams = GetQueryParameters(Offset),
25
                    AuthHeaders = GetHeadersParametersWithAccessToken(),
26
                    ApiResponse = HttpClientGetRequest(
27
                        RelativePath,
28
                        QueryParams,
29
                        AuthHeaders
30
                    ),
31
                    Results = Record.Field(ApiResponse, FieldName)
32
                in
33
                    Results,
34

35
            // Fonction principale : récupère toutes les pages
36
            GetAllData = () =>
37
                let
38
                    TotalCount = RetrieveTotalCount(TotalFieldName),
39
                    MaxCount = List.Max({API_PAGINATION_LIMIT, TotalCount}),
40
                    TotalPages = Number.RoundUp(MaxCount / API_PAGINATION_LIMIT),
41
                    PageIndices = {0..TotalPages - 1},
42
                    AllPages = List.Transform(
43
                        PageIndices,
44
                        each FetchPage(ResultsFieldName, _)
45
                    ),
46
                    CombinedPages = List.Union(AllPages),
47
                    DataTable = Table.FromList(
48
                        CombinedPages,
49
                        Splitter.SplitByNothing(),
50
                        null,
51
                        null,
52
                        ExtraValues.Error
53
                    ),
54
                    ColumnIndices = List.Positions(Table.ColumnNames(DataTable)),
55
                    RecordColumnIndex = List.First(
56
                        List.Select(
57
                            ColumnIndices,
58
                            each Type.Is(
59
                                Value.Type(Record.FieldValues(DataTable{0}){_}),
60
                                type record
61
                            )
62
                        )
63
                    ),
64
                    RecordColumnName = Table.ColumnNames(DataTable){RecordColumnIndex},
65
                    RecordFieldNames = Record.FieldNames(
66
                        Record.FieldValues(DataTable{0}){RecordColumnIndex}
67
                    ),
68
                    ExpandedTable = Table.ExpandRecordColumn(
69
                        DataTable,
70
                        RecordColumnName,
71
                        RecordFieldNames,
72
                        RecordFieldNames
73
                    )
74
                in
75
                    ExpandedTable
76
        in
77
            GetAllData()
78
in
79
    FetchDataFromApi

Je ne vais pas entrer dans les détails de chaque ligne de code, je vous encourage à examiner le code pour bien comprendre son fonctionnement. Mais voici ce que fait cette fonction :

1. Elle a besoin de trois infos :

   • RelativePath : le chemin de l’API (exemple : “auth/products”)
   • ResultsFieldName : le nom du champ qui contient les résultats (exemple : “products”)
   • TotalFieldName : le nom du champ qui indique le total (exemple : “total”)

2. Elle compte d’abord : Elle fait un premier appel juste pour savoir combien il y a d’éléments au total. Comme quand vous regardez le nombre de pages d’un livre avant de le lire

3. Elle récupère page par page : Elle calcule combien de pages il faut télécharger, puis elle va chercher chaque page l’une après l’autre

4. Elle assemble le tout : Toutes les pages sont combinées en une seule grande liste

5. Elle nettoie et structure : La liste est transformée en un beau tableau Power Query, avec toutes les colonnes bien dépliées et organisées

En gros, vous lui donnez le chemin de l’API et les noms des champs importants, et elle vous rend un tableau complet avec toutes les données. Magique, non ?

5. Organisation de vos fonctions

Petit conseil d’organisation : créez des dossiers dans Power Query pour ranger vos paramètres et fonctions. Ça aide vraiment à maintenir un projet propre !

Voici comment je structure mes projets par exemple :

Importation des données dans Power BI (Utilisation de la fonction FetchDataFromApi)

Maintenant que tout est en place, voyons à quel point c’est simple d’utiliser notre travail !

Récupérer les produits

Créez une nouvelle requête vide et collez ce code :

1
let
2
    Source = FetchDataFromApi("auth/products", "products", "total")
3
in
4
    Source

C’est tout ! Vraiment, c’est tout.

Cliquez sur Terminer et admirez vos données qui se chargent :

Récupérer les utilisateurs

Même principe, c’est tout aussi simple :

1
let
2
    Source = FetchDataFromApi("auth/users", "users", "total")
3
in
4
    Source

Vous voyez ? Une fois que vous avez fait le travail de base, ajouter de nouvelles sources de données devient un jeu d’enfant !

Tip

Visualisez vos dépendances

Power Query propose une vue super pratique appelée “Dépendances de requêtes” qui vous montre graphiquement comment toutes vos fonctions et requêtes sont connectées. C’est parfait pour :

• Comprendre la structure de votre projet d’un coup d’œil
• Vérifier que tout est bien relié
• Repérer d’éventuels problèmes de dépendance

Pour y accéder : Onglet Affichage > Dépendances de requêtes

Conclusion

Voilà, on a fait le tour !

Dans cet article, on a vu ensemble comment :

• Structurer proprement un projet Power Query avec des paramètres et des fonctions réutilisables
• Gérer l’authentification JWT avec une API
• Récupérer automatiquement toutes les pages de données grâce à la pagination
• Transformer tout ça en tableaux propres et prêts à l’emploi dans Power BI

Le gros avantage de cette approche, c’est que maintenant vous avez un système réutilisable. Besoin de connecter une nouvelle API ? Vous n’avez qu’à adapter les paramètres et les chemins, le reste est déjà fait !

Quelques conseils pour aller plus loin :

• Adaptez le code à vos propres API (elles fonctionnent toutes un peu différemment)
• Ajoutez de la gestion d’erreurs si nécessaire
• Pensez à documenter vos fonctions avec des commentaires
• Testez toujours

Si vous avez apprécié cette approche basée sur des fonctions réutilisables, vous allez adorer ces deux autres articles qui suivent la même philosophie :

🔗 Gestion flexible des sources de données
Vous gérez des tableaux de bord qui doivent fonctionner sur différents environnements ? Découvrez comment adapter dynamiquement vos connexions MySQL selon l’environnement (développement, test, production). C’est le complément parfait de cet article si vous travaillez avec des bases de données volumineuses et que vous voulez éviter de reconfigurer manuellement vos sources à chaque fois.

📁 Importer plusieurs fichiers Excel/CSV proprement
Marre de voir votre éditeur Power Query pollué par des dizaines de requêtes quand vous importez plusieurs fichiers ? Je vous montre comment créer une fonction personnalisée pour combiner des fichiers Excel ou CSV de façon élégante.