Gratis URL-verkorter-API: codevoorbeelden die werken

Met een gratis URL-verkorter-API maak je korte links vanuit code in plaats van door een dashboard te klikken. Je stuurt een bestemmings-URL en krijgt een korte link terug. Dit artikel heeft werkende voorbeelden in vier varianten (curl, JavaScript, Python, Go) tegen de API van Elido, die op het gratis plan beschikbaar is, plus het eerlijke deel dat de meeste lijstjes overslaan: wat "gratis" echt beperkt. Voor een walkthrough per taal met retries, idempotency en bulk is er één per runtime: Python, JavaScript en Node, PHP, Go, Ruby, Java, C# en PowerShell.

Heb je nog nooit een link verkort? Een URL verkorten behandelt eerst de handmatige versie. Alles hieronder gaat ervan uit dat je het programmatisch wilt doen.

Wat een verkorter-API doet

In de kern is de API vier bewerkingen op een linkresource: aanmaken, lezen, bijwerken, verwijderen. Je maakt een link door een bestemmings-URL te posten, en de dienst geeft een korte URL terug die naar elders verwijst.

Eén ding doet mensen struikelen. De API-host en de redirect-host zijn verschillend. De API van Elido staat op https://api.elido.app/v1, terwijl de korte links zelf op een redirectdomein als s.elido.me worden afgehandeld. Je praat met de API om links te beheren; je gebruikers komen alleen op het redirectdomein. Door die twee gescheiden te houden blijft het redirectpad snel terwijl de API het zwaardere werk doet.

Authenticeer eerst

Elk echt verzoek draagt een bearertoken in de Authorization-header. Je genereert het token in de instellingen van je werkruimte, bewaart het als omgevingsvariabele en zet het nooit in code aan de clientkant, want wie het token heeft, kan links op jouw account maken.

export ELIDO_TOKEN="your_token_here"

Dat is het hele authenticatiemodel: één header, Authorization: Bearer $ELIDO_TOKEN, bij elke call. API's die dit helemaal overslaan zijn handig voor een wegwerpscript, maar er staat geen account achter de links, dus je kunt ze later niet opvragen, bewerken of meten.

Een korte link aanmaken

Hier is dezelfde create-call in vier talen. Elk daarvan post een bestemmings-URL en print de korte URL uit het antwoord.

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"}'

Het antwoord is JSON:

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

JavaScript, met de ingebouwde fetch:

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, met 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, met de standaardbibliotheek:

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
}

Voeg optionele velden aan de body toe wanneer je ze nodig hebt: een slug voor een eigen achterdeel, tags voor organisatie, een domain om een branded eigen domein te kiezen, of expires_at voor een link die na een datum stopt met werken.

Wat "gratis" echt beperkt

Hier zit de eerlijke vergelijking, want "gratis API" dekt twee heel verschillende dingen.

De endpoints zonder aanmelding en zonder authenticatie, die een URL verkorten met één ongeauthenticeerde POST, zijn echt gratis en echt beperkt. Gedeelde rate limits, geen account, geen branded domein, geen analytics en geen belofte dat de dienst er volgend kwartaal nog is. Prima voor een eenmalig script. Riskant voor alles wat je uitbrengt.

Een geauthenticeerde gratis tier is de nuttiger soort. Daar is de beperking voorspelbaar. De functies die het vaakst voor betaalde plannen zijn gereserveerd, zijn branded eigen domeinen, hoog verzoekvolume, langere bewaartermijn van analytics en bulk-endpoints. Op het gratis plan van Elido zit de API zelf erbij inbegrepen, worden links afgehandeld en gemeten, en gelden de limieten per werkruimte in plaats van gedeeld met vreemden. Voor hoe de betaalde tools zich hierin verhouden, behandelt Dub vs Bitly twee van de bekendste API's, en je kunt op het gratis plan beginnen om die van Elido uit te proberen.

De vuistregel die ik hanteer: is de link wegwerp, dan volstaat een API zonder authenticatie. Draagt hij je merk of wil je hem meten, gebruik dan een geauthenticeerde met een domein dat je beheert.

Rate limits en idempotency

In productie is het getal dat je echt beschermt niet de rate limit. Het is idempotency.

Elk verzoek dat iets wijzigt, accepteert een Idempotency-Key-header. Stuur bij een create-call een unieke key mee, en als het verzoek een time-out krijgt en je het opnieuw probeert met dezelfde key, geeft de server het oorspronkelijke resultaat terug in plaats van een tweede link te maken. Dat maakt een retry-lus veilig.

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"}'

Idempotency is een eigenschap van de semantiek van HTTP-methoden in RFC 9110, en elke API waarop je voor geautomatiseerd links aanmaken vertrouwt, hoort het te ondersteunen. De diepere behandeling, welke statuscodes je opnieuw probeert en hoe je je je tempo afstemt op de limiet, staat in rate limits, retries en idempotency in productie.

SDK's of kale HTTP?

De officiële SDK's van Elido (TypeScript, Python, Go en Ruby), gegenereerd uit de OpenAPI-specificatie, zijn nog niet openbaar; de openbare release komt binnenkort. Tot die tijd laat de quickstart voor API en SDK's dezelfde aanroepen zien met kale HTTP in elke taal.

Gebruik kale HTTP, zoals in de voorbeelden hierboven: geen afhankelijkheden en het werkt vanuit elke taal. Retries zijn voorlopig aan jou: wacht bij een 429 volgens de Retry-After-header en stuur bij het aanmaken een Idempotency-Key mee. Zodra de SDK's uitkomen, zijn ze een dunner pad naar dezelfde REST-API.

Verwant op de blog

• Quickstart voor de URL-verkorter-API en SDK's
• Rate limits, retries en idempotency in productie
• Een URL verkorten: gratis, branded en bulk-links
• Dub vs Bitly: prijzen, gratis plannen en functies
• Bitly API-alternatief voor developers: waar je op let
• URL-verkorter-CLI: links verkorten vanuit de terminal