Skip to main content
POST
/
api
/
v1
/
auth
/
token
S'authentifier et obtenir un token
curl --request POST \
  --url https://egimgarsud.gimpayapp.com/api/v1/auth/token \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data grant_type=client_credentials \
  --data 'client_id=<string>' \
  --data 'client_secret=<string>'
import requests

url = "https://egimgarsud.gimpayapp.com/api/v1/auth/token"

payload = {
    "grant_type": "client_credentials",
    "client_id": "<string>",
    "client_secret": "<string>"
}
headers = {"Content-Type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.text)
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    grant_type: 'client_credentials',
    client_id: '<string>',
    client_secret: '<string>'
  })
};

fetch('https://egimgarsud.gimpayapp.com/api/v1/auth/token', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://egimgarsud.gimpayapp.com/api/v1/auth/token",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "grant_type=client_credentials&client_id=%3Cstring%3E&client_secret=%3Cstring%3E",
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://egimgarsud.gimpayapp.com/api/v1/auth/token"

	payload := strings.NewReader("grant_type=client_credentials&client_id=%3Cstring%3E&client_secret=%3Cstring%3E")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
HttpResponse<String> response = Unirest.post("https://egimgarsud.gimpayapp.com/api/v1/auth/token")
  .header("Content-Type", "application/x-www-form-urlencoded")
  .body("grant_type=client_credentials&client_id=%3Cstring%3E&client_secret=%3Cstring%3E")
  .asString();
require 'uri'
require 'net/http'

url = URI("https://egimgarsud.gimpayapp.com/api/v1/auth/token")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/x-www-form-urlencoded'
request.body = "grant_type=client_credentials&client_id=%3Cstring%3E&client_secret=%3Cstring%3E"

response = http.request(request)
puts response.read_body
{
  "access_token": "<string>",
  "expires_in": 123,
  "token_type": "<string>",
  "refresh_expires_in": 123,
  "scope": "<string>",
  "not_before_policy": 123
}
{
  "access_token": "<string>",
  "expires_in": 123,
  "token_type": "<string>",
  "refresh_expires_in": 123,
  "scope": "<string>",
  "not_before_policy": 123
}
{
  "access_token": "<string>",
  "expires_in": 123,
  "token_type": "<string>",
  "refresh_expires_in": 123,
  "scope": "<string>",
  "not_before_policy": 123
}
Toutes les requêtes vers l’API GIMgar Sud, à l’exception de la génération du token elle-même, doivent être authentifiées. Ce guide explique le flux d’authentification et comment l’implémenter en toute sécurité.

​
Vue d’ensemble

GIMgar Sud utilise le protocole OAuth 2.0 avec le flux client_credentials : vous échangez un client_id et un client_secret contre un token Bearer (JWT), que vous incluez ensuite dans l’en-tête Authorization de chaque appel.
1

Récupérez vos identifiants

Votre client_id et votre client_secret vous sont fournis par GIM-UEMOA lors de votre intégration à la plateforme.
2

Générez un token

Appelez POST {{baseUrl}}/api/v1/auth/token avec vos identifiants pour obtenir un access_token.
3

Utilisez le token

Incluez Authorization: Bearer {{access_token}} dans l’en-tête de chaque requête vers les autres endpoints.
4

Renouvelez avant expiration

Le token expire après expires_in secondes. Générez-en un nouveau proactivement avant qu’il n’expire plutôt que d’attendre une erreur 401.

​
Exemple de requête

curl --request POST \
  --url {{baseUrl}}/api/v1/auth/token \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data grant_type=client_credentials \
  --data client_id={{client_id}} \
  --data client_secret={{client_secret}}

const response = await fetch("{{baseUrl}}/api/v1/auth/token", {
  method: "POST",
  headers: { "Content-Type": "application/x-www-form-urlencoded" },
  body: new URLSearchParams({
    grant_type: "client_credentials",
    client_id: "{{client_id}}",
    client_secret: "{{client_secret}}",
  }),
});

const { access_token } = await response.json();
La réponse contient votre access_token, sa durée de validité (expires_in, en secondes) et son type (token_type, toujours Bearer).

​
Utiliser le token

Incluez le token dans l’en-tête Authorization de chaque requête vers une API protégée : 
Authorization: Bearer {{access_token}}

​
Sécurité des identifiants

1

Gardez vos identifiants privés

Ne partagez jamais votre client_secret dans du code accessible publiquement (dépôt Git, code côté client, réseaux sociaux).
2

Appelez le token endpoint depuis un backend

Le client_secret ne doit jamais être exposé côté navigateur ou dans une application mobile — générez le token depuis un serveur que vous contrôlez.
3

Utilisez des variables d'environnement

Stockez client_id et client_secret dans des variables d’environnement ou un gestionnaire de secrets, jamais en dur dans le code.
4

Limitez l'accès

Seules les personnes qui en ont réellement besoin doivent avoir accès à ces identifiants.
5

Utilisez HTTPS

Toutes les requêtes doivent transiter en HTTPS pour éviter toute interception du token en transit.

​
Réponses d’erreur

Code httpCause possible
400grant_type, client_id ou client_secret manquant ou invalide.
401Token manquant, invalide ou expiré sur un appel vers une API protégée.
500Problème serveur lors de la génération du token.

​
Étapes suivantes

Référence API

Explorez l’ensemble des endpoints disponibles.

Erreurs

Comprenez les codes d’erreur retournés par l’API.

Tester votre intégration

Utilisez le sandbox interactif pour exécuter vos premiers appels.

Body

application/x-www-form-urlencoded

Identifiants de connexion de l'utilisateur.

​
grant_type
string
required

Le type d'authentification

Example:

"client_credentials"

​
client_id
string
required

L'identifiant du client

​
client_secret
string
required

Le secret du client

Response

Authentification réussie. Le token est retourné dans la réponse.

​
access_token
string

Token JWT signé (au format Bearer) à inclure dans l'en-tête Authorization des requêtes vers les APIs protégées.

​
expires_in
integer<int32>

Durée de validité du token, en secondes.

​
token_type
string

Type du token. Toujours Bearer.

​
refresh_expires_in
integer<int32>

Durée de vie du token de rafraîchissement. Toujours 0.

​
scope
string

Liste des portées accordées au token.

​
not_before_policy
integer<int32>

Timestamp Unix indiquant que le token ne doit pas être accepté avant ce moment.