API gratuita de acortador de URL: ejemplos de código que funcionan

Una API gratuita de acortador de URL te permite crear enlaces cortos desde código en lugar de hacer clic por un panel. Envías una solicitud con una URL de destino, obtienes de vuelta un enlace corto que redirige a ella. Este artículo tiene ejemplos ejecutables en curl, JavaScript, Python y Go contra la API de Elido, disponible en el plan gratuito, además de la parte honesta que la mayoría de las listas se saltan: qué restringe realmente "gratis".

Si nunca has acortado un enlace, cómo acortar una URL cubre primero la versión manual. Todo lo de abajo asume que quieres hacerlo de forma programática.

Qué hace una API de acortador

En su núcleo, la API son cuatro operaciones sobre un recurso de enlace: crear, leer, actualizar, eliminar. Creas un enlace enviando una URL de destino, y el servicio devuelve una URL corta que resuelve en otro lugar.

Algo que confunde a la gente: el host de la API y el host de redirección son distintos. La API de Elido vive en https://api.elido.app/v1, mientras que los propios enlaces cortos resuelven en un dominio de redirección como s.elido.me. Hablas con la API para gestionar enlaces; tus usuarios solo tocan el dominio de redirección. Mantener esos dos separados es lo que permite que la ruta de redirección se mantenga rápida mientras la API hace el trabajo más pesado.

Primero, autentícate

Cada solicitud real lleva un token bearer en el encabezado Authorization. Generas el token en los ajustes de tu espacio de trabajo, lo guardas como variable de entorno, y nunca lo pones en código del lado del cliente, porque cualquiera con el token puede crear enlaces en tu cuenta.

export ELIDO_TOKEN="your_token_here"

Ese es todo el modelo de autenticación: un encabezado, Authorization: Bearer $ELIDO_TOKEN, en cada llamada. Las APIs que se saltan esto por completo son convenientes para un script desechable, pero no hay cuenta detrás de los enlaces, así que no puedes listarlos, editarlos ni medirlos después.

Crea un enlace corto

Aquí está la misma llamada de creación en cuatro lenguajes. Cada una envía una URL de destino e imprime la URL corta de la respuesta.

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 respuesta es JSON:

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

JavaScript, usando el fetch integrado:

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 biblioteca estándar:

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
}

Añade campos opcionales al cuerpo según los necesites: un slug para una segunda parte personalizada, tags para organización, un domain para elegir un dominio personalizado de marca, o expires_at para un enlace que deja de funcionar después de una fecha.

Qué restringe realmente "gratis"

Aquí es donde vive la comparación honesta, porque "API gratuita" cubre dos cosas muy distintas.

Los endpoints sin registro y sin autenticación, los que acortan una URL con un único POST no autenticado, son genuinamente gratuitos y genuinamente limitados. Límites de tasa compartidos, sin cuenta, sin dominio de marca, sin analíticas, y sin promesa de que el servicio exista el próximo trimestre. Está bien para un script puntual, arriesgado para cualquier cosa que publiques.

Un nivel gratuito autenticado es el tipo más útil, y ahí las restricciones son predecibles. Las funciones más a menudo reservadas para planes de pago son los dominios personalizados de marca, el volumen alto de solicitudes, una retención de analíticas más larga y los endpoints masivos. En el plan gratuito de Elido la propia API está incluida, los enlaces resuelven y se rastrean, y los límites están delimitados por espacio de trabajo en lugar de compartidos con desconocidos. Para ver cómo se comparan las herramientas de pago en esto, Dub frente a Bitly cubre dos de las APIs más conocidas, y puedes empezar en el plan gratuito para probar la de Elido.

La regla general: si el enlace es desechable, una API sin autenticación está bien. Si lleva tu marca o necesitas medirlo, usa una autenticada con un dominio que controles.

Límites de tasa e idempotencia

El número que realmente te protege en producción no es el límite de tasa, es la idempotencia.

Cada solicitud que modifica datos acepta un encabezado Idempotency-Key. Envía una clave única con una llamada de creación, y si la solicitud agota el tiempo de espera y la reintentas con la misma clave, el servidor devuelve el resultado original en lugar de crear un segundo enlace. Esto es lo que hace segura una lógica de reintentos.

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

La idempotencia es una propiedad de la semántica de métodos HTTP en el RFC 9110, y cualquier API en la que confíes para la creación automatizada de enlaces debería admitirla. El tratamiento más profundo, qué códigos de estado reintentar y cómo pautar frente al límite, está en límites de tasa, reintentos e idempotencia en producción.

¿SDKs o HTTP directo?

No tienes que construir las solicitudes a mano. Elido publica SDKs generados a partir de su especificación OpenAPI para TypeScript, Python, Go y más, y la guía rápida de API y SDK explica cómo instalarlos y llamarlos.

Usa un SDK cuando quieras que los tipos, los reintentos y la paginación estén resueltos por ti. Usa HTTP directo, como los ejemplos de arriba, cuando quieras cero dependencias o estés llamando desde un lenguaje sin cliente oficial. Ambos llegan a la misma API REST; el SDK solo es una vía más ligera hacia ella.

Relacionado en el blog

• Guía rápida de API y SDK de acortador de URL
• Límites de tasa, reintentos e idempotencia en producción
• Cómo acortar una URL: enlaces gratuitos, de marca y masivos
• Dub frente a Bitly: precios, planes gratuitos y funciones