API Gratuita de Encurtador de URL: Exemplos de Código Que Funcionam

Uma API gratuita de encurtador de URL permite criar links curtos a partir de código em vez de clicar num painel. Envie um pedido com um URL de destino, receba de volta um link curto que redireciona para lá. Este artigo tem exemplos executáveis em curl, JavaScript, Python, e Go contra a API do Elido, que está disponível no plano gratuito, mais a parte honesta que a maioria das listas salta: o que "gratuito" realmente limita.

Se nunca encurtou um link antes, como encurtar um URL cobre primeiro a versão manual. Tudo abaixo assume que quer fazê-lo programaticamente.

O Que Uma API de Encurtador Faz

No fundo, a API é quatro operações sobre um recurso de link: criar, ler, atualizar, apagar. Cria um link ao enviar um URL de destino, e o serviço devolve um URL curto que resolve para outro lado.

Uma coisa que confunde as pessoas: o host da API e o host de redirecionamento são diferentes. A API do Elido vive em https://api.elido.app/v1, enquanto os próprios links curtos resolvem num domínio de redirecionamento como s.elido.me. Fala com a API para gerir links; os seus utilizadores só alguma vez atingem o domínio de redirecionamento. Manter esses dois separados é o que permite que o caminho de redirecionamento se mantenha rápido enquanto a API faz o trabalho mais pesado.

Autentique Primeiro

Cada pedido real transporta um token bearer no cabeçalho Authorization. Gera o token nas definições do seu workspace, guarda-o como variável de ambiente, e nunca o coloca em código do lado do cliente, porque qualquer pessoa com o token pode criar links na sua conta.

export ELIDO_TOKEN="your_token_here"

Esse é todo o modelo de autenticação: um cabeçalho, Authorization: Bearer $ELIDO_TOKEN, em cada chamada. APIs que saltam isto completamente são convenientes para um script descartável, mas não há conta por trás dos links, pelo que não os pode listar, editar, ou medir mais tarde.

Crie um Link Curto

Aqui está a mesma chamada de criação em quatro linguagens. Cada uma envia um URL de destino e imprime o URL curto a partir da resposta.

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

A resposta é JSON:

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

JavaScript, usando o fetch incorporado:

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, com 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, com a biblioteca padrão:

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
}

Adicione campos opcionais ao corpo conforme precisar deles: um slug para uma segunda metade personalizada, tags para organização, um domain para escolher um domínio personalizado de marca, ou expires_at para um link que deixa de funcionar após uma data.

O Que "Gratuito" Realmente Limita

É aqui que vive a comparação honesta, porque "API gratuita" cobre duas coisas muito diferentes.

Os endpoints sem registo e sem autenticação, aqueles que encurtam um URL com um único POST não autenticado, são genuinamente gratuitos e genuinamente limitados. Limites de taxa partilhados, nenhuma conta, nenhum domínio de marca, nenhumas análises, e nenhuma promessa de que o serviço existirá no próximo trimestre. Bom para um script pontual, arriscado para qualquer coisa que lance ao público.

Um nível gratuito autenticado é o tipo mais útil, e aí a limitação é previsível. As funcionalidades mais frequentemente reservadas para planos pagos são domínios personalizados de marca, volume elevado de pedidos, retenção de análises mais longa, e endpoints em massa. No plano gratuito do Elido, a própria API está incluída, os links resolvem e são rastreados, e os limites são delimitados por workspace em vez de partilhados com estranhos. Para como as ferramentas pagas se comparam nisto, Dub vs Bitly cobre duas das APIs mais conhecidas, e pode começar no plano gratuito para experimentar a do Elido.

A regra geral: se o link é descartável, uma API sem autenticação serve. Se carrega a sua marca ou precisa de o medir, use uma autenticada com um domínio que controla.

Limites de Taxa e Idempotência

O número que realmente o protege em produção não é o limite de taxa, é a idempotência.

Cada pedido de alteração aceita um cabeçalho Idempotency-Key. Envie uma chave única com uma chamada de criação, e se o pedido expirar e repetir com a mesma chave, o servidor devolve o resultado original em vez de criar um segundo link. É isto que torna um ciclo de repetição seguro.

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

A idempotência é uma propriedade da semântica de métodos HTTP na RFC 9110, e qualquer API em que confie para criação automatizada de links deve suportá-la. O tratamento mais profundo, quais códigos de estado repetir e como ritmar contra o limite, está em limites de taxa, repetições, e idempotência em produção.

SDKs ou HTTP Puro?

Não tem de construir pedidos à mão. O Elido publica SDKs gerados a partir da sua especificação OpenAPI para TypeScript, Python, Go, e mais, e o guia rápido de API e SDK explica como instalá-los e chamá-los.

Use um SDK quando quiser tipos, repetições, e paginação tratados por si. Use HTTP puro, como os exemplos acima, quando quiser zero dependências ou estiver a chamar a partir de uma linguagem sem cliente oficial. Ambos atingem a mesma API REST; o SDK é apenas um caminho mais fino até lá.

Relacionado no Blog

• Guia rápido de API e SDK do encurtador de URL
• Limites de taxa, repetições, e idempotência em produção
• Como encurtar um URL: links gratuitos, de marca, e em massa
• Dub vs Bitly: preços, planos gratuitos, e funcionalidades