API gratuite de raccourcisseur d'URL : des exemples de code qui fonctionnent

Une API gratuite de raccourcisseur d'URL vous permet de créer des liens courts depuis du code au lieu de cliquer dans un tableau de bord. Vous envoyez une requête avec une URL de destination, vous récupérez un lien court qui redirige vers elle. Cet article contient des exemples exécutables en curl, JavaScript, Python et Go face à l'API d'Elido, disponible sur le plan gratuit, plus la partie honnête que la plupart des listicles omettent : ce que « gratuit » verrouille réellement. Pour un guide consacré à un seul langage, avec retries, idempotence et traitement en masse, il en existe un par runtime : Python, JavaScript et Node, PHP, Go, Ruby, Java, C#, et PowerShell.

Si vous n'avez encore jamais raccourci de lien du tout, comment raccourcir une URL couvre d'abord la version manuelle. Tout ce qui suit suppose que vous voulez le faire de manière programmatique.

Ce que fait une API de raccourcisseur

Au fond, l'API est constituée de quatre opérations sur une ressource lien : créer, lire, mettre à jour, supprimer. Vous créez un lien en postant une URL de destination, et le service renvoie une URL courte qui se résout ailleurs.

Une chose qui piège les gens : l'hôte de l'API et l'hôte de redirection sont différents. L'API d'Elido vit à https://api.elido.app/v1, tandis que les liens courts eux-mêmes se résolvent sur un domaine de redirection comme s.elido.me. Vous parlez à l'API pour gérer les liens ; vos utilisateurs ne touchent jamais que le domaine de redirection. Garder ces deux éléments séparés est ce qui permet au chemin de redirection de rester rapide pendant que l'API fait le travail plus lourd.

Authentifiez-vous d'abord

Chaque vraie requête porte un jeton bearer dans l'en-tête Authorization. Vous générez le jeton dans les paramètres de votre espace de travail, vous le stockez comme variable d'environnement, et vous ne le mettez jamais dans du code côté client, car quiconque possède le jeton peut créer des liens sur votre compte.

export ELIDO_TOKEN="your_token_here"

C'est tout le modèle d'authentification : un en-tête, Authorization: Bearer $ELIDO_TOKEN, à chaque appel. Les API qui sautent complètement cela sont pratiques pour un script jetable, mais il n'y a aucun compte derrière les liens, donc vous ne pouvez pas les lister, les modifier ou les mesurer plus tard.

Créer un lien court

Voici le même appel de création en quatre langages. Chacun poste une URL de destination et affiche l'URL courte à partir de la réponse.

curl -X POST https://api.elido.app/v1/links \
  -H "Authorization: Bearer $ELIDO_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"destination_url": "https://example.com/spring-sale"}'

La réponse est du JSON :

{
  "id": "lnk_9aF2xK",
  "short_url": "https://s.elido.me/abc123",
  "destination_url": "https://example.com/spring-sale"
}

JavaScript, en utilisant le fetch intégré :

const res = await fetch("https://api.elido.app/v1/links", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.ELIDO_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ destination_url: "https://example.com/spring-sale" }),
});
const link = await res.json();
console.log(link.short_url); // https://s.elido.me/abc123

Python, avec requests :

import os
import requests

res = requests.post(
    "https://api.elido.app/v1/links",
    headers={"Authorization": f"Bearer {os.environ['ELIDO_TOKEN']}"},
    json={"destination_url": "https://example.com/spring-sale"},
)
print(res.json()["short_url"])  # https://s.elido.me/abc123

Go, avec la bibliothèque standard :

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body, _ := json.Marshal(map[string]string{
		"destination_url": "https://example.com/spring-sale",
	})
	req, _ := http.NewRequest("POST", "https://api.elido.app/v1/links", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("ELIDO_TOKEN"))
	req.Header.Set("Content-Type", "application/json")

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

	var link struct {
		ShortURL string `json:"short_url"`
	}
	json.NewDecoder(res.Body).Decode(&link)
	fmt.Println(link.ShortURL) // https://s.elido.me/abc123
}

Ajoutez des champs optionnels au corps selon vos besoins : un slug pour une seconde partie personnalisée, tags pour l'organisation, un domain pour choisir un domaine personnalisé de marque, ou expires_at pour un lien qui cesse de fonctionner après une date.

