API gratuit de scurtare URL: exemple de cod care rulează

Un API gratuit pentru scurtarea URL-urilor îți permite să creezi linkuri scurte din cod, în loc să dai clic printr-un dashboard. Trimiți un URL de destinație, primești înapoi un link scurt. Articolul are exemple care rulează în patru variante (curl, JavaScript, Python, Go) pe API-ul Elido, disponibil pe planul gratuit, plus partea sinceră pe care majoritatea listelor o sar: ce blochează de fapt „gratuit". Pentru un parcurs într-un singur limbaj, cu reîncercări, idempotență și operațiuni în masă, există câte unul pentru fiecare runtime: Python, JavaScript și Node, PHP, Go, Ruby, Java, C# și PowerShell.

N-ai scurtat niciodată un link? Cum scurtezi un URL acoperă mai întâi varianta manuală. Tot ce urmează presupune că vrei să o faci programatic.

Ce face un API de scurtare

În esență, API-ul are patru operații pe o resursă de tip link: creare, citire, actualizare, ștergere. Creezi un link trimițând un URL de destinație, iar serviciul returnează un URL scurt care se rezolvă în altă parte.

Un lucru încurcă lumea. Gazda API-ului și gazda de redirecționare sunt diferite. API-ul Elido trăiește la https://api.elido.app/v1, în timp ce linkurile scurte propriu-zise se rezolvă pe un domeniu de redirecționare ca s.elido.me. Vorbești cu API-ul ca să gestionezi linkurile; utilizatorii tăi ating doar domeniul de redirecționare. Separarea celor două e ceea ce permite căii de redirecționare să rămână rapidă, în timp ce API-ul face munca mai grea.

Autentifică-te întâi

Fiecare cerere reală poartă un token bearer în antetul Authorization. Generezi tokenul în setările workspace-ului, îl stochezi ca variabilă de mediu și nu-l pui niciodată în cod de client, pentru că oricine are tokenul poate crea linkuri pe contul tău.

export ELIDO_TOKEN="your_token_here"

Acesta e tot modelul de autentificare: un antet, Authorization: Bearer $ELIDO_TOKEN, la fiecare apel. API-urile care sar peste asta sunt comode pentru un script de unică folosință, dar în spatele linkurilor nu există un cont, deci nu le poți lista, edita sau măsura mai târziu.

Creează un link scurt

Iată același apel de creare în patru limbaje. Fiecare trimite un URL de destinație și afișează URL-ul scurt din răspuns.

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

Răspunsul e JSON:

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

JavaScript, cu fetch încorporat:

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, cu 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, cu biblioteca 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
}

Adaugă în corp câmpuri opționale după nevoie: un slug pentru o terminație personalizată, tags pentru organizare, un domain ca să alegi un domeniu personalizat de marcă sau expires_at pentru un link care nu mai funcționează după o dată.

Ce blochează de fapt „gratuit"

Aici e comparația sinceră, pentru că „API gratuit" acoperă două lucruri foarte diferite.

Endpointurile fără înscriere și fără autentificare, cele care scurtează un URL cu un singur POST neautentificat, sunt cu adevărat gratuite și cu adevărat limitate. Limite de rată partajate, fără cont, fără domeniu de marcă, fără statistici și fără promisiunea că serviciul există trimestrul viitor. Bune pentru un script de o singură dată. Riscante pentru orice livrezi.

Un nivel gratuit autentificat e varianta mai utilă. Acolo blocările sunt previzibile. Funcțiile rezervate cel mai des planurilor plătite sunt domeniile personalizate de marcă, volumul mare de cereri, retenția mai lungă a statisticilor și endpointurile în masă. Pe planul gratuit Elido, API-ul în sine e inclus, linkurile se rezolvă și sunt urmărite, iar limitele sunt la nivel de workspace, nu partajate cu necunoscuți. Pentru cum se compară uneltele plătite aici, Dub vs Bitly acoperă două dintre cele mai cunoscute API-uri, iar poți începe pe planul gratuit ca să-l încerci pe cel Elido.

Regula mea de bază: dacă linkul e de unică folosință, un API fără autentificare e în regulă. Dacă poartă marca ta sau vrei să-l măsori, folosește unul autentificat, cu un domeniu pe care îl controlezi.

Limite de rată și idempotență

În producție, numărul care te protejează cu adevărat nu e limita de rată. E idempotența.

Fiecare cerere care modifică ceva acceptă un antet Idempotency-Key. Trimite o cheie unică cu un apel de creare și, dacă cererea expiră și o reîncerci cu aceeași cheie, serverul returnează rezultatul inițial, în loc să creeze un al doilea link. Asta face o buclă de reîncercare sigură.

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

Idempotența e o proprietate a semanticii metodelor HTTP din RFC 9110, iar orice API pe care te bazezi pentru crearea automată de linkuri ar trebui să o accepte. Tratarea mai amplă, ce coduri de stare să reîncerci și cum te ritmezi față de limită, e în limite de rată, reîncercări și idempotență în producție.

SDK-uri sau HTTP direct?

SDK-urile oficiale Elido (TypeScript, Python, Go și Ruby), generate din specificația OpenAPI, nu sunt încă publice; lansarea publică vine în curând. Până atunci, ghidul rapid pentru API și SDK arată aceleași apeluri prin HTTP direct în fiecare limbaj.

Folosește HTTP direct, ca în exemplele de mai sus: zero dependențe și merge din orice limbaj. Reîncercările rămân deocamdată în grija ta: la un 429 așteaptă conform antetului Retry-After și trimite un Idempotency-Key la creare. Când vor apărea SDK-urile, vor fi o cale mai subțire spre același API REST.

Articole conexe de pe blog

• Ghid rapid pentru API și SDK-urile scurtătorului de URL
• Limite de rată, reîncercări și idempotență în producție
• Cum scurtezi un URL: linkuri gratuite, de marcă și în masă
• Dub vs Bitly: prețuri, planuri gratuite și funcții
• Alternativă la API-ul Bitly pentru dezvoltatori: la ce să te uiți
• CLI pentru scurtătorul de URL: scurtează linkuri din terminal