API gratuita per URL shortener: esempi di codice che funzionano

Un'API gratuita per URL shortener ti permette di creare link brevi da codice invece di cliccare in giro su una dashboard. Invii una richiesta con un URL di destinazione, ricevi indietro un link breve che vi reindirizza. Questo articolo ha esempi eseguibili in curl, JavaScript, Python e Go contro l'API di Elido, che è disponibile nel piano gratuito, più la parte onesta che la maggior parte delle listicle salta: cosa limita davvero "gratuito". Per una guida dedicata a un singolo runtime, con retry, idempotenza e bulk, ce n'è una per ciascuno: Python, JavaScript e Node, PHP, Go, Ruby, Java, C# e PowerShell.

Se non hai mai accorciato un link, come accorciare un URL copre prima la versione manuale. Tutto ciò che segue presuppone che tu voglia farlo in modo programmatico.

Cosa fa un'API shortener

Al suo nucleo l'API è quattro operazioni su una risorsa link: creare, leggere, aggiornare, eliminare. Crei un link inviando un URL di destinazione, e il servizio restituisce un URL breve che si risolve altrove.

Una cosa che confonde le persone: l'host dell'API e l'host di reindirizzamento sono diversi. L'API di Elido vive su https://api.elido.app/v1, mentre i link brevi stessi si risolvono su un dominio di reindirizzamento come s.elido.me. Parli con l'API per gestire i link; i tuoi utenti colpiscono sempre e solo il dominio di reindirizzamento. Mantenere questi due separati è ciò che permette al percorso di reindirizzamento di restare veloce mentre l'API fa il lavoro più pesante.

Autenticati prima

Ogni richiesta reale porta un bearer token nell'header Authorization. Generi il token nelle impostazioni del tuo workspace, lo memorizzi come variabile d'ambiente, e non lo metti mai in codice lato client, perché chiunque abbia il token può creare link sul tuo account.

export ELIDO_TOKEN="your_token_here"

Questo è l'intero modello di autenticazione: un header, Authorization: Bearer $ELIDO_TOKEN, su ogni chiamata. Le API che saltano completamente questo passaggio sono comode per uno script usa e getta, ma non c'è alcun account dietro i link, quindi non puoi elencarli, modificarli, o misurarli in seguito.

Crea un link breve

Ecco la stessa chiamata di creazione in quattro linguaggi. Ognuna invia un URL di destinazione e stampa l'URL breve dalla risposta.

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 risposta è JSON:

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

JavaScript, usando fetch incorporato:

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, con 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, con la libreria 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
}

Aggiungi campi opzionali al corpo quando ne hai bisogno: uno slug per una seconda metà personalizzata, tags per l'organizzazione, un domain per scegliere un dominio personalizzato brandizzato, o expires_at per un link che smette di funzionare dopo una data.

Cosa limita davvero "gratuito"

Qui vive il confronto onesto, perché "API gratuita" copre due cose molto diverse.

Gli endpoint senza registrazione e senza autenticazione, quelli che accorciano un URL con un singolo POST non autenticato, sono genuinamente gratuiti e genuinamente limitati. Limiti di frequenza condivisi, nessun account, nessun dominio brandizzato, nessuna analisi, e nessuna promessa che il servizio esista il prossimo trimestre. Va bene per uno script una tantum, rischioso per qualsiasi cosa tu metta in produzione.

Un piano gratuito autenticato è il tipo più utile, e lì la limitazione è prevedibile. Le funzionalità più spesso riservate ai piani a pagamento sono domini personalizzati brandizzati, alto volume di richieste, conservazione più lunga delle analisi, ed endpoint in blocco. Nel piano gratuito di Elido l'API stessa è inclusa, i link si risolvono e vengono tracciati, e i limiti hanno ambito workspace anziché essere condivisi con estranei. Per come si confrontano gli strumenti a pagamento su questo, Dub vs Bitly copre due delle API più conosciute, e puoi iniziare sul piano gratuito per provare quella di Elido.

La regola pratica: se il link è usa e getta, un'API senza autenticazione va bene. Se porta il tuo brand o hai bisogno di misurarlo, usane una autenticata con un dominio che controlli.

Limiti di frequenza e idempotenza

Il numero che davvero ti protegge in produzione non è il limite di frequenza, è l'idempotenza.

Ogni richiesta che modifica accetta un header Idempotency-Key. Invii una chiave unica con una chiamata di creazione, e se la richiesta va in timeout e la ripeti con la stessa chiave, il server restituisce il risultato originale invece di creare un secondo link. Questo è ciò che rende sicuro un ciclo di retry.

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'idempotenza è una proprietà della semantica dei metodi HTTP in RFC 9110, e qualsiasi API su cui fai affidamento per la creazione automatizzata di link dovrebbe supportarla. La trattazione più approfondita, quali codici di stato ripetere e come regolare il ritmo rispetto al limite, è in limiti di frequenza, retry e idempotenza in produzione.

SDK o HTTP grezzo?

Non devi scrivere manualmente le richieste. Elido pubblica SDK generati dalla sua specifica OpenAPI per TypeScript, Python, Go e altri, e la guida rapida API e SDK illustra come installarli e chiamarli.

Usa un SDK quando vuoi tipi, retry e paginazione gestiti per te. Usa HTTP grezzo, come gli esempi sopra, quando vuoi zero dipendenze o stai chiamando da un linguaggio senza un client ufficiale. Entrambi colpiscono la stessa API REST; l'SDK è solo un percorso più sottile verso di essa.

Correlati sul blog

• Guida rapida API e SDK per URL shortener
• Limiti di frequenza, retry e idempotenza in produzione
• Come accorciare un URL: link gratuiti, brandizzati e in blocco
• Dub vs Bitly: prezzi, piani gratuiti e funzionalità
• Come accorciare un URL in 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
• Alternativa all'API di Bitly per sviluppatori: cosa cercare
• 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