Ce que « gratuit » verrouille réellement

C'est ici que réside la comparaison honnête, car « API gratuite » couvre deux choses très différentes.

Les points de terminaison sans inscription et sans authentification, ceux qui raccourcissent une URL avec un simple POST non authentifié, sont véritablement gratuits et véritablement limités. Limites de débit partagées, aucun compte, aucun domaine de marque, aucune analyse, et aucune promesse que le service existe le trimestre prochain. Correct pour un script ponctuel, risqué pour tout ce que vous mettez en production.

Un palier gratuit authentifié est le type le plus utile, et là le verrouillage est prévisible. Les fonctionnalités le plus souvent réservées aux plans payants sont les domaines personnalisés de marque, un volume de requêtes élevé, une conservation d'analyses plus longue, et les points de terminaison en masse. Sur le plan gratuit d'Elido, l'API elle-même est incluse, les liens se résolvent et sont suivis, et les limites sont propres à l'espace de travail plutôt que partagées avec des inconnus. Pour savoir comment les outils payants se comparent sur ce point, Dub vs Bitly couvre deux des API les plus connues, et vous pouvez commencer sur le plan gratuit pour essayer celle d'Elido.

La règle empirique : si le lien est jetable, une API sans authentification convient. S'il porte votre marque ou si vous devez le mesurer, utilisez-en une authentifiée avec un domaine que vous contrôlez.

Limites de débit et idempotence

Le chiffre qui vous protège réellement en production n'est pas la limite de débit, c'est l'idempotence.

Chaque requête de mutation accepte un en-tête Idempotency-Key. Envoyez une clé unique avec un appel de création, et si la requête expire et que vous retentez avec la même clé, le serveur renvoie le résultat original au lieu de créer un second lien. C'est ce qui rend une boucle de nouvelle tentative sûre.

curl -X POST https://api.elido.app/v1/links \
  -H "Authorization: Bearer $ELIDO_TOKEN" \
  -H "Idempotency-Key: spring-sale-2026-04-01" \
  -H "Content-Type: application/json" \
  -d '{"destination_url": "https://example.com/spring-sale"}'

L'idempotence est une propriété de la sémantique des méthodes HTTP dans RFC 9110, et toute API sur laquelle vous vous appuyez pour la création automatisée de liens devrait la prendre en charge. Le traitement plus approfondi, sur quels codes de statut retenter et comment cadencer par rapport à la limite, se trouve dans limites de débit, nouvelles tentatives et idempotence en production.

SDK ou HTTP brut ?

Vous n'êtes pas obligé d'écrire vos requêtes à la main. Elido publie des SDK générés à partir de sa spécification OpenAPI pour TypeScript, Python, Go, et plus encore, et le démarrage rapide API et SDK explique comment les installer et les appeler.

Utilisez un SDK quand vous voulez que les types, les nouvelles tentatives et la pagination soient gérés pour vous. Utilisez le HTTP brut, comme les exemples ci-dessus, quand vous voulez zéro dépendance ou que vous appelez depuis un langage sans client officiel. Les deux frappent la même API REST ; le SDK n'est qu'un chemin plus fin vers elle.

À lire aussi sur le blog

• Démarrage rapide de l'API et du SDK de raccourcisseur d'URL
• Limites de débit, nouvelles tentatives et idempotence en production
• Comment raccourcir une URL : liens gratuits, de marque et en masse
• Dub vs Bitly : prix, plans gratuits et fonctionnalités
• Comment raccourcir une URL en Python
• How to Shorten a URL in JavaScript With fetch and Node
• How to Shorten a URL in PHP With curl, Guzzle, or WordPress
• How to Shorten a URL in Go With net/http and errgroup
• Alternative à l'API Bitly pour les développeurs : ce qu'il faut rechercher
• How to Shorten a URL in Ruby With Net::HTTP and Faraday
• How to Shorten a URL in Java With the Built-in HttpClient
• How to Shorten a URL in C# With HttpClient and .NET
• How to Shorten a URL in PowerShell With Invoke-RestMethod
• URL Shortener CLI: Shorten Links From the Terminal