Documentação da API
Envie um arquivo uma vez, mande-o para os hosts de arquivos que você escolher e receba de volta um único link de compartilhamento — a partir do seu próprio código.
Atualizado em
Uma API REST versionada: envie um arquivo em partes, mande-o para os hosts que escolher, e todas as cópias ficam reunidas em uma página de compartilhamento com status ao vivo.
- URL base
- https://api.mirroruploadx.com/api/v1
- Autenticação
- x-api-key: mux_…
1Abra uma sessão
POST /
api/ v1/ upload-sessions filename + sizeBytes; receba sessionId e chunkSize
2Envie as partes
PATCH /
api/ v1/ upload-sessions/ {id}/ chunks bytes brutos, em ordem; a resposta que completa o arquivo traz fileId
3Distribua
POST /
api/ v1/ mirror-tasks/ start fileId + providerSlugs; depois consulte a tarefa
Crie uma chave na página Chaves de API. O passo a passo completo, com código, está em Enviar e distribuir.
Autenticação
Crie uma chave na página Chaves de API do seu painel. A chave completa (ela começa com mux_) é exibida só uma vez, então guarde-a na hora. Envie-a no cabeçalho x-api-key em todas as requisições; Authorization: Bearer mux_… é aceito da mesma forma, para clientes que só trabalham com bearer tokens.
As chaves têm escopo: uma chave só alcança os endpoints cobertos pelos seus escopos, e uma chamada com o escopo errado retorna 403 INSUFFICIENT_SCOPE com o escopo necessário na mensagem. Configurações da conta, gerenciamento de chaves e webhooks não podem ser acessados com uma chave de API de forma alguma (API_KEY_NOT_ALLOWED).
| Escopo | Alcança |
|---|---|
upload:write | Sessões de envio (criar, partes, concluir, cancelar), sua cota de envio, segurar ou alterar a distribuição automática de um envio (hold-distribution, distribution-intent), envios por URL remota, iniciar a distribuição |
file:read | Listar arquivos, detalhes de arquivos, status dos espelhos e das tarefas |
file:write | Configurações de compartilhamento de um arquivo |
file:delete | Excluir um arquivo e os espelhos dele |
Endpoints
Tudo o que uma chave de API pode alcançar, além dos endpoints públicos que não precisam de chave. Quando a coluna de escopo lista dois escopos, qualquer um deles basta. Os esquemas de requisição e resposta de cada um estão na referência da API.
| Método | Caminho | Escopo | O que faz |
|---|---|---|---|
| POST | / | upload:write | Abrir uma sessão de envio (opcionalmente com um plano de distribuição) |
| PATCH | / | upload:write | Enviar a próxima parte de bytes |
| HEAD | / | upload:write | Onde retomar: o cabeçalho Upload-Offset |
| GET | / | upload:writefile:read | Status da sessão: bytes recebidos, fileId, finalizable |
| GET | / | upload:writefile:read | Seus limites de envio, uso e sessões não concluídas |
| POST | / | upload:write | Concluir um envio cuja resposta final se perdeu (seguro repetir) |
| POST | / | upload:write | Impedir que uma distribuição adiada comece sozinha |
| PUT | / | upload:write | Substituir o plano de distribuição de um envio |
| DELETE | / | upload:write | Cancelar um envio não concluído e liberar a vaga dele |
| POST | / | upload:write | Buscar arquivos de URLs http(s) para a sua conta |
| POST | / | upload:write | Mandar um arquivo para os hosts que você escolher |
| GET | / | upload:writefile:read | Status da tarefa, cada host e o link de compartilhamento (shareTakenDown indica uma página removida) |
| GET | / | file:read | Listar seus arquivos (paginação por cursor, busca, filtros) |
| GET | / | file:read | Um arquivo: tamanho, checksum, tarefa, configurações de compartilhamento, estatísticas |
| GET | / | file:read | Todas as cópias de um arquivo: host, link, saúde, cliques |
| PATCH | / | file:write | Senha, expiração e visibilidade do compartilhamento |
| DELETE | / | file:delete | Excluir um arquivo e (por padrão) as cópias dele nos hosts |
| GET | / | nenhum (público) | Limites atuais: maior arquivo, hosts por arquivo, tetos de envio por URL |
| GET | / | nenhum (público) | O catálogo de hosts, com os slugs que você envia em providerSlugs |
| GET | / | nenhum (público) | Sucesso de envio medido por host |
| GET | / | nenhum (público) | Totais da plataforma nos últimos 30 dias: arquivos, espelhos no ar, taxa de sucesso |
Enviar um arquivo e distribuí-lo
- Abra uma sessão com
POST /api/v1/upload-sessions.filenameesizeBytes(o tamanho exato em bytes) são obrigatórios;mimeTypee umaidempotencyKeyUUID são opcionais — repetir uma requisição com a mesma chave retorna a sessão existente em vez de abrir uma segunda. A resposta trazdata.sessionId(nãoid) edata.chunkSize. - Envie os bytes com
PATCH /api/v1/upload-sessions/{id}/chunks: bytes brutos, content typeapplication/offset+octet-streame a posição inicial da parte no cabeçalhoupload-offset. As partes vão em ordem, ou atémaxChunksAheadpartes adiante; enviando em ordem, usedata.uploadedBytesde cada resposta como o próximo offset. Envie partes dechunkSizebytes; toda parte, exceto a última, deve ter pelo menos 5 MiB, e um envio pode ter no máximo 10 000 partes. A resposta que completa o arquivo trazdata.fileId. Para ganhar velocidade, você pode manter 2–3 partes do mesmo arquivo em trânsito. Envie a primeira parte sozinha; a resposta dela informa odata.maxChunksAheadreal (4 quando a primeira parte foi uma fatia inteira dechunkSize, 0 = só em ordem). Se a primeira parte foi uma fatia inteira dechunkSize, todas as partes seguintes também precisam ser (em ordem ou adiante): começam em um múltiplo dechunkSizee têm exatamentechunkSizebytes (a última: o restante do arquivo). Uma parte enviada à frente deuploadedBytesprecisa ser uma fatia assim e começar no máximodata.maxChunksAheadpartes adiante; caso contrário, recebe409 CHUNK_MISALIGNEDou409 CHUNK_OUT_OF_WINDOW.uploadedBytesconta só os bytes recebidos sem lacuna, e a parte que completar o arquivo, seja ela qual for, recebe a resposta comfileId. Reenviar uma parte que já chegou é um sucesso inofensivo. - Distribua com
POST /api/v1/mirror-tasks/start:fileIdeproviderSlugssão obrigatórios (os slugs vêm deGET /api/v1/providers). Opcionais:minSuccess(padrão 1 — quantos hosts precisam aceitar o arquivo para a tarefa não falhar; ela só ficacompletedquando todos os hosts também o aceitaram, caso contráriopartially_completed. Hosts que recusam este tipo de arquivo não são contados),sharePassword,expiresInDaysouexpiresAt. A resposta trazuploadJobId,taskCount,shareSlug,alreadyStartedeskipped[]— um host que não pode aceitar este arquivo é ignorado, não conta como falha, então leiaskipped[](os motivos estão listados abaixo). No momento, um arquivo pode ir para no máximo 50 hosts. - Acompanhe a conclusão com
GET /api/v1/mirror-tasks/{uploadJobId}a cada poucos segundos, atédata.terminalsertrue. A resposta lista cada host emtasks[](providerSlug,status,mirrorUrl,errorCode) e o link de compartilhamento emdata.shareUrl.data.shareTakenDownétruequando essa página de compartilhamento foi removida e não abre mais.
O maior arquivo aceito no momento é de 5,00 GB.
bash, requer jq
set -euo pipefail
API=https://api.mirroruploadx.com
FILE=clip.mp4
SIZE=$(wc -c < "$FILE" | tr -d ' ')
# 1. Open an upload session
SESSION_JSON=$(curl -sS --fail-with-body -X POST "$API/api/v1/upload-sessions" \
-H "x-api-key: $MUX_API_KEY" -H "content-type: application/json" \
-d '{"filename":"clip.mp4","sizeBytes":'"$SIZE"',"mimeType":"video/mp4"}')
SESSION=$(echo "$SESSION_JSON" | jq -r .data.sessionId)
CHUNK=$(echo "$SESSION_JSON" | jq -r .data.chunkSize)
# 2. Send the bytes in order, one chunk per request
OFFSET=0
while [ "$OFFSET" -lt "$SIZE" ]; do
dd if="$FILE" of=part.bin bs="$CHUNK" skip=$((OFFSET / CHUNK)) count=1 status=none
REPLY=$(curl -sS --fail-with-body -X PATCH "$API/api/v1/upload-sessions/$SESSION/chunks" \
-H "x-api-key: $MUX_API_KEY" \
-H "upload-offset: $OFFSET" \
-H "content-type: application/offset+octet-stream" \
--data-binary @part.bin)
OFFSET=$(echo "$REPLY" | jq -r .data.uploadedBytes)
done
FILE_ID=$(echo "$REPLY" | jq -r .data.fileId)
# 3. Distribute to the hosts you pick
JOB=$(curl -sS --fail-with-body -X POST "$API/api/v1/mirror-tasks/start" \
-H "x-api-key: $MUX_API_KEY" -H "content-type: application/json" \
-d '{"fileId":"'"$FILE_ID"'","providerSlugs":["gofile","pixeldrain"],"minSuccess":1}' \
| jq -r .data.uploadJobId)
# 4. Poll until the job is terminal, then print the share link
until curl -sS --fail-with-body "$API/api/v1/mirror-tasks/$JOB" \
-H "x-api-key: $MUX_API_KEY" > job.json \
&& [ "$(jq -r .data.terminal job.json)" = "true" ]; do
sleep 5
done
jq -r '.data.status, .data.shareUrl' job.jsonrequests
import os, time, requests
API = "https://api.mirroruploadx.com"
H = {"x-api-key": os.environ["MUX_API_KEY"]}
def call(method, path, headers=None, **kw):
r = requests.request(method, API + path, headers={**H, **(headers or {})}, timeout=120, **kw)
body = r.json()
if not body.get("success"):
err = body["error"]
raise RuntimeError(f'{r.status_code} {err["code"]}: {err["message"]}')
return body["data"]
path = "clip.mp4"
size = os.path.getsize(path)
# 1. Open an upload session
s = call("POST", "/api/v1/upload-sessions",
json={"filename": os.path.basename(path), "sizeBytes": size, "mimeType": "video/mp4"})
session, chunk = s["sessionId"], s["chunkSize"]
# 2. Send the bytes in order; the reply says where to continue
offset, last = 0, None
with open(path, "rb") as f:
while offset < size:
f.seek(offset)
last = call("PATCH", f"/api/v1/upload-sessions/{session}/chunks",
headers={"upload-offset": str(offset),
"content-type": "application/offset+octet-stream"},
data=f.read(chunk))
offset = last["uploadedBytes"]
file_id = last["fileId"]
# 3. Distribute
job = call("POST", "/api/v1/mirror-tasks/start",
json={"fileId": file_id, "providerSlugs": ["gofile", "pixeldrain"], "minSuccess": 1})
for sk in job["skipped"]:
print("skipped", sk["slug"], sk["reason"], sk["detail"])
# 4. Poll until terminal
job_id = job["uploadJobId"]
while True:
st = call("GET", f"/api/v1/mirror-tasks/{job_id}")
if st["terminal"]:
break
time.sleep(5)
print(st["status"], st["shareUrl"])
for t in st["tasks"]:
print(t["providerSlug"], t["status"], t["mirrorUrl"] or t["errorCode"])Node.js 18+, fetch
// Node.js 18+ (global fetch), ES module
import { open, stat } from 'node:fs/promises';
import { basename } from 'node:path';
const API = 'https://api.mirroruploadx.com';
const KEY = process.env.MUX_API_KEY;
async function call(method, path, { json, body, headers = {} } = {}) {
const res = await fetch(API + path, {
method,
headers: { 'x-api-key': KEY, ...(json ? { 'content-type': 'application/json' } : {}), ...headers },
body: json ? JSON.stringify(json) : body,
});
const out = await res.json();
if (!out.success) throw new Error(`${res.status} ${out.error.code}: ${out.error.message}`);
return out.data;
}
const path = 'clip.mp4';
const { size } = await stat(path);
// 1. Open an upload session
const { sessionId, chunkSize } = await call('POST', '/api/v1/upload-sessions', {
json: { filename: basename(path), sizeBytes: size, mimeType: 'video/mp4' },
});
// 2. Send the bytes in order; the reply says where to continue
const fh = await open(path);
let offset = 0;
let last;
while (offset < size) {
const buf = Buffer.alloc(Math.min(chunkSize, size - offset));
await fh.read(buf, 0, buf.length, offset);
last = await call('PATCH', `/api/v1/upload-sessions/${sessionId}/chunks`, {
headers: { 'upload-offset': String(offset), 'content-type': 'application/offset+octet-stream' },
body: buf,
});
offset = last.uploadedBytes;
}
await fh.close();
// 3. Distribute
const job = await call('POST', '/api/v1/mirror-tasks/start', {
json: { fileId: last.fileId, providerSlugs: ['gofile', 'pixeldrain'], minSuccess: 1 },
});
for (const s of job.skipped) console.log('skipped', s.slug, s.reason, s.detail);
// 4. Poll until terminal
let st;
do {
await new Promise((r) => setTimeout(r, 5000));
st = await call('GET', `/api/v1/mirror-tasks/${job.uploadJobId}`);
} while (!st.terminal);
console.log(st.status, st.shareUrl);
for (const t of st.tasks) console.log(t.providerSlug, t.status, t.mirrorUrl ?? t.errorCode);PHP 8.1+, ext-curl
<?php
// PHP 8.1+, built-in ext-curl and ext-json only (no Composer)
declare(strict_types=1);
const API = 'https://api.mirroruploadx.com';
function call(string $method, string $path, ?array $json = null, ?string $body = null, array $headers = []): array
{
$h = ['x-api-key: ' . getenv('MUX_API_KEY'), 'expect:']; // no 100-continue round trip
if ($json !== null) {
$h[] = 'content-type: application/json';
$body = json_encode($json, JSON_THROW_ON_ERROR);
}
foreach ($headers as $k => $v) {
$h[] = "$k: $v";
}
$ch = curl_init(API . $path);
curl_setopt_array($ch, [
CURLOPT_CUSTOMREQUEST => $method,
CURLOPT_HTTPHEADER => $h,
CURLOPT_RETURNTRANSFER => true,
// no total cap (a large part can take minutes); give up on a stalled transfer instead
CURLOPT_TIMEOUT => 0,
CURLOPT_CONNECTTIMEOUT => 15,
CURLOPT_LOW_SPEED_LIMIT => 1024, // bytes per second
CURLOPT_LOW_SPEED_TIME => 60,
]);
if ($body !== null) {
curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
}
$raw = curl_exec($ch);
if ($raw === false) {
throw new RuntimeException('network error: ' . curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
$out = json_decode($raw, true, 512, JSON_THROW_ON_ERROR);
if (empty($out['success'])) {
$err = $out['error'];
throw new RuntimeException("$status {$err['code']}: {$err['message']}");
}
return $out['data'];
}
$path = 'clip.mp4';
$size = filesize($path);
// 1. Open an upload session
$s = call('POST', '/api/v1/upload-sessions',
json: ['filename' => basename($path), 'sizeBytes' => $size, 'mimeType' => 'video/mp4']);
$session = $s['sessionId'];
$chunk = $s['chunkSize'];
// 2. Send the bytes in order, one chunk in memory at a time; the reply says where to continue
$fh = fopen($path, 'rb');
$offset = 0;
$last = null;
while ($offset < $size) {
fseek($fh, $offset);
$last = call('PATCH', "/api/v1/upload-sessions/$session/chunks", body: fread($fh, $chunk), headers: [
'upload-offset' => (string) $offset,
'content-type' => 'application/offset+octet-stream',
]);
$offset = $last['uploadedBytes'];
}
fclose($fh);
$fileId = $last['fileId'];
// 3. Distribute
$job = call('POST', '/api/v1/mirror-tasks/start',
json: ['fileId' => $fileId, 'providerSlugs' => ['gofile', 'pixeldrain'], 'minSuccess' => 1]);
foreach ($job['skipped'] as $sk) {
echo "skipped {$sk['slug']} {$sk['reason']} {$sk['detail']}\n";
}
// 4. Poll until terminal
$jobId = $job['uploadJobId'];
do {
sleep(5);
$st = call('GET', "/api/v1/mirror-tasks/$jobId");
} while (!$st['terminal']);
echo "{$st['status']} {$st['shareUrl']}\n";
foreach ($st['tasks'] as $t) {
echo $t['providerSlug'], ' ', $t['status'], ' ', $t['mirrorUrl'] ?? $t['errorCode'], "\n";
}Exemplos de respostas
Abrir uma sessão responde 201. Cada parte, exceto a última, responde { uploadedBytes, completed: false, expiresAt }; a última traz o arquivo. distribution só aparece quando você passou um plano ao abrir a sessão (veja abaixo).
{
"success": true,
"data": {
"sessionId": "…",
"uploadedBytes": 0,
"chunkSize": 8388608,
"maxChunksAhead": 0
}
}{
"success": true,
"data": {
"uploadedBytes": 10485760,
"completed": true,
"fileId": "…",
"scan": "skipped",
"distributable": true,
"distribution": {
"started": true,
"uploadJobId": "…",
"taskCount": 2,
"shareSlug": "…",
"skipped": []
}
}
}{
"success": true,
"data": {
"uploadJobId": "…",
"taskCount": 2,
"shareSlug": "…",
"skipped": [],
"alreadyStarted": false
}
}{
"success": true,
"data": {
"uploadJobId": "…",
"status": "completed",
"terminal": true,
"shareSlug": "…",
"shareUrl": "https://mirroruploadx.com/f/…",
"shareTakenDown": false,
"minSuccess": 1,
"scan": "skipped",
"tasks": [
{
"provider": "Gofile",
"providerSlug": "gofile",
"status": "succeeded",
"attempts": 1,
"errorCode": null,
"viaOwnAccount": false,
"errorMessage": null,
"mirrorUrl": "https://gofile.io/d/…",
"mirrorHidden": false
},
{
"provider": "Pixeldrain",
"providerSlug": "pixeldrain",
"status": "succeeded",
"attempts": 1,
"errorCode": null,
"viaOwnAccount": false,
"errorMessage": null,
"mirrorUrl": "https://pixeldrain.com/u/…",
"mirrorHidden": false
}
]
}
}Um primeiro start bem-sucedido responde 202; chamá-lo de novo para uma tarefa que já está em andamento responde 200 com alreadyStarted: true. Quando o link de um host é mantido privado por política, mirrorUrl é null e mirrorHidden é true — a página de compartilhamento ainda o lista.
Pule a segunda chamada
Passe distribution ao abrir a sessão e o servidor começa a distribuir assim que o arquivo estiver completo. Confira data.distribution na resposta que completa o arquivo: started: true significa que a tarefa está na fila (uploadJobId, shareSlug). Com started: false e deferred: true, nada foi colocado na fila ainda, de propósito — veja abaixo. Com started: false e sem deferred, o envio deu certo, mas a distribuição não pôde começar (error diz por quê): chame POST /api/v1/mirror-tasks/start com o fileId. Um error junto com deferred: true significa uma falha temporária (por exemplo, todos os hosts estão ocupados ou em manutenção): não chame start nem envie o arquivo de novo — o próprio servidor vai tentar iniciar a distribuição de novo a partir de autoStartAt (até 5 tentativas). Chame hold-distribution para impedir isso.
curl -sS -X POST "https://api.mirroruploadx.com/api/v1/upload-sessions" \
-H "x-api-key: $MUX_API_KEY" -H "content-type: application/json" \
-d '{
"filename": "clip.mp4",
"sizeBytes": 10485760,
"mimeType": "video/mp4",
"distribution": { "providerSlugs": ["gofile", "pixeldrain"], "minSuccess": 1 }
}'
# The reply to the final chunk then carries data.distribution:
# { "started": true, "uploadJobId": "…", "taskCount": 2, "shareSlug": "…", "skipped": [] }
# or { "started": false, "error": { "code": "…", "message": "…" } }Adicione deferred: true a distribution para ter um período de carência: a resposta final é { started: false, deferred: true, autoStartAt } e o próprio servidor inicia a distribuição em autoStartAt (cerca de 2 minutos depois), a menos que você chame start antes. Para impedir o início automático, chame POST /api/v1/upload-sessions/{id}/hold-distribution (sem corpo; autoStartAt passa a ser null e você mesmo inicia). Para alterar o plano, chame PUT /api/v1/upload-sessions/{id}/distribution-intent com os mesmos campos de distribution (providerSlugs, minSuccess, expiresInDays, sharePassword): isso substitui o plano e remove uma retenção, e, se o envio já terminou, o início automático passa para pelo menos 2 minutos após a chamada. Se a distribuição já começou, ambos respondem 200 e distribution-intent informa alreadyStarted: true.
Inicie em até 30 minutos. Quando um envio termina e nenhuma distribuição é iniciada, nossa cópia do arquivo é removida após 30 minutos (com um plano de distribuição ainda aguardando hosts ficarem disponíveis, após no máximo 72 horas; envios por URL remota não são afetados). Depois disso, start e distribution-intent respondem 409 SOURCE_GONE e o arquivo precisa ser enviado de novo.
Se a resposta final se perder
Chame GET /api/v1/upload-sessions/{id}: um fileId significa que o arquivo existe; finalizable: true significa que todos os bytes chegaram e que POST /api/v1/upload-sessions/{id}/complete o conclui. Essa chamada é segura para repetir e nunca cria um segundo arquivo. Um offset divergente recebe 409 CHUNK_OFFSET_CONFLICT — envie HEAD na sessão e retome a partir do cabeçalho Upload-Offset dela. Chamar start de novo para uma tarefa em andamento não é erro: você recebe 200 com alreadyStarted: true.
Enviar a partir de uma URL
POST /api/v1/remote-uploads recebe { "urls": [...] } e busca cada arquivo para você (escopo upload:write). Só links http e https são buscados, endereços de redes privadas são recusados e só um número limitado de redirecionamentos é seguido. Uma requisição leva no máximo 10 URLs (informado por GET /api/v1/platform); divida listas maiores.
O limite de tamanho por arquivo depende da origem. Quando ela informa o tamanho do arquivo, cada arquivo pode ter até 5,00 GB (limits.remoteUploadPassthroughMaxBytes); quando não informa, até 100,0 MB (limits.remoteUploadMaxBytes). O nome do arquivo vem do cabeçalho Content-Disposition da origem, quando ela o envia; um nome sem extensão recebe uma com base no tipo do arquivo.
A requisição aguarda enquanto os arquivos são baixados. Se a conexão cair antes, o arquivo ainda chega à sua conta — encontre-o com GET /api/v1/files. Cada fileId é então distribuído com POST /api/v1/mirror-tasks/start, como acima.
Quando o armazenamento temporário está cheio, a requisição inteira recebe 503 TEMPORARILY_UNAVAILABLE com details.reason: "staging_full" e um cabeçalho Retry-After. Se só uma URL não couber, essa entrada em results[] tem ok: false e o mesmo código; um resultado por URL não tem cabeçalho, então a espera em segundos fica em details.retryAfter.
curl -sS -X POST "https://api.mirroruploadx.com/api/v1/remote-uploads" \
-H "x-api-key: $MUX_API_KEY" -H "content-type: application/json" \
-d '{"urls":["https://example.com/files/archive.zip"]}'
# One result per URL, in order. A failed URL does not fail the batch:
# {"success":true,"data":{"results":[
# {"url":"https://example.com/files/archive.zip","ok":true,
# "fileId":"…","scan":…,"distributable":true}
# ]}}
# or {"url":"…","ok":false,"code":"REMOTE_TOO_LARGE","error":"…"}
#
# Then distribute each fileId with POST /api/v1/mirror-tasks/start.PHP 8.1+, ext-curl
<?php
// PHP 8.1+, built-in ext-curl and ext-json only (no Composer)
$ch = curl_init('https://api.mirroruploadx.com/api/v1/remote-uploads');
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_HTTPHEADER => ['x-api-key: ' . getenv('MUX_API_KEY'), 'content-type: application/json'],
CURLOPT_POSTFIELDS => json_encode(['urls' => ['https://example.com/files/archive.zip']], JSON_THROW_ON_ERROR),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 0, // the request waits while the files download
]);
$raw = curl_exec($ch);
if ($raw === false) {
throw new RuntimeException('network error: ' . curl_error($ch));
}
$out = json_decode($raw, true, 512, JSON_THROW_ON_ERROR);
if (empty($out['success'])) {
throw new RuntimeException("{$out['error']['code']}: {$out['error']['message']}");
}
// One result per URL, in order. A failed URL does not fail the batch.
foreach ($out['data']['results'] as $r) {
echo $r['ok']
? "{$r['url']} -> {$r['fileId']}\n"
: "{$r['url']} failed: {$r['code']} {$r['error']}\n";
}
// Then distribute each fileId with POST /api/v1/mirror-tasks/start.Gerenciar arquivos
Seus arquivos ficam na sua conta depois do envio. Liste-os com GET /api/v1/files (limit até 100; passe o nextCursor da resposta como cursor para a próxima página, q busca pelo nome). GET /api/v1/files/{id} retorna um arquivo com a tarefa, as configurações de compartilhamento e as estatísticas de visualização; GET /api/v1/files/{id}/mirrors lista cada cópia com o link, a saúde e os cliques.
PATCH /api/v1/files/{id}/share (escopo file:write) altera a página de compartilhamento: password (4–128 caracteres, null remove — ela nunca é retornada, só passwordProtected), expiresAt (data ISO, null para sem expiração), visibility e hideDownloadCount. Envie só os campos que quer alterar. DELETE /api/v1/files/{id} (escopo file:delete) remove o arquivo e coloca na fila a exclusão das cópias dele nos hosts; adicione ?keepMirrors=true para mantê-las. Alguns hosts não suportam exclusão, então uma cópia pode continuar lá.
bash, requer jq; defina FILE_ID
API=https://api.mirroruploadx.com
H="x-api-key: $MUX_API_KEY"
# List your files, newest first (20 per page; pass ?cursor=<nextCursor> for more)
curl -sS "$API/api/v1/files?limit=20" -H "$H" | jq '.data.items[] | {id, name, mirrorCount, shareSlug}'
# One file, then every copy of it
curl -sS "$API/api/v1/files/$FILE_ID" -H "$H"
curl -sS "$API/api/v1/files/$FILE_ID/mirrors" -H "$H" | jq '.data.mirrors[] | {providerSlug, status, url}'
# Share settings: a password and an expiry date (null removes either)
curl -sS -X PATCH "$API/api/v1/files/$FILE_ID/share" -H "$H" -H "content-type: application/json" \
-d '{"password":"correct-horse","expiresAt":"2026-12-31T23:59:59Z"}'
# Delete the file and its copies on hosts (?keepMirrors=true keeps the copies)
curl -sS -X DELETE "$API/api/v1/files/$FILE_ID" -H "$H"requests; defina FILE_ID
import os, requests
API = "https://api.mirroruploadx.com"
H = {"x-api-key": os.environ["MUX_API_KEY"]}
file_id = os.environ["FILE_ID"]
def call(method, path, **kw):
body = requests.request(method, API + path, headers=H, timeout=60, **kw).json()
if not body.get("success"):
raise RuntimeError(f'{body["error"]["code"]}: {body["error"]["message"]}')
return body["data"]
# List your files, page by page
cursor = None
while True:
page = call("GET", "/api/v1/files", params={"limit": 100, **({"cursor": cursor} if cursor else {})})
for f in page["items"]:
print(f["id"], f["name"], f"{f['mirrorCount']}/{f['mirrorTotal']} mirrors")
cursor = page["nextCursor"]
if not cursor:
break
# One file, then every copy of it
print(call("GET", f"/api/v1/files/{file_id}")["share"])
for m in call("GET", f"/api/v1/files/{file_id}/mirrors")["mirrors"]:
print(m["providerSlug"], m["status"], m["url"])
# Share settings: a password and an expiry date (None removes either)
print(call("PATCH", f"/api/v1/files/{file_id}/share",
json={"password": "correct-horse", "expiresAt": "2026-12-31T23:59:59Z"}))
# Delete the file and its copies on hosts
print(call("DELETE", f"/api/v1/files/{file_id}")["note"])Node.js 18+, módulo ES; defina FILE_ID
const API = 'https://api.mirroruploadx.com';
const KEY = process.env.MUX_API_KEY;
const fileId = process.env.FILE_ID;
async function call(method, path, json) {
const res = await fetch(API + path, {
method,
headers: { 'x-api-key': KEY, ...(json ? { 'content-type': 'application/json' } : {}) },
body: json ? JSON.stringify(json) : undefined,
});
const out = await res.json();
if (!out.success) throw new Error(`${res.status} ${out.error.code}: ${out.error.message}`);
return out.data;
}
// List your files, page by page
let cursor = null;
do {
const page = await call('GET', `/api/v1/files?limit=100${cursor ? `&cursor=${cursor}` : ''}`);
for (const f of page.items) console.log(f.id, f.name, `${f.mirrorCount}/${f.mirrorTotal} mirrors`);
cursor = page.nextCursor;
} while (cursor);
// One file, then every copy of it
console.log((await call('GET', `/api/v1/files/${fileId}`)).share);
for (const m of (await call('GET', `/api/v1/files/${fileId}/mirrors`)).mirrors) {
console.log(m.providerSlug, m.status, m.url);
}
// Share settings: a password and an expiry date (null removes either)
console.log(await call('PATCH', `/api/v1/files/${fileId}/share`, {
password: 'correct-horse',
expiresAt: '2026-12-31T23:59:59Z',
}));
// Delete the file and its copies on hosts
console.log((await call('DELETE', `/api/v1/files/${fileId}`)).note);PHP 8.1+, ext-curl; defina FILE_ID
<?php
// PHP 8.1+, built-in ext-curl and ext-json only (no Composer)
declare(strict_types=1);
const API = 'https://api.mirroruploadx.com';
$fileId = getenv('FILE_ID');
function call(string $method, string $path, ?array $json = null, ?string $body = null, array $headers = []): array
{
$h = ['x-api-key: ' . getenv('MUX_API_KEY'), 'expect:']; // no 100-continue round trip
if ($json !== null) {
$h[] = 'content-type: application/json';
$body = json_encode($json, JSON_THROW_ON_ERROR);
}
foreach ($headers as $k => $v) {
$h[] = "$k: $v";
}
$ch = curl_init(API . $path);
curl_setopt_array($ch, [
CURLOPT_CUSTOMREQUEST => $method,
CURLOPT_HTTPHEADER => $h,
CURLOPT_RETURNTRANSFER => true,
// no total cap (a large part can take minutes); give up on a stalled transfer instead
CURLOPT_TIMEOUT => 0,
CURLOPT_CONNECTTIMEOUT => 15,
CURLOPT_LOW_SPEED_LIMIT => 1024, // bytes per second
CURLOPT_LOW_SPEED_TIME => 60,
]);
if ($body !== null) {
curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
}
$raw = curl_exec($ch);
if ($raw === false) {
throw new RuntimeException('network error: ' . curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
$out = json_decode($raw, true, 512, JSON_THROW_ON_ERROR);
if (empty($out['success'])) {
$err = $out['error'];
throw new RuntimeException("$status {$err['code']}: {$err['message']}");
}
return $out['data'];
}
// List your files, page by page (http_build_query drops a null cursor)
$cursor = null;
do {
$page = call('GET', '/api/v1/files?' . http_build_query(['limit' => 100, 'cursor' => $cursor]));
foreach ($page['items'] as $f) {
echo "{$f['id']} {$f['name']} {$f['mirrorCount']}/{$f['mirrorTotal']} mirrors\n";
}
$cursor = $page['nextCursor'];
} while ($cursor);
// One file, then every copy of it
print_r(call('GET', "/api/v1/files/$fileId")['share']);
foreach (call('GET', "/api/v1/files/$fileId/mirrors")['mirrors'] as $m) {
echo "{$m['providerSlug']} {$m['status']} {$m['url']}\n";
}
// Share settings: a password and an expiry date (null removes either)
print_r(call('PATCH', "/api/v1/files/$fileId/share",
json: ['password' => 'correct-horse', 'expiresAt' => '2026-12-31T23:59:59Z']));
// Delete the file and its copies on hosts
echo call('DELETE', "/api/v1/files/$fileId")['note'], "\n";{
"success": true,
"data": {
"stagingDeleted": true,
"mirrorsQueued": true,
"mirrorsPurgeDeferred": false,
"note": "File removed. Copies on providers are being deleted; some may remain on providers that do not support deletion."
}
}Webhooks
Adicione um endpoint na página Webhooks. A URL deve usar https://; o segredo de assinatura dela (whsec_…) é exibido uma vez, na criação. Um endpoint sem eventos selecionados recebe todos eles.
| Evento | Quando |
|---|---|
upload.completed | Todos os hosts aceitaram o arquivo, e pelo menos minSuccess aceitaram — hosts que recusaram este arquivo (rejected) ou foram cancelados não são contados |
upload.partially_completed | Pelo menos minSuccess hosts aceitaram o arquivo, mas pelo menos um outro host falhou |
upload.failed | Menos de minSuccess hosts aceitaram o arquivo (minSuccess 0 conta como 1) |
upload.quarantined | A verificação de malware sinalizou o arquivo (só quando a verificação está ativada) |
provider.upload_succeeded | Um host aceitou o arquivo — enviado uma vez por host |
provider.upload_failed | Um host desistiu do arquivo — enviado uma vez por host |
webhook.test | Você clicou em Testar na página Webhooks |
Cada entrega é um POST com corpo JSON e os cabeçalhos X-MUX-Event e X-MUX-Signature. Qualquer resposta 2xx em até 10 segundos conta como entregue; redirecionamentos não são seguidos. Uma entrega com falha (erro de rede, tempo esgotado, 408, 425, 429 ou 5xx) é repetida após 1, 5 e 30 minutos com o mesmo corpo; outros 4xx e redirecionamentos não. Cada tentativa traz X-MUX-Delivery-Attempt (1–4) e uma assinatura nova, então elimine duplicatas pelo corpo. A ordem de entrega não é garantida (um evento repetido pode chegar depois de um mais novo); compare data e createdAt antes de agir. Use GET /api/v1/mirror-tasks/{uploadJobId} para se atualizar. Após 15 entregas seguidas cuja última tentativa falhou, ou uma hora de falhas sem nenhum sucesso, o endpoint é pausado; reativá-lo zera a contagem. Uma entrega webhook.test (o botão Testar) é enviada uma vez, com X-MUX-Delivery-Attempt: 1, e nunca é repetida.
{
"event": "provider.upload_succeeded",
"createdAt": "2026-09-25T12:00:00.000Z",
"data": {
"uploadJobId": "…",
"fileId": "…",
"provider": "gofile",
"providerName": "Gofile",
"status": "succeeded",
"mirrorUrl": "https://…"
}
}Os eventos upload.* trazem uploadJobId, fileId e status; provider.upload_failed traz errorCode em vez de mirrorUrl.
Verificar a assinatura
O cabeçalho tem o formato t=1727265600,v1=5f2b…: t é o momento da assinatura em segundos Unix, v1 é o HMAC-SHA256 em hexadecimal de <t>.<raw body>, com o segredo do seu endpoint como chave. Calcule o hash dos bytes brutos exatamente como recebidos, compare em tempo constante e rejeite timestamps com mais de 5 minutos.
Express
import express from 'express';
import { createHmac, timingSafeEqual } from 'node:crypto';
function verify(rawBody, header, secret, toleranceSec = 300) {
const parts = Object.fromEntries(
header.split(',').map((kv) => {
const i = kv.indexOf('=');
return [kv.slice(0, i).trim(), kv.slice(i + 1).trim()];
}),
);
const t = Number(parts.t);
if (!Number.isFinite(t) || !parts.v1) return false;
if (Math.abs(Date.now() / 1000 - t) > toleranceSec) return false; // too old: replay
const expected = createHmac('sha256', secret).update(`${parts.t}.`).update(rawBody).digest();
const got = Buffer.from(parts.v1, 'hex');
return got.length === expected.length && timingSafeEqual(got, expected);
}
const app = express();
// Raw bytes, not parsed JSON: the signature covers the body exactly as sent.
app.post('/hooks/mirroruploadx', express.raw({ type: 'application/json' }), (req, res) => {
if (!verify(req.body, req.get('x-mux-signature') ?? '', process.env.MUX_WEBHOOK_SECRET)) {
return res.sendStatus(401);
}
const { event, data } = JSON.parse(req.body);
console.log(event, data.uploadJobId);
res.sendStatus(204); // any 2xx counts as delivered
});
app.listen(3000);Flask
import hashlib, hmac, os, time
from flask import Flask, abort, request
def verify(raw_body: bytes, header: str, secret: str, tolerance: int = 300) -> bool:
parts = dict(kv.strip().split("=", 1) for kv in header.split(",") if "=" in kv)
t, v1 = parts.get("t", ""), parts.get("v1", "")
if not t.isdigit() or not v1 or abs(time.time() - int(t)) > tolerance:
return False
expected = hmac.new(secret.encode(), t.encode() + b"." + raw_body, hashlib.sha256).hexdigest()
return hmac.compare_digest(expected, v1)
app = Flask(__name__)
@app.post("/hooks/mirroruploadx")
def hook():
# get_data(): the raw bytes, exactly as signed
if not verify(request.get_data(), request.headers.get("X-MUX-Signature", ""),
os.environ["MUX_WEBHOOK_SECRET"]):
abort(401)
payload = request.get_json()
print(payload["event"], payload["data"].get("uploadJobId"))
return "", 204 # any 2xx counts as deliveredPHP 8.1+ puro
<?php
// Plain PHP 8.1+ endpoint, e.g. public/hooks/mirroruploadx.php
declare(strict_types=1);
function verify(string $rawBody, string $header, string $secret, int $tolerance = 300): bool
{
$parts = [];
foreach (explode(',', $header) as $kv) {
[$k, $v] = array_pad(explode('=', $kv, 2), 2, '');
$parts[trim($k)] = trim($v);
}
$t = $parts['t'] ?? '';
$v1 = $parts['v1'] ?? '';
if (!ctype_digit($t) || $v1 === '' || abs(time() - (int) $t) > $tolerance) {
return false; // malformed, or too old: replay
}
$expected = hash_hmac('sha256', "$t.$rawBody", $secret);
return hash_equals($expected, $v1);
}
// php://input: the raw bytes, exactly as signed (not $_POST, not re-encoded JSON)
$raw = file_get_contents('php://input');
if (!verify($raw, $_SERVER['HTTP_X_MUX_SIGNATURE'] ?? '', (string) getenv('MUX_WEBHOOK_SECRET'))) {
http_response_code(401);
exit;
}
$payload = json_decode($raw, true, 512, JSON_THROW_ON_ERROR);
error_log($payload['event'] . ' ' . ($payload['data']['uploadJobId'] ?? ''));
http_response_code(204); // any 2xx counts as deliveredLimites de requisições
Os limites são contados por chave de API, não por endereço IP. Toda resposta de um endpoint limitado traz X-RateLimit-Limit, X-RateLimit-Remaining e X-RateLimit-Reset (segundos epoch). Ultrapassar o limite retorna 429 RATE_LIMITED com um cabeçalho Retry-After — aguarde esse número de segundos. O envio de partes tem uma cota ampla; os limites estreitos ficam na abertura de sessões e no início de distribuições.
| Grupo | Endpoints | Por chave | Janela |
|---|---|---|---|
| Iniciar envios | POST /POST /DELETE / | 60 | 1 minuto |
| Enviar partes | PATCH / | 600 | 1 minuto |
| Consultar o progresso | GET /HEAD /GET /GET / | 600 | 1 minuto |
| Configurações de distribuição de um envio | POST /PUT / | 300 | 1 minuto |
| Iniciar a distribuição | POST / | 30 | 1 minuto |
| Envios remotos (URL) | POST / | 20 | 10 minutos |
| Ler arquivos | GET /GET /GET / | 300 | 1 minuto |
| Alterar arquivos | PATCH /DELETE / | 60 | 1 minuto |
| Catálogo público | GET /GET /GET /GET / | 300 | 1 minuto |
Estes são os números padrão. O operador pode alterá-los, então os cabeçalhos acima são sempre a fonte da verdade. Os números exatos das suas chaves, e quanto de cada um você já usou agora, estão na página Chaves de API. Requisições sem chave são contadas por endereço IP e recebem cotas menores para iniciar envios (10 em vez de 60), enviar partes (300 em vez de 600), consultar o progresso (300 em vez de 600), configurações de distribuição de um envio (60 em vez de 300), iniciar a distribuição (10 em vez de 30), e a mesma cota para envios remotos (URL) e catálogo público. Ler arquivos e alterar arquivos sempre exigem uma chave.
Erros
Respostas de sucesso são { "success": true, "data": … }. Os erros usam um único formato, junto com o status HTTP. code é estável — use-o nas suas condições; message é para pessoas e pode mudar. details é adicionado quando há mais contexto, retryable diz se repetir a mesma requisição pode ajudar, e requestId nos ajuda a encontrar a sua requisição se você falar com o suporte.
{
"success": false,
"error": {
"code": "INSUFFICIENT_SCOPE",
"message": "This endpoint needs one of these API key scopes: upload:write.",
"requestId": "…",
"retryable": false
}
}| Código | HTTP | Repetir? | Significado |
|---|---|---|---|
NO_TOKEN | 401 | Não | Nenhuma chave de API foi enviada |
INVALID_API_KEY | 401 | Não | A chave está errada ou foi revogada |
INSUFFICIENT_SCOPE | 403 | Não | A chave não tem o escopo que este endpoint exige |
API_KEY_NOT_ALLOWED | 403 | Não | Este endpoint não pode ser usado com uma chave de API |
EMAIL_NOT_VERIFIED | 403 | Não | Confirme primeiro o e-mail da conta; as sessões abertas continuam funcionando |
SESSION_REVOKED | 401 | Não | A sessão de login foi encerrada (redefinição ou troca de senha, saída da conta); entre de novo |
ACCOUNT_INACTIVE | 403 | Não | A conta está suspensa ou agendada para exclusão |
ACCOUNT_DISABLED | 401 / 409 | Não | A conta foi suspensa: 401 na verificação da chave, 409 se isso mudou durante a requisição |
ACCOUNT_PENDING_DELETION | 409 | Não | A conta foi agendada para exclusão durante a requisição; nada novo é iniciado |
VALIDATION_ERROR | 400 | Não | O corpo ou um parâmetro é inválido; veja details |
FILE_REJECTED | 400 | Não | O tipo ou o tamanho do arquivo não é permitido; details.reason diz qual |
TOO_MANY_MIRRORS | 400 | Não | Mais hosts do que um arquivo pode ter |
NO_CONNECTED_PROVIDERS | 400 | Não | Todos os hosts selecionados precisam da sua própria conta e nenhum está conectado |
PROVIDER_REJECTS_FILE | 400 | Não | Nenhum host selecionado aceita este tipo ou tamanho de arquivo |
NO_AVAILABLE_PROVIDERS | 400 | Não | Nenhum dos hosts selecionados está aceitando envios agora; escolha outros ou tente mais tarde. `details.waiting` lista os hosts apenas pausados (por exemplo, um limite diário, liberado em até 24 horas): para eles, tentar mais tarde funciona mesmo com `retryable` false |
NO_VALID_PROVIDERS | 400 | Não | Nenhum valor de providerSlugs corresponde a um host ativo; veja GET /api/v1/providers |
INVALID_JOB_STATE | 400 | Não | A tarefa não pode ser iniciada no estado atual |
JOB_NOT_READY | 400 | Não | O arquivo ainda não tem tarefa de distribuição |
FILE_TOO_LARGE_FOR_UPLOAD | 400 | Não | O arquivo não cabe em 10 000 partes do chunkSize da sessão; details.limitBytes |
MISSING_OFFSET | 400 | Não | Uma parte foi enviada sem um cabeçalho upload-offset numérico |
RAW_BODY_REQUIRED | 400 | Não | O corpo de uma parte deve ser bytes brutos com content-type application/offset+octet-stream |
TOO_MANY_URLS | 400 | Não | Mais URLs em uma requisição remote-uploads do que o permitido |
FILE_NOT_FOUND | 404 | Não | Esse arquivo não existe na sua conta (ou foi excluído) |
JOB_NOT_FOUND | 404 | Não | Essa tarefa de distribuição não existe na sua conta |
SESSION_NOT_FOUND | 404 | Não | Essa sessão de envio não existe na sua conta |
SHARE_NOT_FOUND | 404 | Não | O arquivo ainda não tem página de compartilhamento |
QUOTA_EXCEEDED | 409 | Não | Um limite diário ou de envios simultâneos; details.retryAt diz quando ele é liberado |
CHUNK_OFFSET_CONFLICT | 409 | Não | upload-offset não corresponde aos bytes recebidos; retome a partir do HEAD |
CHUNK_TOO_SMALL | 409 | Não | Uma parte que não é a última tem menos de 5 MiB |
CHUNK_TOO_MANY_PARTS | 409 | Não | Mais de 10 000 partes; envie partes maiores |
CHUNK_MISALIGNED | 409 | Não | A parte não é uma fatia inteira de chunkSize começando em um múltiplo de chunkSize: isso é exigido para uma parte enviada adiante e, se a primeira parte foi uma fatia inteira de chunkSize, também para todas as partes seguintes (em ordem ou adiante); ou uma parte foi enviada adiante em uma sessão que só aceita partes em ordem |
CHUNK_OUT_OF_WINDOW | 409 | Não | Uma parte começa mais de maxChunksAhead partes além de uploadedBytes, ou além dele antes de a primeira parte ser aceita; envie-a de novo depois das anteriores |
CHUNK_EXCEEDS_DECLARED_SIZE | 409 | Não | A parte ultrapassa o tamanho de arquivo declarado na criação da sessão |
CHUNK_EMPTY | 409 | Não | A parte não tem bytes |
CHUNK_NOT_RECEIVABLE | 409 | Não | A sessão não aceita mais dados (foi concluída, cancelada ou expirou); abra uma nova |
SESSION_EXPIRED | 409 | Não | A sessão de envio expirou; abra uma nova |
SESSION_NOT_RECEIVABLE | 409 | Não | A sessão foi cancelada ou expirou e não aceita mais alterações |
SESSION_COMPLETED | 409 | Não | O envio já terminou; exclua o arquivo em vez disso |
UPLOAD_INCOMPLETE | 409 | Não | Nem todos os bytes chegaram; envie primeiro as partes restantes (details traz as contagens) |
IDEMPOTENCY_KEY_CONFLICT | 409 | Não | Esta idempotencyKey já é usada por outro envio; use uma chave única por envio |
SOURCE_GONE | 409 | Não | Nossa cópia do arquivo já foi removida, então ele não pode ser mandado para hosts em que ainda não foi tentado; envie-o de novo para esses. Nossa cópia é removida assim que uma tarefa de distribuição termina (concluída, concluída em parte ou com falha), e um envio cuja distribuição nunca é iniciada é removido 30 minutos após terminar (até 72 horas quando o plano de distribuição ainda aguarda hosts; exceto envios por URL remota). Chamar mirror-tasks/start de novo para uma tarefa concluída só com hosts já tentados apenas aplica as configurações de compartilhamento (alreadyStarted: true) |
JOB_NOT_DISTRIBUTABLE | 409 | Não | A tarefa falhou, foi cancelada ou está em um estado que não permite mais distribuição |
SHARE_TAKEN_DOWN | 409 | Não | A página de compartilhamento do arquivo foi removida, então ele não pode ser mandado para mais hosts |
FINALIZING | 409 | Sim | Outra requisição está montando o arquivo; pergunte de novo em alguns segundos |
CONFLICT | 409 | Sim | Colidiu com outra alteração em andamento; repita a mesma requisição |
TEMPORARILY_UNAVAILABLE | 503 | Sim, após Retry-After | O servidor está ocupado agora; tente de novo após o intervalo de Retry-After. details.reason "staging_full": o armazenamento temporário está cheio e nenhum envio novo foi aceito (Retry-After de cerca de 10 minutos); envios já em andamento continuam funcionando |
PAYLOAD_TOO_LARGE | 413 | Não | O corpo da requisição (ou uma parte) é maior do que o servidor aceita |
REMOTE_TOO_LARGE | por URL | Não | Em um resultado de remote-uploads: o arquivo passa do limite de envio por URL |
RATE_LIMITED | 429 | Sim, após Retry-After | Requisições demais para este grupo |
INTERNAL_ERROR | 500 | Sim | Erro no servidor; os detalhes são registrados, nunca retornados |
MAINTENANCE | 503 | Sim, após Retry-After | Novos envios estão pausados por enquanto; leituras continuam funcionando |
UPLOADS_TEMPORARILY_UNAVAILABLE | 503 | Sim, após Retry-After | Não foi possível ler nosso contador de envios; nenhuma sessão foi aberta |
SHUTTING_DOWN | 503 | Sim, após Retry-After | O servidor está reiniciando (Retry-After de 5 segundos); aguarde e envie a mesma requisição de novo — nada foi processado |
Por que um host foi ignorado
Isto não são erros: chegam em skipped[].reason de um start bem-sucedido (e de distribution na resposta que completa o arquivo). Os outros hosts recebem o arquivo normalmente. A chamada só falha quando nenhum host selecionado pode aceitá-lo: PROVIDER_REJECTS_FILE (nenhum aceita este arquivo), NO_CONNECTED_PROVIDERS (todos precisam da sua própria conta), NO_AVAILABLE_PROVIDERS (nenhum está aceitando envios agora) ou NO_VALID_PROVIDERS (nenhum slug corresponde a um host ativo).
| Motivo | Significado |
|---|---|
UNKNOWN_PROVIDER | Não existe host com este slug — confira a grafia em GET /api/v1/providers |
PROVIDER_DISABLED | O host está desativado ou em manutenção agora |
ACCOUNT_REQUIRED | O host só aceita envios para a sua própria conta — conecte-o na página Conexões |
GUEST_UPLOAD_OFF | O host não está aceitando envios agora e não pode ser conectado a uma conta |
DAILY_LIMIT_REACHED | O limite diário do host para envios sem conta se esgotou por enquanto (até 24 h) — conecte sua própria conta para enviar mesmo assim |
FILE_TOO_LARGE | O arquivo passa do limite de tamanho deste host |
MIME_NOT_ALLOWED | O host não aceita este tipo de arquivo |
ALREADY_ATTEMPTED | Este host já foi tentado para este arquivo, então ele não é enviado de novo para lá |
A referência da API lista os códigos que cada endpoint pode retornar.