Documentación de la API
Sube un archivo una vez, envíalo a los hosts de archivos que elijas y recibe un solo enlace para compartir, todo desde tu propio código.
Actualizado
Una API REST versionada: sube un archivo por partes, envíalo a los hosts que elijas y todas las copias se reúnen en una sola página para compartir con estado en vivo.
- URL base
- https://api.mirroruploadx.com/api/v1
- Autenticación
- x-api-key: mux_…
1Abre una sesión
POST /
api/ v1/ upload-sessions filename + sizeBytes; obtienes sessionId y chunkSize
2Envía las partes
PATCH /
api/ v1/ upload-sessions/ {id}/ chunks bytes sin procesar, en orden; la respuesta que completa el archivo incluye fileId
3Distribuye
POST /
api/ v1/ mirror-tasks/ start fileId + providerSlugs; luego consulta el trabajo
Crea una clave en la página Claves de API. Guía completa con código en Subir y distribuir.
Autenticación
Crea una clave en la página Claves de API de tu panel. La clave completa (empieza por mux_) solo se muestra una vez, así que guárdala de inmediato. Envíala en la cabecera x-api-key en cada solicitud; Authorization: Bearer mux_… se acepta de la misma forma para los clientes que solo trabajan con tokens bearer.
Las claves tienen permisos: una clave solo llega a los endpoints que cubren sus permisos, y una llamada con el permiso incorrecto devuelve 403 INSUFFICIENT_SCOPE con el permiso necesario en el mensaje. Los ajustes de la cuenta, la gestión de claves y los webhooks no son accesibles con una clave de API (API_KEY_NOT_ALLOWED).
| Permiso | Da acceso a |
|---|---|
upload:write | Sesiones de subida (crear, partes, completar, cancelar), tu cuota de subida, retener o cambiar la distribución automática de una subida (hold-distribution, distribution-intent), subidas desde URL remotas, iniciar la distribución |
file:read | Listado de archivos, detalles de archivos, estado de espejos y trabajos |
file:write | Ajustes de compartir de un archivo |
file:delete | Eliminar un archivo y sus espejos |
Endpoints
Todo lo que una clave de API puede alcanzar, además de los endpoints públicos que no necesitan clave. Cuando la columna de permisos indica dos permisos, basta con uno de ellos. Los esquemas de solicitud y respuesta de cada uno están en la referencia de la API.
| Método | Ruta | Permiso | Qué hace |
|---|---|---|---|
| POST | / | upload:write | Abre una sesión de subida (opcionalmente con un plan de distribución) |
| PATCH | / | upload:write | Envía la siguiente parte de bytes |
| HEAD | / | upload:write | Dónde reanudar: la cabecera Upload-Offset |
| GET | / | upload:writefile:read | Estado de la sesión: bytes recibidos, fileId, finalizable |
| GET | / | upload:writefile:read | Tus límites de subida, uso y sesiones sin terminar |
| POST | / | upload:write | Termina una subida cuya respuesta final se perdió (se puede reintentar sin riesgo) |
| POST | / | upload:write | Impide que una distribución diferida empiece sola |
| PUT | / | upload:write | Reemplaza el plan de distribución de una subida |
| DELETE | / | upload:write | Cancela una subida sin terminar y libera su espacio |
| POST | / | upload:write | Descarga archivos desde URL http(s) a tu cuenta |
| POST | / | upload:write | Envía un archivo a los hosts que elijas |
| GET | / | upload:writefile:read | Estado del trabajo, cada host y el enlace para compartir (shareTakenDown indica una página retirada) |
| GET | / | file:read | Lista tus archivos (paginación por cursor, búsqueda, filtros) |
| GET | / | file:read | Un archivo: tamaño, suma de verificación, trabajo, ajustes de compartir, estadísticas |
| GET | / | file:read | Todas las copias de un archivo: host, enlace, estado, clics |
| PATCH | / | file:write | Contraseña, caducidad y visibilidad del enlace compartido |
| DELETE | / | file:delete | Elimina un archivo y (por defecto) sus copias en los hosts |
| GET | / | ninguno (público) | Límites actuales: archivo más grande, hosts por archivo, topes de subida desde URL |
| GET | / | ninguno (público) | El catálogo de hosts, con los slugs que envías en providerSlugs |
| GET | / | ninguno (público) | Éxito de subida medido por host |
| GET | / | ninguno (público) | Totales de la plataforma en los últimos 30 días: archivos, espejos en línea, tasa de éxito |
Subir un archivo y distribuirlo
- Abre una sesión con
POST /api/v1/upload-sessions.filenameysizeBytes(la longitud exacta en bytes) son obligatorios;mimeTypey unidempotencyKeyUUID son opcionales: repetir una solicitud con la misma clave devuelve la sesión existente en lugar de abrir una segunda. La respuesta incluyedata.sessionId(noid) ydata.chunkSize. - Envía los bytes con
PATCH /api/v1/upload-sessions/{id}/chunks: bytes sin procesar, tipo de contenidoapplication/offset+octet-streamy la posición inicial de la parte en la cabeceraupload-offset. Las partes van en orden, o hastamaxChunksAheadpartes por delante; si envías en orden, usadata.uploadedBytesde cada respuesta como el siguiente desplazamiento. Envía partes dechunkSizebytes; todas las partes excepto la última deben tener al menos 5 MiB, y una subida puede tener como máximo 10 000 partes. La respuesta que completa el archivo incluyedata.fileId. Para ganar velocidad, puedes tener 2 o 3 partes del mismo archivo en curso a la vez. Envía la primera parte sola; su respuesta indica el valor real dedata.maxChunksAhead(4 si la primera parte era un fragmento completo dechunkSize, 0 = solo en orden). Si la primera parte era un fragmento completo dechunkSize, todas las partes posteriores también deben serlo (en orden o por delante): empiezan en un múltiplo dechunkSizey miden exactamentechunkSizebytes (la última: el resto del archivo). Una parte enviada por delante deuploadedBytesdebe ser un fragmento así y empezar como máximodata.maxChunksAheadpartes por delante; de lo contrario, recibe409 CHUNK_MISALIGNEDo409 CHUNK_OUT_OF_WINDOW.uploadedBytessolo cuenta los bytes recibidos sin huecos, y la parte que complete el archivo, sea cual sea, recibe la respuesta confileId. Volver a enviar una parte que ya llegó es un éxito inofensivo. - Distribuye con
POST /api/v1/mirror-tasks/start:fileIdyproviderSlugsson obligatorios (los slugs se obtienen deGET /api/v1/providers). Opcionales:minSuccess(por defecto 1: cuántos hosts deben aceptar el archivo para que el trabajo no falle; solo escompletedcuando todos los hosts lo aceptaron, si no,partially_completed. Los hosts que rechazan este tipo de archivo no cuentan),sharePassword,expiresInDaysoexpiresAt. La respuesta incluyeuploadJobId,taskCount,shareSlug,alreadyStartedyskipped[]: un host que no puede aceptar este archivo se omite, no falla, así que leeskipped[](los motivos se enumeran más abajo). Ahora mismo, un archivo puede ir como máximo a 50 hosts. - Sigue su progreso con
GET /api/v1/mirror-tasks/{uploadJobId}cada pocos segundos hasta quedata.terminalseatrue. La respuesta enumera cada host entasks[](providerSlug,status,mirrorUrl,errorCode) y el enlace para compartir endata.shareUrl.data.shareTakenDownestruecuando esa página para compartir se retiró y ya no se abre.
El archivo más grande que se acepta ahora mismo es de 5,00 GB.
bash, requiere 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";
}Respuestas de ejemplo
Abrir una sesión responde 201. Cada parte salvo la última responde { uploadedBytes, completed: false, expiresAt }; la última incluye el archivo. distribution solo aparece si pasaste un plan al abrir la sesión (ver más abajo).
{
"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
}
]
}
}Un primer start correcto responde 202; volver a llamarlo para un trabajo que ya está en curso responde 200 con alreadyStarted: true. Cuando el enlace de un host se mantiene privado por política, mirrorUrl es null y mirrorHidden es true; la página para compartir sigue mostrándolo.
Ahórrate la segunda llamada
Pasa distribution al abrir la sesión y el servidor empezará a distribuir en cuanto el archivo esté completo. Comprueba data.distribution en la respuesta que completa el archivo: started: true significa que el trabajo está en cola (uploadJobId, shareSlug). Con started: false y deferred: true, todavía no hay nada en cola a propósito; ver más abajo. Con started: false y sin deferred, la subida se completó pero la distribución no pudo empezar (error indica por qué): llama a POST /api/v1/mirror-tasks/start con el fileId. Un error junto con deferred: true significa un fallo temporal (por ejemplo, todos los hosts están ocupados o en mantenimiento): no llames a start ni vuelvas a subir el archivo; el propio servidor reintentará iniciar la distribución a partir de autoStartAt (hasta 5 intentos). Llama a hold-distribution para detenerlo.
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": "…" } }Añade deferred: true a distribution para tener un periodo de gracia: la respuesta final es { started: false, deferred: true, autoStartAt } y el propio servidor inicia la distribución en autoStartAt (unos 2 minutos después), salvo que llames antes a start. Para detener el inicio automático, llama a POST /api/v1/upload-sessions/{id}/hold-distribution (sin cuerpo; autoStartAt pasa a null y la inicias tú). Para cambiar el plan, llama a PUT /api/v1/upload-sessions/{id}/distribution-intent con los mismos campos que distribution (providerSlugs, minSuccess, expiresInDays, sharePassword): reemplaza el plan y levanta la retención, y una vez terminada la subida el inicio automático se aplaza al menos 2 minutos después de la llamada. Si la distribución ya ha empezado, ambas responden 200 y distribution-intent indica alreadyStarted: true.
Inicia la distribución en menos de 30 minutos. Cuando termina una subida y no se inicia ninguna distribución, nuestra copia del archivo se elimina al cabo de 30 minutos (si hay un plan de distribución esperando a que los hosts estén disponibles, como máximo al cabo de 72 horas; las subidas desde URL remotas no se ven afectadas). A partir de entonces, start y distribution-intent responden 409 SOURCE_GONE y hay que volver a subir el archivo.
Si se pierde la respuesta final
Llama a GET /api/v1/upload-sessions/{id}: un fileId significa que el archivo existe; finalizable: true significa que llegaron todos los bytes y POST /api/v1/upload-sessions/{id}/complete lo termina. Esa llamada se puede reintentar sin riesgo y nunca crea un segundo archivo. Un desplazamiento que no coincide recibe 409 CHUNK_OFFSET_CONFLICT: envía HEAD a la sesión y reanuda desde su cabecera Upload-Offset. Volver a llamar a start para un trabajo en curso no es un error: recibes 200 con alreadyStarted: true.
Subir desde una URL
POST /api/v1/remote-uploads recibe { "urls": [...] } y descarga cada archivo por ti (permiso upload:write). Solo se descargan enlaces http y https, las direcciones de redes privadas se rechazan y solo se sigue un número limitado de redirecciones. Una solicitud admite como máximo 10 URL (lo devuelve GET /api/v1/platform); divide las listas más largas.
El límite de tamaño por archivo depende del origen. Cuando indica el tamaño del archivo, cada archivo puede ocupar hasta 5,00 GB (limits.remoteUploadPassthroughMaxBytes); cuando no lo indica, hasta 100,0 MB (limits.remoteUploadMaxBytes). El nombre del archivo se toma de la cabecera Content-Disposition del origen cuando la envía; a un nombre sin extensión se le añade una según el tipo del archivo.
La solicitud espera mientras se descargan los archivos. Si la conexión se corta antes, el archivo llega igualmente a tu cuenta: encuéntralo con GET /api/v1/files. Después, cada fileId se distribuye con POST /api/v1/mirror-tasks/start, como se explica arriba.
Cuando el almacenamiento temporal está lleno, toda la solicitud recibe 503 TEMPORARILY_UNAVAILABLE con details.reason: "staging_full" y una cabecera Retry-After. Si solo una URL no cabe, esa entrada de results[] tiene ok: false y el mismo código; un resultado por URL no tiene cabecera, así que la espera en segundos está en 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.Gestionar archivos
Tus archivos permanecen en tu cuenta después de la subida. Lístalos con GET /api/v1/files (limit hasta 100; pasa el nextCursor de la respuesta como cursor para la página siguiente; q busca por nombre). GET /api/v1/files/{id} devuelve un archivo con su trabajo, sus ajustes de compartir y sus estadísticas de visitas; GET /api/v1/files/{id}/mirrors enumera cada copia con su enlace, su estado y sus clics.
PATCH /api/v1/files/{id}/share (permiso file:write) cambia la página para compartir: password (de 4 a 128 caracteres; null la quita; nunca se devuelve, solo passwordProtected), expiresAt (fecha ISO, null para que no caduque), visibility y hideDownloadCount. Envía solo los campos que quieras cambiar. DELETE /api/v1/files/{id} (permiso file:delete) elimina el archivo y pone en cola la eliminación de sus copias en los hosts; añade ?keepMirrors=true para conservarlas. Algunos hosts no permiten borrar, así que puede quedar una copia allí.
bash, requiere jq; define 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; define 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; define 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; define 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
Añade un endpoint en la página Webhooks. La URL debe usar https://; su secreto de firma (whsec_…) se muestra una sola vez, al crearlo. Un endpoint sin eventos seleccionados los recibe todos.
| Evento | Cuándo |
|---|---|
upload.completed | Todos los hosts aceptaron el archivo, y al menos minSuccess lo hicieron; no cuentan los hosts que rechazaron este archivo (rejected) ni los que se cancelaron |
upload.partially_completed | Al menos minSuccess hosts aceptaron el archivo, pero al menos otro host falló |
upload.failed | Menos de minSuccess hosts aceptaron el archivo (minSuccess 0 cuenta como 1) |
upload.quarantined | El análisis de malware marcó el archivo (solo cuando el análisis está activado) |
provider.upload_succeeded | Un host aceptó el archivo; se envía una vez por host |
provider.upload_failed | Un host se dio por vencido con el archivo; se envía una vez por host |
webhook.test | Pulsaste Probar en la página Webhooks |
Cada entrega es un POST con un cuerpo JSON y las cabeceras X-MUX-Event y X-MUX-Signature. Cualquier respuesta 2xx en 10 segundos cuenta como entregada; las redirecciones no se siguen. Una entrega fallida (error de red, tiempo de espera agotado, 408, 425, 429 o 5xx) se reintenta tras 1, 5 y 30 minutos con el mismo cuerpo; los demás 4xx y las redirecciones no. Cada intento incluye X-MUX-Delivery-Attempt (1–4) y una firma nueva, así que elimina los duplicados a partir del cuerpo. El orden de entrega no está garantizado (un evento reintentado puede llegar después de uno más reciente); compara data y createdAt antes de actuar. Usa GET /api/v1/mirror-tasks/{uploadJobId} para ponerte al día. Tras 15 entregas seguidas cuyo último intento falló, o una hora de fallos sin un solo éxito, el endpoint se pone en pausa; al reactivarlo, el recuento se reinicia. Una entrega webhook.test (el botón Probar) se envía una sola vez, con X-MUX-Delivery-Attempt: 1, y nunca se reintenta.
{
"event": "provider.upload_succeeded",
"createdAt": "2026-09-25T12:00:00.000Z",
"data": {
"uploadJobId": "…",
"fileId": "…",
"provider": "gofile",
"providerName": "Gofile",
"status": "succeeded",
"mirrorUrl": "https://…"
}
}Los eventos upload.* incluyen uploadJobId, fileId y status; provider.upload_failed incluye errorCode en lugar de mirrorUrl.
Verificar la firma
La cabecera tiene este aspecto: t=1727265600,v1=5f2b…. t es el momento de la firma en segundos Unix y v1 es el HMAC-SHA256 en hexadecimal de <t>.<raw body>, con el secreto de tu endpoint como clave. Calcula el hash de los bytes sin procesar exactamente como se recibieron, compara en tiempo constante y rechaza las marcas de tiempo con más de 5 minutos de antigüedad.
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+ sin dependencias
<?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 deliveredLímites de solicitudes
Los límites se cuentan por clave de API, no por dirección IP. Cada respuesta de un endpoint limitado incluye X-RateLimit-Limit, X-RateLimit-Remaining y X-RateLimit-Reset (segundos desde epoch). Si superas el límite, se devuelve 429 RATE_LIMITED con una cabecera Retry-After: espera esa cantidad de segundos. La subida de partes tiene un margen amplio; los límites estrictos están en la apertura de sesiones y el inicio de distribuciones.
| Grupo | Endpoints | Por clave | Periodo |
|---|---|---|---|
| Inicio de subidas | POST /POST /DELETE / | 60 | 1 minuto |
| Subida de partes | PATCH / | 600 | 1 minuto |
| Consulta del progreso | GET /HEAD /GET /GET / | 600 | 1 minuto |
| Ajustes de distribución de una subida | POST /PUT / | 300 | 1 minuto |
| Inicio de la distribución | POST / | 30 | 1 minuto |
| Subidas remotas (URL) | POST / | 20 | 10 minutos |
| Lectura de archivos | GET /GET /GET / | 300 | 1 minuto |
| Modificación de archivos | PATCH /DELETE / | 60 | 1 minuto |
| Catálogo público | GET /GET /GET /GET / | 300 | 1 minuto |
Estas son las cifras predeterminadas. El operador puede cambiarlas, así que las cabeceras anteriores son siempre la fuente fiable. Las cifras exactas de tus claves, y cuánto has usado de cada una ahora mismo, están en la página Claves de API. Las solicitudes sin clave se cuentan por dirección IP y tienen márgenes menores para el inicio de subidas (10 en lugar de 60), la subida de partes (300 en lugar de 600), la consulta del progreso (300 en lugar de 600), los ajustes de distribución de una subida (60 en lugar de 300), el inicio de la distribución (10 en lugar de 30) y el mismo margen para las subidas remotas (URL) y el catálogo público. Lectura de archivos y la modificación de archivos: siempre se necesita una clave.
Errores
Las respuestas correctas tienen la forma { "success": true, "data": … }. Los errores usan una única forma, junto al estado HTTP. code es estable: toma decisiones según él; message es para personas y puede cambiar. details se añade cuando hay más contexto, retryable indica si repetir la misma solicitud puede servir de algo y requestId nos ayuda a encontrar tu solicitud si contactas con soporte.
{
"success": false,
"error": {
"code": "INSUFFICIENT_SCOPE",
"message": "This endpoint needs one of these API key scopes: upload:write.",
"requestId": "…",
"retryable": false
}
}| Código | HTTP | ¿Reintentar? | Significado |
|---|---|---|---|
NO_TOKEN | 401 | No | No se envió ninguna clave de API |
INVALID_API_KEY | 401 | No | La clave es incorrecta o está revocada |
INSUFFICIENT_SCOPE | 403 | No | La clave no tiene el permiso que necesita este endpoint |
API_KEY_NOT_ALLOWED | 403 | No | Este endpoint no se puede usar con una clave de API |
EMAIL_NOT_VERIFIED | 403 | No | Primero verifica el correo de la cuenta; las sesiones abiertas siguen funcionando |
SESSION_REVOKED | 401 | No | La sesión se cerró (restablecimiento o cambio de contraseña, cierre de sesión); vuelve a iniciar sesión |
ACCOUNT_INACTIVE | 403 | No | La cuenta está suspendida o programada para su eliminación |
ACCOUNT_DISABLED | 401 / 409 | No | La cuenta se suspendió: 401 en la comprobación de la clave, 409 si cambió mientras se procesaba la solicitud |
ACCOUNT_PENDING_DELETION | 409 | No | La cuenta pasó a estar programada para su eliminación mientras se procesaba la solicitud; no se inicia nada nuevo |
VALIDATION_ERROR | 400 | No | El cuerpo o un parámetro no es válido; consulta details |
FILE_REJECTED | 400 | No | El tipo o el tamaño del archivo no está permitido; details.reason indica cuál |
TOO_MANY_MIRRORS | 400 | No | Más hosts de los que puede tener un archivo |
NO_CONNECTED_PROVIDERS | 400 | No | Todos los hosts seleccionados necesitan tu propia cuenta y ninguno está conectado |
PROVIDER_REJECTS_FILE | 400 | No | Ningún host seleccionado acepta este tipo o tamaño de archivo |
NO_AVAILABLE_PROVIDERS | 400 | No | Ninguno de los hosts seleccionados acepta subidas ahora mismo; elige otros o inténtalo más tarde. `details.waiting` enumera los hosts solo pausados (por ejemplo, un límite diario que se levanta en 24 horas): para ellos reintentar más tarde funciona aunque `retryable` sea false |
NO_VALID_PROVIDERS | 400 | No | Ningún valor de providerSlugs coincide con un host activado; consulta GET /api/v1/providers |
INVALID_JOB_STATE | 400 | No | El trabajo no se puede iniciar en su estado actual |
JOB_NOT_READY | 400 | No | El archivo aún no tiene un trabajo de distribución |
FILE_TOO_LARGE_FOR_UPLOAD | 400 | No | El archivo no cabe en 10 000 partes del tamaño de parte de la sesión; details.limitBytes |
MISSING_OFFSET | 400 | No | Se envió una parte sin una cabecera upload-offset numérica |
RAW_BODY_REQUIRED | 400 | No | El cuerpo de una parte debe ser bytes sin procesar con content-type application/offset+octet-stream |
TOO_MANY_URLS | 400 | No | Más URL de las permitidas en una solicitud remote-uploads |
FILE_NOT_FOUND | 404 | No | Ese archivo no existe en tu cuenta (o se eliminó) |
JOB_NOT_FOUND | 404 | No | Ese trabajo de distribución no existe en tu cuenta |
SESSION_NOT_FOUND | 404 | No | Esa sesión de subida no existe en tu cuenta |
SHARE_NOT_FOUND | 404 | No | El archivo aún no tiene página para compartir |
QUOTA_EXCEEDED | 409 | No | Un límite de subidas diario o simultáneo; details.retryAt indica cuándo se libera |
CHUNK_OFFSET_CONFLICT | 409 | No | upload-offset no coincide con los bytes recibidos; reanuda a partir de HEAD |
CHUNK_TOO_SMALL | 409 | No | Una parte que no es la última mide menos de 5 MiB |
CHUNK_TOO_MANY_PARTS | 409 | No | Más de 10 000 partes; envía partes más grandes |
CHUNK_MISALIGNED | 409 | No | La parte no es un fragmento completo de chunkSize que empiece en un múltiplo de chunkSize: es obligatorio para una parte enviada por delante y, si la primera parte era un fragmento completo de chunkSize, también para todas las posteriores (en orden o por delante); o se envió una parte por delante en una sesión que solo acepta partes en orden |
CHUNK_OUT_OF_WINDOW | 409 | No | Una parte empieza más de maxChunksAhead partes por delante de uploadedBytes, o simplemente por delante antes de que se haya aceptado la primera parte; vuelve a enviarla después de las anteriores |
CHUNK_EXCEEDS_DECLARED_SIZE | 409 | No | La parte supera el tamaño de archivo declarado al crear la sesión |
CHUNK_EMPTY | 409 | No | La parte no tiene bytes |
CHUNK_NOT_RECEIVABLE | 409 | No | La sesión ya no acepta datos (se completó, se canceló o caducó); abre una nueva |
SESSION_EXPIRED | 409 | No | La sesión de subida caducó; abre una nueva |
SESSION_NOT_RECEIVABLE | 409 | No | La sesión se canceló o caducó y no admite más cambios |
SESSION_COMPLETED | 409 | No | La subida ya terminó; elimina el archivo en su lugar |
UPLOAD_INCOMPLETE | 409 | No | No han llegado todos los bytes; envía primero las partes restantes (details incluye los recuentos) |
IDEMPOTENCY_KEY_CONFLICT | 409 | No | Este idempotencyKey ya lo usa otra subida; usa una clave única por subida |
SOURCE_GONE | 409 | No | Nuestra copia del archivo ya se eliminó, así que no se puede enviar a los hosts en los que aún no se ha intentado; vuelve a subirlo para esos. Nuestra copia se elimina en cuanto termina un trabajo de distribución (completado, completado parcialmente o fallido), y una subida cuya distribución nunca se inicia se elimina 30 minutos después de terminar (hasta 72 horas cuando su plan de distribución sigue esperando a los hosts; salvo las subidas desde URL remotas). Volver a llamar a mirror-tasks/start para un trabajo terminado solo con hosts ya intentados se limita a aplicar los ajustes de compartir (alreadyStarted: true) |
JOB_NOT_DISTRIBUTABLE | 409 | No | El trabajo falló, se canceló o está en un estado que ya no se puede distribuir |
SHARE_TAKEN_DOWN | 409 | No | La página para compartir del archivo se retiró, así que no se puede enviar a más hosts |
FINALIZING | 409 | Sí | Otra solicitud está ensamblando el archivo; vuelve a preguntar en unos segundos |
CONFLICT | 409 | Sí | Coincidió con otro cambio en curso; reintenta la misma solicitud |
TEMPORARILY_UNAVAILABLE | 503 | Sí, tras Retry-After | El servidor está ocupado ahora mismo; reintenta tras el plazo de Retry-After. details.reason "staging_full": el almacenamiento temporal está lleno y no se aceptó ninguna subida nueva (Retry-After de unos 10 minutos); las subidas ya en curso siguen funcionando |
PAYLOAD_TOO_LARGE | 413 | No | El cuerpo de la solicitud (o una parte) es más grande de lo que acepta el servidor |
REMOTE_TOO_LARGE | por URL | No | En un resultado de remote-uploads: el archivo supera el límite de subida desde URL |
RATE_LIMITED | 429 | Sí, tras Retry-After | Demasiadas solicitudes para este grupo |
INTERNAL_ERROR | 500 | Sí | Error del servidor; los detalles se registran, nunca se devuelven |
MAINTENANCE | 503 | Sí, tras Retry-After | Las nuevas subidas están en pausa por ahora; las lecturas siguen funcionando |
UPLOADS_TEMPORARILY_UNAVAILABLE | 503 | Sí, tras Retry-After | No se pudo leer nuestro contador de subidas; no se abrió ninguna sesión |
SHUTTING_DOWN | 503 | Sí, tras Retry-After | El servidor se está reiniciando (Retry-After de 5 segundos); espera y envía la misma solicitud de nuevo: no se procesó nada |
Por qué se omitió un host
No son errores: llegan en skipped[].reason de un start correcto (y de distribution en la respuesta que completa el archivo). Los demás hosts reciben el archivo igualmente. La llamada solo falla cuando ningún host seleccionado puede aceptarlo: PROVIDER_REJECTS_FILE (ninguno acepta este archivo), NO_CONNECTED_PROVIDERS (todos necesitan tu propia cuenta), NO_AVAILABLE_PROVIDERS (ninguno acepta subidas ahora mismo) o NO_VALID_PROVIDERS (ningún slug coincide con un host activado).
| Motivo | Significado |
|---|---|
UNKNOWN_PROVIDER | No existe ningún host con este slug: comprueba cómo se escribe en GET /api/v1/providers |
PROVIDER_DISABLED | El host está desactivado o en mantenimiento ahora mismo |
ACCOUNT_REQUIRED | El host solo acepta subidas a tu propia cuenta: conéctalo en la página Conexiones |
GUEST_UPLOAD_OFF | El host no acepta subidas ahora mismo y no se puede conectar a una cuenta |
DAILY_LIMIT_REACHED | El límite diario del host para subidas sin cuenta está agotado por ahora (hasta 24 h): conecta tu propia cuenta para poder subir igualmente |
FILE_TOO_LARGE | El archivo supera el límite de tamaño de este host |
MIME_NOT_ALLOWED | El host no acepta este tipo de archivo |
ALREADY_ATTEMPTED | Este host ya se intentó para este archivo, así que no se vuelve a enviar allí |
La referencia de la API enumera los códigos que puede devolver cada endpoint.