voltar

API.

Automatize tudo. Suba qualquer arquivo (incluindo .zip), crie arquivos de código e gere links de download programaticamente — sem tocar no site. Sem login, sem chave de API. É só chamar as rotas abaixo do seu bot, script ou pipeline.

BASE URL https://…

Rate limit

Todos os limites são por IP, numa janela de 60 segundos. VPN e usuários de qualquer país passam normalmente — só o volume por IP é limitado.

5 uploads / min
60 requests / min
até 2048 MB / arquivo
código até 20.000 linhas

Toda resposta traz estes headers pra o bot se auto-regular:

HeaderSignificado
X-RateLimit-Limitmáximo permitido na janela atual
X-RateLimit-Remainingquantas requisições ainda restam
X-RateLimit-Resetsegundos até a janela zerar
Retry-After(só no 429) segundos pra tentar de novo
Passou do limite? A rota devolve 429 com { "error": "...", "retryAfter": N }. O bot deve esperar retryAfter segundos e tentar de novo.

Endpoints

POST /create criar arquivo de código

Cria um arquivo de texto/código direto, sem chunking. Ideal pra bots que geram scripts, configs ou logs. Corpo em JSON.

CampoTipoDescrição
content reqstringo conteúdo do arquivo. Indentação e quebras de linha são preservadas.
namestringnome do arquivo, ex: main.py. Padrão: arquivo.
languagestringlinguagem p/ o highlight na página (python, javascript, etc.).
expirynumberhoras até expirar (0 = permanente, máx 720). Padrão: 24.

Resposta:

{ "fileId": "a1b2c3d4e5f6..." }
POST /upload/start inicia upload de arquivo

Passo 1 de 3 do upload de arquivo binário (qualquer tipo, incluindo .zip). Parâmetros via query string. Devolve um uploadId.

QueryTipoDescrição
size reqnumbertamanho total do arquivo em bytes.
name reqstringnome do arquivo (URL-encoded).
kindstringzip ativa a validação de zip não-vazio. Senão, file.
expirynumberhoras até expirar (0 = permanente, máx 720). Padrão: 24.

Resposta:

{ "uploadId": "..." }
POST /upload/chunk/:uploadId envia um pedaço

Passo 2. Envia um pedaço (chunk) do arquivo como corpo bruto (application/octet-stream). Repita pra cada chunk até enviar o arquivo inteiro. Chunks de ~5 MB funcionam bem.

QueryTipoDescrição
offset reqnumberposição em bytes onde este chunk começa no arquivo.

Corpo: os bytes crus do chunk. Resposta:

{ "ok": true }
POST /upload/finish/:uploadId finaliza e gera o link

Passo 3. Fecha o upload, valida o zip (se kind=zip), move tudo pro banco e devolve o fileId. O link final é /d/{fileId}.

Resposta:

{ "fileId": "a1b2c3d4e5f6..." }
Zip vazio ou arquivo .zip inválido devolve 400 aqui.
GET /code/:code resolve o Strcode (4 dígitos)

Todo upload gera um Strcode de 4 dígitos (ex: X7K2) — um atalho pro arquivo. Esta rota troca o code pelo fileId. O bot pode montar o link a partir daí: /d/{fileId}.

{ "fileId": "a1b2c3d4e5f6..." }
O fileId vem na resposta de /create e /upload/finish junto com o shortCode.
GET /info/:fileId metadados do arquivo

Retorna informações sem baixar o conteúdo.

{
  "size": 1048576,
  "name": "projeto.zip",
  "kind": "zip",
  "language": null,
  "expiry": 1730000000000,
  "createdAt": 1729990000000
}
GET /file/:fileId baixa o arquivo

Baixa o conteúdo bruto. Suporta Range (download parcial / retomável). Imagens e vídeos abrem inline; o resto vem como download.

GET /raw/:fileId texto puro (só arquivos de código)

Devolve o texto cru de um arquivo criado via /create. Útil pra bot ler o código de volta. Só funciona em arquivos pequenos de texto.

GET /api/limits consulta os limites atuais

Retorna os limites de rate e tamanho em JSON, pro bot se ajustar sozinho.

Códigos de status

200sucesso 400requisição inválida (ex: zip vazio, conteúdo vazio) 410arquivo expirado 413arquivo grande demais / passou de 20k linhas 429rate limit — veja o header Retry-After 503servidor ainda iniciando, tente em instantes

Exemplos de bot

Fluxo completo: subir um arquivo (funciona com .zip) e receber o link. Copia, cola e roda.

# pip install requests
import requests, os

BASE = "__BASE__"
path = "projeto.zip"          # qualquer arquivo, incl. .zip
size = os.path.getsize(path)
name = os.path.basename(path)
kind = "zip" if name.endswith(".zip") else "file"

# 1. inicia
r = requests.post(f"{BASE}/upload/start",
    params={"size": size, "name": name, "kind": kind, "expiry": 24})
uid = r.json()["uploadId"]

# 2. envia em chunks de 5 MB
CHUNK = 5 * 1024 * 1024
with open(path, "rb") as f:
    off = 0
    while (buf := f.read(CHUNK)):
        requests.post(f"{BASE}/upload/chunk/{uid}",
            params={"offset": off}, data=buf,
            headers={"Content-Type": "application/octet-stream"})
        off += len(buf)

# 3. finaliza
fid = requests.post(f"{BASE}/upload/finish/{uid}").json()["fileId"]
print(f"link: {BASE}/d/{fid}")
// Node 18+ (fetch nativo)
import fs from "fs";

const BASE = "__BASE__";
const path = "projeto.zip";
const data = fs.readFileSync(path);
const name = path.split("/").pop();
const kind = name.endsWith(".zip") ? "zip" : "file";

// 1. inicia
let q = new URLSearchParams({ size: data.length, name, kind, expiry: "24" });
const { uploadId } = await (await fetch(`${BASE}/upload/start?${q}`, { method:"POST" })).json();

// 2. chunks de 5 MB
const CHUNK = 5*1024*1024;
for (let off=0; off<data.length; off+=CHUNK) {
  const part = data.subarray(off, off+CHUNK);
  await fetch(`${BASE}/upload/chunk/${uploadId}?offset=${off}`, {
    method:"POST", headers:{"Content-Type":"application/octet-stream"}, body: part });
}

// 3. finaliza
const { fileId } = await (await fetch(`${BASE}/upload/finish/${uploadId}`, { method:"POST" })).json();
console.log(`link: ${BASE}/d/${fileId}`);
# criar arquivo de código (jeito mais simples)
curl -X POST "__BASE__/create" \
  -H "Content-Type: application/json" \
  -d '{"name":"oi.py","language":"python","content":"print(1)","expiry":24}'

# → {"fileId":"abc123..."}  →  link: __BASE__/d/abc123


# subir um arquivo pequeno (1 chunk só)
SIZE=$(stat -c%s projeto.zip)
UID=$(curl -s -X POST "__BASE__/upload/start?size=$SIZE&name=projeto.zip&kind=zip" | jq -r .uploadId)
curl -X POST "__BASE__/upload/chunk/$UID?offset=0" --data-binary @projeto.zip
curl -X POST "__BASE__/upload/finish/$UID"