Infraestructura de almacenamiento híbrida con gestión avanzada.
Bienvenido a la documentación de Evogb Cloud. Este sistema proporciona almacenamiento en Nube Compartida y Privada, accesible mediante un Panel de Control Web interactivo y una API REST.
Esta documentación cubre desde la gestión básica sobre Evogb Cloud hasta la integración avanzada (Bots, Apps, Scripts), incluyendo detalles sobre planes, límites y preferencias.
Evogb Cloud opera bajo un modelo de Ciclo de Vida Gestionado. Dependiendo de tu plan, tus archivos se almacenan y comportan de manera diferente.
free/ (URL pública).hide_user y hide_filename.premium/ (URL pública limpia en raíz).*/* y Dominios Personalizados (Plan Pro o superior).El sistema usa una base de datos aislada en un sitio aparte y seguro para rastrear uso (almacenamiento, operaciones diarias) y archivos subidos, con resets diarios automáticos.
Variables del sistema que rigen tu cuenta (consultables vía /api/cdn/stats).
| Atributo JSON | Nombre Panel | Descripción y Efecto al Límite |
|---|---|---|
storage_total_mb | Almacenamiento | Capacidad total. Bloqueo (403): No podrás subir más hasta liberar espacio o mejorar plan. |
upload_ops_limit | Subidas Diarias | Máx. archivos/24h. Temp (429): Reinicia a las 04:00 AM Colombia |
download_ops_limit | Descargas Diarias | Máx. accesos/24h. Temp (429): Ilimitado en Business. |
max_file_size_mb | Peso Máximo | Rechazo (413): Subida cancelada inmediatamente. |
allowed_mime_types | Formatos | Lista blanca. Rechazo (415) si no permitido. |
retention_days | Retención | Vida útil. Eliminación: Se borra al cumplirse el plazo (30 días). |
expiring_links | Links Temporales | En Desarrollo: No disponible actualmente. |
custom_domain | Dominio Propio | Requiere configuración CNAME y Plan Pro o superior. |
| Plan | Precios & Descuentos (USD) | Almacenamiento | Subidas / Día | Descargas / Día | Máx. por Archivo | Formatos | Cuota IA Diaria |
|---|---|---|---|---|---|---|---|
| Free | $0 (7d) | 100 MB | 11/día | 300 | 5 MB | Imágenes básicas | 10 req/d |
| Lite | $0.60 (15d) | 2.1 GB (2,100 MB) | 40/día | 3,000 | 15 MB | Img, PDF | 20 req/d |
| Go | $0.99 (30d) $1.14 (60d) $1.29 (90d) | 4.1 GB (4,100 MB) | 70/día | 8,000 | 30 MB | Img, PDF, Audio | 30 req/d |
| Basic Popular | $1.69 (30d) $1.95 (60d) $2.20 (90d) | 6.1 GB (6,100 MB) | 130/día | 20,000 | 40 MB | Img, PDF, Audio, Video | 40 req/d |
| Plus | $3.39 (30d) $3.90 (60d) -15% OFF $4.41 (90d) -15% OFF | 10.1 GB (10,100 MB) | 275/día | 55,000 | 75 MB | Todos (*/*) | 50 req/d |
| Pro | $5.94 (60d) $6.83 (90d) $7.73 (365d) | 25.5 GB (25,500 MB) | 600/día | 150,000 | 125 MB | Todos (*/*) | 80 req/d |
| Ultra | $8.99 (60d) $10.34 (90d) $11.69 (365d) | 50.5 GB (50,500 MB) | 1,500/día | 450,000 | 500 MB | Todos (*/*) | 100 req/d |
| Business | $17.99 (60d) $20.69 (90d) $23.39 (365d) -40% OFF | 100.5 GB (100,500 MB) | 7,500/día | Ilimitado | 2 GB (2,000 MB) | Todos (*/*) | 150 req/d |
Precios y duraciones varían por variante. Planes Premium incluyen preferencias de URL y retención permanente. Para mayor información visita la tienda
El panel ubicado en cloud.evogb.org es tu centro de comando visual, con un diseño responsivo (soporte móvil) y efectos animados.
Visualiza consumo en tiempo real:
Llave maestra para APIs. Incluye botones para mostrar, copiar, regenerar y configurar permisos del token.
Permisos del TokenBusca por rango de peso, tipo, fecha o patrones de nombre (empieza/termina).
Opciones de Personalización de Enlaces para ocultar usuario/archivo en URL.
Vincula tu marca (ej. cloud.tu-web.com). Incluye gestión DNS y SSL automático.
Interfaz optimizada para grandes volúmenes. Paginación dinámica y carga fluida.
Sincronización instantánea de carpetas, archivos y consumo de tráfico.
Documentación técnica detallada para desarrolladores. Todas las peticiones requieren autenticación.
Base URL: https://api.evogb.org
El CDN soporta autenticación flexible para adaptarse a cualquier entorno:
x-upload-token: <TU_UPLOAD_TOKEN>Authorization: Bearer <TU_UPLOAD_TOKEN>?upload_token=<TU_UPLOAD_TOKEN> (Aislado de ?key= para evitar colisiones con la API global)upload_token: "<TU_UPLOAD_TOKEN>"Por seguridad, las operaciones destructivas o críticas vía API (como eliminar archivos o carpetas recursivamente) vienen desactivadas por defecto para tu Upload Token. Puedes habilitar o personalizar permisos en cualquier momento desde el Panel CDN > Ajustes del Token.
Permite subir archivos locales (Buffer/Stream) y URLs a tu almacenamiento cloud, con soporte de carpetas virtuales recursivas, metadatos y dos modalidades de subida según el tamaño del archivo:
Envías el archivo completo en una única petición HTTP multipart/form-data. Ideal para fotos, audios, documentos y vídeos estándar.
Para archivos gigantes (ej: 300 MB, 500 MB o 2 GB). El cliente divide el archivo en fragmentos de 25 MB y el servidor los une automáticamente.
Las infraestructuras de red y proxies perimetrales de Internet rechazan peticiones HTTP individuales mayores a 100 MB con el error 413 Payload Too Large. Por esta razón:
Blob.slice() en la web o streams/buffers en backend). Generas un uploadId único y envías los fragmentos uno tras otro.chunkIndex === totalChunks - 1), ensambla el archivo completo automáticamente, valida el tipo MIME y el peso de tu plan, y lo guarda en el CDN entregándote la URL definitiva.| Parámetro | Tipo | Modalidad | Descripción y Comportamiento |
|---|---|---|---|
file | Binary / File | REQ | El archivo binario completo o el fragmento (chunk) actual de 25 MB. |
url | String | Opcional | URL pública de un archivo remoto para que el CDN lo descargue e ingeste automáticamente. |
chunkIndex | Integer | Modo Chunks | Índice base 0 del fragmento actual (ej: 0 para el 1er chunk, 1 para el 2do, etc.). |
totalChunks | Integer | Modo Chunks | Número total de fragmentos en los que se dividió el archivo (ej: 12 para un archivo de 300 MB en bloques de 25 MB). |
uploadId | String | Modo Chunks | Identificador de sesión único compartido por todos los fragmentos del mismo archivo (ej: "up_1723849102" o UUID). |
folder_id | Integer | Opcional | ID numérico de la carpeta de destino donde se guardará el archivo. |
folder_path / path | String | Opcional | Ruta virtual de carpetas (ej: "videos/2026/render"). Si no existen, el CDN las crea automáticamente. |
custom_name | String | Opcional | Sobrescribe el nombre del archivo en la URL final (ej: "video_final"). |
hide_user | Boolean | Opcional (Planes Pro+) | true: URL en la raíz (cdn.evogb.org/Xy9K2.mp4).false: Con usuario (cdn.evogb.org/usuario/Xy9K2.mp4). |
hide_filename | Boolean | Opcional (Planes Pro+) | true: Oculta el nombre original y genera un enlace 100% aleatorio (ej: 7hKxS.webp). |
const axios = require("axios");
const FormData = require("form-data");
const fs = require("fs");
async function uploadFileDirect() {
const form = new FormData();
form.append("file", fs.createReadStream("./foto.jpg"));
form.append("folder_path", "proyectos/2026");
try {
const res = await axios.post("https://api.evogb.org/api/cdn/upload", form, {
headers: {
"x-upload-token": "TU_UPLOAD_TOKEN",
...form.getHeaders()
}
});
console.log("✅ Archivo Subido:", res.data);
console.log("🔗 URL Pública:", res.data.url);
} catch (err) {
console.error("❌ Error en subida:", err.response?.data || err.message);
}
}
uploadFileDirect();import requests
url = "https://api.evogb.org/api/cdn/upload"
headers = { "x-upload-token": "TU_UPLOAD_TOKEN" }
payload = { "folder_path": "proyectos/2026" }
with open("./foto.jpg", "rb") as f:
files = { "file": ("foto.jpg", f, "image/jpeg") }
res = requests.post(url, data=payload, files=files, headers=headers)
if res.status_code == 200:
print("✅ Archivo subido exitosamente:", res.json())
else:
print("❌ Error:", res.text)curl -X POST "https://api.evogb.org/api/cdn/upload" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-F "file=@./foto.jpg" \
-F "folder_path=proyectos/2026"Divide el archivo en fragmentos de 25 MB y envíalos secuencialmente con el mismo uploadId. Al enviar el último fragmento, el servidor lo ensamblará automáticamente:
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const path = require('path');
const CHUNK_SIZE = 25 * 1024 * 1024; // 25 MB por fragmento
const TOKEN = 'TU_UPLOAD_TOKEN';
async function uploadLargeFile(filePath) {
const fileStats = fs.statSync(filePath);
const totalBytes = fileStats.size;
const fileName = path.basename(filePath);
const totalChunks = Math.ceil(totalBytes / CHUNK_SIZE);
const uploadId = `up_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
console.log(`🚀 Iniciando subida de: ${fileName} (${(totalBytes / 1024 / 1024).toFixed(2)} MB en ${totalChunks} chunks)`);
const fd = fs.openSync(filePath, 'r');
const buffer = Buffer.alloc(CHUNK_SIZE);
for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
const bytesRead = fs.readSync(fd, buffer, 0, CHUNK_SIZE, chunkIndex * CHUNK_SIZE);
const chunkBuffer = buffer.subarray(0, bytesRead);
const form = new FormData();
form.append('file', chunkBuffer, { filename: fileName });
form.append('chunkIndex', chunkIndex.toString());
form.append('totalChunks', totalChunks.toString());
form.append('uploadId', uploadId);
form.append('folder_path', 'videos/grandes');
const res = await axios.post('https://api.evogb.org/api/cdn/upload', form, {
headers: {
'x-upload-token': TOKEN,
...form.getHeaders()
},
maxContentLength: Infinity,
maxBodyLength: Infinity
});
// Auditoría y progreso a partir de las propiedades devueltas por el servidor
if (chunkIndex < totalChunks - 1) {
const currentChunk = res.data.current_chunk || (chunkIndex + 1);
const maxChunks = res.data.total_chunks || totalChunks;
const percent = Math.round((currentChunk / maxChunks) * 100);
console.log(`📦 Progreso confirmado: ${percent}% (Chunk ${currentChunk}/${maxChunks}) - ${res.data.message}`);
} else {
// El último chunk devuelve la respuesta completa con la URL pública
console.log('🎉 ¡Archivo ensamblado con éxito en el CDN!');
console.log('🔗 URL Pública:', res.data.url);
console.log('📄 ID en Base de Datos:', res.data.id);
}
}
fs.closeSync(fd);
}
uploadLargeFile('./video_de_300mb.mp4');import os
import math
import time
import requests
CHUNK_SIZE = 25 * 1024 * 1024 # 25 MB
TOKEN = "TU_UPLOAD_TOKEN"
API_URL = "https://api.evogb.org/api/cdn/upload"
def upload_large_file(file_path):
file_size = os.path.getsize(file_path)
file_name = os.path.basename(file_path)
total_chunks = math.ceil(file_size / CHUNK_SIZE)
upload_id = f"up_{int(time.time())}"
print(f"🚀 Subiendo {file_name} ({file_size / 1024 / 1024:.2f} MB) en {total_chunks} fragmentos...")
with open(file_path, "rb") as f:
for chunk_index in range(total_chunks):
chunk_data = f.read(CHUNK_SIZE)
payload = {
"chunkIndex": str(chunk_index),
"totalChunks": str(total_chunks),
"uploadId": upload_id,
"folder_path": "archivos/grandes"
}
files = {
"file": (file_name, chunk_data, "application/octet-stream")
}
headers = {
"x-upload-token": TOKEN
}
res = requests.post(API_URL, data=payload, files=files, headers=headers)
res.raise_for_status()
res_data = res.json()
if chunk_index < total_chunks - 1:
current_chunk = res_data.get("current_chunk", chunk_index + 1)
max_chunks = res_data.get("total_chunks", total_chunks)
percent = int((current_chunk / max_chunks) * 100)
print(f"📦 Progreso confirmado: {percent}% (Fragmento {current_chunk}/{max_chunks}) - {res_data.get('message')}")
else:
print("🎉 ¡Archivo completado y guardado en CDN!")
print("🔗 URL:", res_data.get("url"))
upload_large_file("./archivo_pesado.zip")async function uploadFileFromBrowser(fileInput, onProgress) {
const file = fileInput.files[0];
if (!file) return alert("Selecciona un archivo primero");
const CHUNK_SIZE = 25 * 1024 * 1024; // 25 MB
const totalChunks = Math.ceil(file.size / CHUNK_SIZE);
const uploadId = `up_${Date.now()}_${Math.random().toString(36).substring(2, 6)}`;
const TOKEN = "TU_UPLOAD_TOKEN";
for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
const start = chunkIndex * CHUNK_SIZE;
const end = Math.min(start + CHUNK_SIZE, file.size);
const chunkBlob = file.slice(start, end);
const formData = new FormData();
formData.append("file", chunkBlob, file.name);
formData.append("chunkIndex", chunkIndex);
formData.append("totalChunks", totalChunks);
formData.append("uploadId", uploadId);
const res = await fetch("https://api.evogb.org/api/cdn/upload", {
method: "POST",
headers: { "x-upload-token": TOKEN },
body: formData
});
const data = await res.json();
if (!res.ok) throw new Error(data.error || "Fallo en la subida");
if (chunkIndex < totalChunks - 1) {
const currentChunk = data.current_chunk || (chunkIndex + 1);
const maxChunks = data.total_chunks || totalChunks;
const percent = Math.round((currentChunk / maxChunks) * 100);
if (onProgress) onProgress(percent, data);
} else {
console.log("✅ Archivo subido con éxito:", data.url);
if (onProgress) onProgress(100, data);
return data;
}
}
}{
"status": true,
"code": 200,
"current_chunk": 1,
"total_chunks": 12,
"message": "Chunk 1/12 procesado."
}{
"status": true,
"code": 200,
"id": 204,
"url": "https://cdn.evogb.org/Xy9K2.mp4",
"filename": "Xy9K2.mp4",
"original_name": "video_de_300mb.mp4",
"size_mb": 298.45,
"mime_type": "video/mp4",
"folder_id": 5
}Devuelve un Array JSON con la lista completa de archivos alojados en tu cuenta. Incluye metadatos técnicos, sociales (likes, tags) y de privacidad.
| Parámetro | Tipo | Obligatorio | Descripción |
|---|---|---|---|
folder_id | Integer / String | Opcional | Filtra los archivos por carpeta. Pasa el ID numérico (ej: 5), "root" o "null" para ver solo archivos en la raíz, o déjalo vacío para listar todos. |
const axios = require("axios");
async function listMyFiles() {
const res = await axios.get("https://api.evogb.org/api/cdn/files", {
headers: { "x-upload-token": "TU_UPLOAD_TOKEN" },
});
console.log(`📦 Total archivos: ${res.data.length}`);
console.log(res.data);
}
listMyFiles().catch((err) => {
console.error("❌ Error:", err.response?.data || err.message);
});import requests
url = "https://api.evogb.org/api/cdn/files"
headers = { "x-upload-token": "TU_UPLOAD_TOKEN" }
res = requests.get(url, headers=headers)
res.raise_for_status()
files = res.json()
print(f"📦 Total archivos: {len(files)}")
print(files)curl -X GET "https://api.evogb.org/api/cdn/files" \
-H "x-upload-token: TU_UPLOAD_TOKEN"[
{
"id": 108,
"file_uuid": "Xy9K2.jpg",
"original_name": "foto_portada.jpg",
"size_mb": 0.32,
"mime_type": "image/jpeg",
"upload_date": "2026-08-15T10:15:30.000Z",
"public_url": "https://cdn.evogb.org/Xy9K2.jpg",
"storage_path": "premium/Xy9K2.jpg",
"folder_id": 5,
"is_public": 1,
"likes": 12,
"is_pinned": 0,
"tags": "[\"banner\",\"portada\",\"2026\"]",
"is_sensitive": 0,
"is_public_suspended": 0
},
{
"id": 109,
"file_uuid": "7hKxS.webp",
"original_name": "grafico_reporte.webp",
"size_mb": 0.58,
"mime_type": "image/webp",
"upload_date": "2026-08-15T18:45:00.000Z",
"public_url": "https://cdn.evogb.org/7hKxS.webp",
"storage_path": "premium/7hKxS.webp",
"folder_id": null,
"is_public": 0,
"likes": 0,
"is_pinned": 1,
"tags": "[]",
"is_sensitive": 0,
"is_public_suspended": 0
}
]| Campo | Tipo | Descripción Técnica |
|---|---|---|
id | Integer | Identificador numérico único del archivo en la base de datos. |
file_uuid | String | Identificador único / nombre seguro del archivo en el sistema de almacenamiento. |
original_name | String | Nombre original del archivo proporcionado en el momento de la subida. |
size_mb | Float | Peso total del archivo medido en Megabytes (MB). |
mime_type | String | Tipo MIME validado del archivo (ej: image/jpeg, video/mp4, application/pdf). |
upload_date | String (ISO 8601) | Fecha y hora exacta en la que se completó la subida. |
public_url | String | Enlace HTTPS público directo servido a través de la red perimetral del CDN. |
storage_path | String | Ruta física interna del archivo en el almacenamiento seguro (ej: premium/Xy9K2.jpg). |
folder_id | Integer / null | ID de la carpeta virtual en la que está ubicado (o null si está en la raíz). |
is_public | Integer (0 o 1) | 1 si está publicado y visible en la Galería comunitaria, 0 si es privado. |
likes | Integer | Cantidad acumulada de "me gusta" recibidos por la comunidad. |
is_pinned | Integer (0 o 1) | 1 si el archivo está fijado en la parte superior del perfil público. |
tags | String (JSON Array) | Array serializado de etiquetas indexadas asociadas al archivo. |
is_sensitive | Integer (0 o 1) | 1 si el archivo contiene contenido marcado como sensible/NSFW. |
is_public_suspended | Integer (0 o 1) | 1 si la visibilidad pública en la galería fue pausada temporalmente por límite de ancho de banda. |
Obtén la metadata completa de un solo archivo mediante su ID numérico en la ruta URL.
const axios = require("axios");
async function getFileDetails(id) {
try {
const res = await axios.get(`https://api.evogb.org/api/cdn/files/${id}`, {
headers: { "x-upload-token": "TU_UPLOAD_TOKEN" },
});
const file = res.data.file;
console.log(`📂 Archivo: ${file.original_name}`);
console.log(`🔗 URL: ${file.public_url}`);
console.log(res.data);
} catch (err) {
console.error("❌ Error:", err.response?.data || err.message);
}
}
getFileDetails(108);import requests
file_id = 108
url = f"https://api.evogb.org/api/cdn/files/{file_id}"
headers = { "x-upload-token": "TU_UPLOAD_TOKEN" }
res = requests.get(url, headers=headers)
if res.status_code == 200:
data = res.json()
file_info = data.get("file", {})
print(f"📂 Archivo: {file_info.get('original_name')}")
print(f"🔗 URL: {file_info.get('public_url')}")
else:
print(f"❌ Error {res.status_code}:", res.text)curl -X GET "https://api.evogb.org/api/cdn/files/108" \
-H "x-upload-token: TU_UPLOAD_TOKEN"{
"status": true,
"code": 200,
"file": {
"id": 108,
"file_uuid": "Xy9K2.jpg",
"original_name": "foto_portada.jpg",
"size_mb": 0.32,
"mime_type": "image/jpeg",
"upload_date": "2026-08-15T10:15:30.000Z",
"public_url": "https://cdn.evogb.org/Xy9K2.jpg",
"storage_path": "premium/Xy9K2.jpg",
"folder_id": 5,
"is_public": 1,
"likes": 12,
"is_pinned": 0,
"tags": "[\"banner\",\"portada\",\"2026\"]",
"is_sensitive": 0,
"is_public_suspended": 0
}
}Consulta en tiempo real para monitorear el consumo de almacenamiento en disco, operaciones diarias de subida y descarga, estado del dominio personalizado y cuotas de Inteligencia Artificial.
| Bloque | Campo | Tipo | Descripción Técnica |
|---|---|---|---|
| Root | username | String | Nombre de usuario del titular de la cuenta. |
plan | String | Nombre comercial o ID del plan activo del usuario. | |
typePlan | String | Identificador técnico del plan (ej: free, lite, basic, pro, ultra, business). | |
| limits | storage_total_mb | Integer | Capacidad máxima de disco asignada al plan (en MB). |
upload_ops_limit | Integer | Tope diario de archivos que se pueden subir (se reinicia a las 04:00 AM). | |
download_ops_limit | Integer / String | Tope diario de descargas/visualizaciones permitidas (o "unlimited"). | |
max_file_size_mb | Integer | Peso máximo permitido por archivo individual (ej: 5 MB en Free, 125 MB en Pro, 2000 MB en Business). | |
allowed_mime_types | Array | Formatos de archivo permitidos. ["*/*"] indica sin restricción. | |
private_buckets | Boolean | Indica si el almacenamiento es aislado y dedicado. | |
expiring_links | Boolean | Indica si el plan tiene acceso a generación de enlaces temporales. | |
custom_domain | Boolean | Indica si el plan permite vincular un dominio personalizado propio con SSL automático. | |
retention_days | Integer / null | Días de retención automática de archivos (o null para almacenamiento permanente). | |
| ai_quota | used | Integer | Peticiones de Inteligencia Artificial consumidas en el ciclo actual. |
max | Integer | Límite máximo de peticiones de IA asignadas según el plan. | |
remaining | Integer | Peticiones de IA restantes disponibles para usar. | |
| usage | email | String | Correo electrónico del usuario. |
storage_used_mb | Float | Espacio en disco consumido actualmente (en MB). | |
upload_ops_daily | Integer | Contador de archivos subidos durante el día actual. | |
download_ops_daily | Integer | Contador de descargas/visualizaciones registradas hoy. | |
custom_domain | String / null | Dominio propio configurado (ej: "cdn.midominio.com") o null. | |
domain_status | String | Estado del dominio propio: configured, pending (validando SSL) o active (en producción). | |
last_reset_date | String (YYYY-MM-DD) | Fecha del último reinicio de contadores diarios. |
const axios = require("axios");
async function checkStats() {
const res = await axios.get("https://api.evogb.org/api/cdn/stats", {
headers: { "x-upload-token": "TU_UPLOAD_TOKEN" },
});
console.log(`📊 Almacenamiento: ${res.data.usage.storage_used_mb} MB / ${res.data.limits.storage_total_mb} MB`);
console.log(`🧠 Cuota de IA: ${res.data.ai_quota.used} / ${res.data.ai_quota.max} peticiones`);
console.log(`📥 Descargas Hoy: ${res.data.usage.download_ops_daily} / ${res.data.limits.download_ops_limit}`);
}
checkStats();{
"status": true,
"code": 200,
"username": "usuario_dev",
"plan": "Pro",
"typePlan": "pro",
"limits": {
"storage_total_mb": 25500,
"upload_ops_limit": 600,
"download_ops_limit": 150000,
"max_file_size_mb": 125,
"allowed_mime_types": ["*/*"],
"private_buckets": true,
"expiring_links": true,
"custom_domain": true,
"retention_days": null
},
"ai_quota": {
"used": 14,
"max": 80,
"remaining": 66
},
"usage": {
"email": "[email protected]",
"storage_used_mb": 4210.55,
"upload_ops_daily": 35,
"download_ops_daily": 1240,
"last_reset_date": "2026-08-16",
"custom_domain": "cdn.midominio.com",
"domain_status": "active"
}
}Eliminación definitiva de un archivo tanto de la base de datos como del almacenamiento en la nube y purga instantánea de la red de distribución global (CDN). Libera espacio en storage_used_mb inmediatamente.
| Parámetro | Tipo | Obligatorio | Descripción |
|---|---|---|---|
id | Integer | REQ | ID numérico del archivo que se desea eliminar (ej: 108). |
curl -X POST "https://api.evogb.org/api/cdn/delete" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 108 }'{
"status": true,
"code": 200,
"message": "Archivo eliminado correctamente."
}Permite consultar y configurar si los enlaces públicos generados deben ocultar el nombre de usuario o el nombre original del archivo (disponible para planes con soporte de personalización y privacidad).
| Parámetro | Tipo | Descripción |
|---|---|---|
hide_username | Boolean | true para omitir la subcarpeta de usuario en la URL generada (ej: cdn.evogb.org/Xy9K2.jpg). |
hide_filename | Boolean | true para usar únicamente un identificador único aleatorio en lugar del nombre original. |
const axios = require('axios');
// 1. Actualizar preferencias
await axios.post('https://api.evogb.org/api/user/cdn-prefs', {
hide_username: true,
hide_filename: false
}, {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});
// 2. Consultar preferencias actuales
const res = await axios.get('https://api.evogb.org/api/user/cdn-prefs', {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});
console.log("Preferencias CDN:", res.data);# Actualizar preferencias
curl -X POST "https://api.evogb.org/api/user/cdn-prefs" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{"hide_username": true, "hide_filename": false}'
# Obtener preferencias
curl -X GET "https://api.evogb.org/api/user/cdn-prefs" \
-H "x-upload-token: TU_UPLOAD_TOKEN"{
"status": true,
"code": 200,
"prefs": {
"hide_username": true,
"hide_filename": false
}
}| Propiedad | Tipo | Descripción |
|---|---|---|
status | Boolean | Indica si la solicitud fue procesada exitosamente (true / false). |
code | Integer | Código de estado HTTP de la respuesta (200). |
prefs.hide_username | Boolean | true si los enlaces públicos generados se crean en la raíz del CDN sin la carpeta del usuario. |
prefs.hide_filename | Boolean | true si los enlaces públicos generados ocultan el nombre original del archivo con un hash aleatorio. |
Organiza tus archivos en estructuras jerárquicas virtuales ilimitadas mediante código. Las carpetas permiten organizar proyectos, categorizar recursos y realizar operaciones recursivas en lote.
Devuelve todas las carpetas del usuario con su ruta calculada (path), cantidad de archivos contenidos (file_count) y peso acumulado en MB (total_size_mb).
const axios = require('axios');
async function listFolders() {
const res = await axios.get('https://api.evogb.org/api/cdn/folders', {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});
console.log(`📁 Total carpetas: ${res.data.total_folders}`);
console.log(res.data.folders);
}
listFolders();import requests
res = requests.get('https://api.evogb.org/api/cdn/folders', headers={'x-upload-token': 'TU_UPLOAD_TOKEN'})
data = res.json()
print(f"📁 Total carpetas: {data.get('total_folders')}")
for f in data.get('folders', []):
print(f" - [{f['id']}] {f['path']} ({f['file_count']} archivos, {f['total_size_mb']} MB)")curl -X GET "https://api.evogb.org/api/cdn/folders" \
-H "x-upload-token: TU_UPLOAD_TOKEN"{
"status": true,
"code": 200,
"total_folders": 2,
"folders": [
{
"id": 1,
"name": "proyectos",
"color": "#3b82f6",
"parent_id": null,
"path": "proyectos",
"file_count": 5,
"total_size_mb": 12.45,
"created_at": "2026-01-10T12:00:00.000Z"
},
{
"id": 2,
"name": "assets",
"color": "#10b981",
"parent_id": 1,
"path": "proyectos/assets",
"file_count": 8,
"total_size_mb": 4.10,
"created_at": "2026-01-11T15:30:00.000Z"
}
]
}| Propiedad | Tipo | Descripción Técnica |
|---|---|---|
status | Boolean | Indica si la consulta fue procesada con éxito (true / false). |
code | Integer | Código de estado HTTP de la respuesta (200). |
total_folders | Integer | Cantidad total de carpetas existentes en la cuenta. |
folders[].id | Integer | ID numérico único de la carpeta. |
folders[].name | String | Nombre asignado a la carpeta. |
folders[].parent_id | Integer / null | ID de la carpeta padre contenedora (o null si está en la raíz). |
folders[].color | String (Hex) | Color HEX distintivo asignado en el panel web. |
folders[].path | String | Ruta jerárquica virtual calculada (ej: "proyectos/assets"). |
folders[].file_count | Integer | Total de archivos almacenados directamente en esta carpeta. |
folders[].total_size_mb | Float | Peso total acumulado en MB de todos los archivos dentro de la carpeta. |
folders[].created_at | String (ISO 8601) | Fecha y hora de creación de la carpeta. |
Crea una carpeta individual o resuelve automáticamente una ruta anidada completa (ej: "app/frontend/icons").
| Parámetro | Tipo | Obligatorio | Descripción |
|---|---|---|---|
name | String | Condicional | Nombre de la carpeta simple (ej: "imagenes"). Requerido si no se envía path. |
path | String | Condicional | Ruta jerárquica (ej: "docs/2026/pdf"). Crea todos los ancestros inexistentes de forma automática. |
parent_id | Integer / null | Opcional | ID de la carpeta padre si se usa name. Enviar null para la raíz. |
color | String (Hex) | Opcional | Color HEX de identificación en el panel web (por defecto: #3b82f6). |
curl -X POST "https://api.evogb.org/api/cdn/folders" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "path": "sitio_web/v2/banners", "color": "#8b5cf6" }'{
"status": true,
"code": 200,
"folder": {
"id": 5,
"name": "banners",
"color": "#8b5cf6",
"parent_id": 2,
"created_at": "2026-08-16T00:00:00.000Z"
},
"created_by_path": true
}Permite renombrar la carpeta, cambiar su color o moverla de jerarquía mediante parent_id.
const axios = require('axios');
const res = await axios.put('https://api.evogb.org/api/cdn/folders/12', {
name: 'documentos_finales',
color: '#f59e0b',
parent_id: null // Mover a la raíz o a otra carpeta
}, {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});
console.log("Respuesta:", res.data);{
"status": true,
"code": 200,
"message": "Carpeta actualizada exitosamente.",
"folder": {
"id": 12,
"name": "documentos_finales",
"color": "#f59e0b",
"parent_id": null
}
}CUIDADO Elimina la carpeta indicada, todas sus subcarpetas de manera recursiva, y purga todos los archivos contenidos en ella de forma permanente del almacenamiento en la nube y de la red de distribución global (CDN), liberando el espacio de disco automáticamente.
curl -X DELETE "https://api.evogb.org/api/cdn/folders/12" \
-H "x-upload-token: TU_UPLOAD_TOKEN"{
"status": true,
"code": 200,
"message": "Carpeta y todos sus archivos eliminados correctamente.",
"deleted_folders_count": 3,
"deleted_files_count": 14,
"freed_storage_mb": 28.50
}Permite reubicar archivos o subárboles completos de carpetas con protección estricta contra ciclos infinitos.
POST /api/cdn/move)// Mover archivo por ID de carpeta o por ruta
const res = await axios.post('https://api.evogb.org/api/cdn/move', {
id: 108, // ID del archivo
folder_id: 5 // O pasar 'path': "proyectos/produccion"
}, {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});{
"status": true,
"code": 200,
"message": "Archivo movido correctamente.",
"file_id": 108,
"folder_id": 5
}POST /api/cdn/folders/move)const res = await axios.post('https://api.evogb.org/api/cdn/folders/move', {
id: 15, // ID de la carpeta a mover
parent_id: 3 // Nueva carpeta padre (o null para raíz)
}, {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});{
"status": true,
"code": 200,
"message": "Carpeta movida exitosamente.",
"id": 15,
"parent_id": 3
}Obtén en una sola consulta toda la estructura anidada de tus proyectos. Ideal para renderizar exploradores de archivos en tus propias aplicaciones, sincronizar sistemas locales o inspeccionar el CDN de forma completa.
| Parámetro | Tipo | Por Defecto | Descripción |
|---|---|---|---|
include_files | Boolean | false | Si es true, incluye el array files dentro de cada nodo de carpeta y root_files en la raíz. |
folder_id | Integer / null | null (Raíz) | Filtra el árbol para obtener únicamente el subárbol a partir de una carpeta específica. |
limit | Integer | 2000 (Max 5000) | Límite máximo de archivos retornados cuando include_files=true para optimizar rendimiento. |
const axios = require('axios');
async function getCdnTree() {
const res = await axios.get('https://api.evogb.org/api/cdn/tree?include_files=true', {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});
console.log("📊 Estadísticas del CDN:", res.data.stats);
console.log("🌳 Árbol Jerárquico:", JSON.stringify(res.data.tree, null, 2));
}
getCdnTree();import requests
res = requests.get('https://api.evogb.org/api/cdn/tree?include_files=true', headers={'x-upload-token': 'TU_UPLOAD_TOKEN'})
tree_data = res.json()
print("Stats:", tree_data['stats'])curl -X GET "https://api.evogb.org/api/cdn/tree?include_files=true" \
-H "x-upload-token: TU_UPLOAD_TOKEN"{
"status": true,
"code": 200,
"stats": {
"total_folders": 3,
"total_files": 42,
"root_files_count": 10,
"storage_used_mb": 85.32,
"storage_limit_mb": 2048,
"files_included": true
},
"tree": [
{
"id": 1,
"name": "frontend",
"color": "#3b82f6",
"path": "frontend",
"file_count": 12,
"total_size_mb": 25.10,
"children": [
{
"id": 2,
"name": "icons",
"color": "#10b981",
"path": "frontend/icons",
"file_count": 5,
"total_size_mb": 1.20,
"children": [],
"files": [
{
"id": 108,
"file_uuid": "7hKxS.svg",
"storage_path": "premium/7hKxS.svg",
"original_name": "logo.svg",
"public_name": "logo.svg",
"size_mb": 0.04,
"size_bytes": 41943,
"mime_type": "image/svg+xml",
"public_url": "https://cdn.evogb.org/7hKxS.svg",
"folder_id": 2,
"folder_path": "/frontend/icons",
"is_public": true,
"is_sensitive": false,
"tags": ["brand", "vector"]
}
]
}
],
"files": []
}
],
"root_files": [
{
"id": 101,
"file_uuid": "3mPqW.txt",
"storage_path": "premium/3mPqW.txt",
"original_name": "readme.txt",
"public_name": "readme.txt",
"size_mb": 0.01,
"mime_type": "text/plain",
"public_url": "https://cdn.evogb.org/3mPqW.txt",
"folder_id": null,
"folder_path": "/",
"is_public": true,
"is_sensitive": false,
"tags": ["documentation"]
}
]
}| Sección / Propiedad | Tipo | Descripción Técnica |
|---|---|---|
stats.total_folders | Integer | Total de carpetas creadas en la cuenta. |
stats.total_files | Integer | Total acumulado de archivos en todas las carpetas y raíz. |
stats.root_files_count | Integer | Cantidad de archivos ubicados en la raíz del CDN. |
stats.storage_used_mb | Float | Espacio de almacenamiento consumido actualmente en MB. |
stats.storage_limit_mb | Integer | Límite total de almacenamiento según el plan activo. |
tree[].children | Array | Subcarpetas anidadas recursivamente dentro del nodo actual. |
tree[].files | Array | Lista de archivos contenidos en esta carpeta (si include_files=true). |
root_files | Array | Lista de archivos ubicados en la raíz (si include_files=true y folder_id=null). |
Permite obtener la metadata completa de un archivo individual utilizando cualquiera de sus 3 identificadores soportados: id (numérico), file_uuid (nombre seguro) o storage_path (ruta física).
| Parámetro | Tipo | Obligatorio | Descripción |
|---|---|---|---|
id | Integer | Condicional | ID numérico del archivo en la base de datos (ej: 108). |
file_uuid | String | Condicional | UUID único del archivo (ej: "Xy9K2.jpg"). |
storage_path | String | Condicional | Ruta interna del archivo en el almacenamiento seguro (ej: "premium/Xy9K2.jpg" o "free/Xy9K2.jpg"). |
const axios = require('axios');
async function getFileInfo() {
// Consulta por ID, UUID o Storage Path
const res = await axios.get('https://api.evogb.org/api/cdn/file?id=108', {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});
console.log("📄 Metadata del Archivo:", res.data.file);
}
getFileInfo();import requests
res = requests.get('https://api.evogb.org/api/cdn/file?file_uuid=Xy9K2.jpg', headers={'x-upload-token': 'TU_UPLOAD_TOKEN'})
print(res.json())curl -X GET "https://api.evogb.org/api/cdn/file?id=108" \
-H "x-upload-token: TU_UPLOAD_TOKEN"{
"status": true,
"code": 200,
"file": {
"id": 108,
"file_uuid": "Xy9K2.jpg",
"storage_path": "premium/Xy9K2.jpg",
"original_name": "factura_enero.png",
"public_name": "factura_enero.png",
"size_mb": 0.45,
"size_bytes": 471859,
"mime_type": "image/png",
"upload_date": "2026-08-15T18:00:00.000Z",
"public_url": "https://cdn.evogb.org/Xy9K2.jpg",
"folder_id": 5,
"folder_path": "/Documentos/Facturas",
"is_public": true,
"is_sensitive": false,
"tags": ["factura", "contabilidad", "2026"]
}
}Aprovecha los modelos de inteligencia artificial multimodal de última generación integrados directamente con tu almacenamiento. Analiza imágenes, extrae texto mediante OCR, transcribe audios y videos, audita código fuente, extrae paletas cromáticas, modera contenidos y realiza búsquedas semánticas sin salir del CDN.
Las funciones de IA del CDN consumen la cuota diaria de peticiones asignada a tu plan (requests_ai). El procesamiento se realiza de forma privada y segura sobre tu almacenamiento cloud, permitiendo analizar archivos privados sin necesidad de exponerlos públicamente a internet.
Conoce con exactitud qué funciones descuentan de tu cuota diaria de IA y cuáles son totalmente ilimitadas:
| Endpoint / Función | Costo de Cuota | Métricas | Descripción |
|---|---|---|---|
POST /api/cdn/ai/analyze(describe, ocr, transcribe, code_refactor, summarize, palette, moderation, tags, custom) | 1 Request IA | Registrado | Suite multimodal: Visión artificial, OCR, transcripción de audio/video, refactorización de código, paletas, resúmenes y moderación. |
POST /api/cdn/ai/tag(Auto-etiquetado) | 1 Request IA | Registrado | Genera etiquetas semánticas y las guarda directamente en los metadatos del archivo para indexación. |
POST /api/cdn/ai/chat(Chat Neuronal) | 1 Request IA | Registrado | Interactúa con el asistente conversacional para desarrolladores autenticando con tu x-upload-token. |
POST /api/cdn/ai/search(Búsqueda Inteligente) | 0 Requests (Gratis) | Sin consumo | Búsqueda indexada de alta velocidad sobre nombres, carpetas, tipos de archivo y etiquetas generadas. |
GET /api/cdn/tree(Árbol de Carpetas/Archivos) | 0 Requests (Gratis) | Sin consumo | Estructuración y cálculo de árboles jerárquicos y estadísticas de carpetas. |
| Operaciones de Almacenamiento (upload, files, folders, move, delete, zip) | 0 Requests (Gratis) | Sin consumo | Todas las operaciones estándar de gestión de archivos y carpetas en la nube. |
• Auditoría de Código (code_refactor): Máximo 3 MB.
• Transcripción (transcribe): Audios y videos hasta 10 MB.
• Imágenes y Documentos: Máximo 10 MB.
• Objetivo de Análisis: Las tareas de IA aplican exclusivamente a archivos individuales. Enviar una carpeta retornará 400 Bad Request.
Al publicar un archivo en la Galería (POST /api/cdn/toggle-public), el sistema de moderación automática evalúa el archivo. Si detecta contenido explícito o sensible, activa is_sensitive = 1 difuminando el contenido para proteger la visualización pública.
{
"status": false,
"code": 429,
"error": "Has alcanzado el límite diario de peticiones de IA de tu plan.",
"details": {
"type": "user_limit_reached",
"current": 50,
"limit": 50,
"hours_until_reset": 6,
"plan": "lite",
"next_recommended_plan": "go"
}
}Ejecuta tareas inteligentes contextuales adaptadas al tipo de archivo almacenado en tu cuenta (imágenes, código, audios, videos y documentos) y retorna un JSON estructurado con el resultado del análisis.
Tarea (task) | Formatos Compatibles | Límite Máximo | Resultado Devuelto en JSON |
|---|---|---|---|
describe | Imágenes y Videos (PNG, JPG, WEBP, MP4, GIF, SVG) | Max 10 MB | Título conciso, descripción visual técnica, resumen de 1 frase, sujetos principales, colores dominantes y tono. |
ocr | Imágenes y Documentos (PNG, JPG, WEBP, PDF, TIFF, BMP) | Max 10 MB | Extracción completa de texto (OCR), idioma detectado, array de líneas/párrafos y nivel de confianza. |
transcribe (o transcription) | Audio y Video (MP3, WAV, OGG, M4A, MP4, WEBM, MKV, FLAC) | Max 10 MB | Transcripción completa de voz a texto, idioma detectado, resumen temático, estimación de ritmo y temas clave. |
code_refactor (o code_review, refactor) | Archivos de Código (JS, TS, PY, HTML, CSS, JSON, SQL, SH, PHP, CPP, RS, etc.) | Max 3 MB | Diagnóstico de arquitectura, detección de fallas (seguridad/rendimiento/estilo), código refactorizado y complejidad temporal. |
summarize | Documentos, Textos y Código (PDF, TXT, MD, CSV, Scripts) | Max 10 MB | Título representativo, resumen ejecutivo estructurado, puntos clave destacados (takeaways), tiempo de lectura y keywords. |
palette | Imágenes (PNG, JPG, WEBP, SVG, BMP) | Max 10 MB | Paleta cromática con valores HEX, nombres, porcentajes y roles (primary, secondary, accent, background), armonía y accesibilidad WCAG. |
moderation | Imágenes, Videos, Audios y Documentos | Max 10 MB | Evaluación de seguridad, banderas is_safe y is_sensitive, score NSFW (0.0 a 1.0), categorías y motivo descriptivo. |
tags | Todos los formatos soportados | Max 10 MB | Generación de 6 a 15 etiquetas semánticas para indexación. Si save_tags: true, se guardan en los metadatos del archivo. |
custom | Todos los formatos soportados | Max 10 MB | Ejecuta un prompt libre personalizado enviado en el parámetro prompt directamente contra el archivo multimedia o de texto. |
| Parámetro | Tipo | Obligatorio | Descripción |
|---|---|---|---|
id / file_id | Integer | Condicional | ID numérico del archivo individual registrado en tu cuenta de CDN. |
file_uuid | String | Condicional | UUID del archivo (ej: "k9xL2pQ.jpg"). |
storage_path | String | Condicional | Ruta del archivo en el almacenamiento (ej: "usuario/k9xL2pQ.jpg"). |
task | String | Opcional | Tarea a ejecutar (por defecto: "describe"). Valores válidos: "describe", "ocr", "transcribe", "code_refactor", "summarize", "palette", "moderation", "tags", "custom". |
prompt | String | Opcional | Instrucción personalizada requerida cuando task="custom" o para añadir contexto adicional a la tarea. |
save_tags | Boolean | Opcional | Si es true y la tarea genera etiquetas (o task="tags"), las guarda automáticamente en el registro del archivo. |
const axios = require('axios');
const CDN_API = 'https://api.evogb.org/api/cdn/ai/analyze';
const UPLOAD_TOKEN = 'TU_UPLOAD_TOKEN';
// Instancia configurada de Axios
const cdnClient = axios.create({
headers: {
'x-upload-token': UPLOAD_TOKEN,
'Content-Type': 'application/json'
}
});
async function runAiTasks() {
try {
// 1. Refactorización y Auditoría de Código
const codeAnalysis = await cdnClient.post(CDN_API, {
id: 310,
task: 'code_refactor'
});
console.log("🛠️ Código Refactorizado:\n", codeAnalysis.data.result.refactored_code);
console.log("📊 Cuota Restante:", codeAnalysis.data.ai_quota.remaining_today);
// 2. Transcripción de Audio / Video
const audioTrans = await cdnClient.post(CDN_API, {
id: 205,
task: 'transcribe'
});
console.log("🎙️ Idioma detectado:", audioTrans.data.result.detected_language);
console.log("📝 Transcripción:\n", audioTrans.data.result.transcription);
// 3. Extracción de Texto OCR desde Imagen o Factura
const ocrResult = await cdnClient.post(CDN_API, {
id: 142,
task: 'ocr'
});
console.log("📄 Texto OCR:\n", ocrResult.data.result.text);
// 4. Extracción de Paleta de Colores y Estilo
const paletteResult = await cdnClient.post(CDN_API, {
file_uuid: 'banner-hero.png',
task: 'palette'
});
console.log("🎨 Colores Dominantes:", paletteResult.data.result.dominant_palette);
// 5. Prompt Libre Personalizado
const customResult = await cdnClient.post(CDN_API, {
id: 520,
task: 'custom',
prompt: 'Enumera los 3 elementos visuales más llamativos y redacta un post promocional para esta imagen.'
});
console.log("✨ Resultado Personalizado:\n", customResult.data.result.output);
} catch (error) {
if (error.response) {
console.error(`❌ Error (${error.response.status}):`, error.response.data);
} else {
console.error("❌ Error de Conexión:", error.message);
}
}
}
runAiTasks();import requests
CDN_API = "https://api.evogb.org/api/cdn/ai/analyze"
HEADERS = {
"x-upload-token": "TU_UPLOAD_TOKEN",
"Content-Type": "application/json"
}
# 1. Moderación y Auditoría de Seguridad de Imagen/Video
mod_payload = {
"id": 618,
"task": "moderation"
}
res_mod = requests.post(CDN_API, json=mod_payload, headers=HEADERS)
data_mod = res_mod.json()
print("🛡️ ¿Es seguro?:", data_mod.get("result", {}).get("is_safe"))
print("⚠️ Score NSFW:", data_mod.get("result", {}).get("nsfw_score"))
# 2. Resumen Ejecutivo de un PDF o Documento
sum_payload = {
"file_uuid": "informe-anual.pdf",
"task": "summarize"
}
res_sum = requests.post(CDN_API, json=sum_payload, headers=HEADERS)
data_sum = res_sum.json()
print("📑 Resumen Ejecutivo:\n", data_sum.get("result", {}).get("executive_summary"))
print("🔑 Puntos Clave:", data_sum.get("result", {}).get("key_takeaways"))
# 3. Auto-etiquetado con guardado automático en metadatos
tags_payload = {
"id": 720,
"task": "tags",
"save_tags": True
}
res_tags = requests.post(CDN_API, json=tags_payload, headers=HEADERS)
print("🏷️ Tags Generados:", res_tags.json().get("result", {}).get("tags"))async function analyzeFileInBrowser(fileId, taskName = 'describe') {
const response = await fetch('https://api.evogb.org/api/cdn/ai/analyze', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-upload-token': 'TU_UPLOAD_TOKEN'
},
body: JSON.stringify({
id: fileId,
task: taskName,
save_tags: true
})
});
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.error || `HTTP ${response.status}`);
}
const data = await response.json();
console.log("✅ Análisis completado:", data);
return data.result;
}
// Ejemplo de uso:
// analyzeFileInBrowser(108, 'ocr').then(result => console.log(result.text));# 1. Tarea: describe (Descripción visual profunda de imagen/video)
curl -X POST "https://api.evogb.org/api/cdn/ai/analyze" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 135, "task": "describe" }'
# 2. Tarea: palette (Extracción de paleta cromática de colores HEX)
curl -X POST "https://api.evogb.org/api/cdn/ai/analyze" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 163, "task": "palette" }'
# 3. Tarea: ocr (Extracción de texto en documentos o fotos)
curl -X POST "https://api.evogb.org/api/cdn/ai/analyze" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 135, "task": "ocr" }'
# 4. Tarea: transcribe (Transcripción inteligente de audio o video)
curl -X POST "https://api.evogb.org/api/cdn/ai/analyze" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 137, "task": "transcribe" }'
# 5. Tarea: code_refactor (Auditoría y optimización de código fuente)
curl -X POST "https://api.evogb.org/api/cdn/ai/analyze" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 156, "task": "code_refactor" }'
# 6. Tarea: summarize (Resumen ejecutivo y puntos clave)
curl -X POST "https://api.evogb.org/api/cdn/ai/analyze" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 156, "task": "summarize" }'
# 7. Tarea: moderation (Detección de contenido sensible y NSFW score)
curl -X POST "https://api.evogb.org/api/cdn/ai/analyze" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 165, "task": "moderation" }'
# 8. Tarea: tags (Generación de etiquetas contextuales en memoria)
curl -X POST "https://api.evogb.org/api/cdn/ai/analyze" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 163, "task": "tags" }'
# 9. Tarea: custom (Instrucción / Prompt libre sobre cualquier archivo)
curl -X POST "https://api.evogb.org/api/cdn/ai/analyze" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 156, "task": "custom", "prompt": "Explica la arquitectura de este archivo y sus dependencias." }'Selecciona la tarea para inspeccionar la estructura exacta del JSON devuelto en la propiedad result:
{
"status": true,
"code": 200,
"task": "describe",
"file_id": 108,
"original_name": "hero-dashboard-banner.png",
"mime_type": "image/png",
"result": {
"title": "Banner promocional futurista de panel de control en la nube",
"description": "Una composición digital moderna que muestra una interfaz gráfica holográfica en modo oscuro con paneles de analítica, gráficos de línea en tono violeta y cian brillante, métricas de rendimiento del servidor y partículas de datos flotantes.",
"summary": "Banner publicitario de alta tecnología enfocado en soluciones de computación en la nube y monitoreo en tiempo real.",
"subjects": [
"interfaz de usuario dark mode",
"gráficos interactivos",
"nube de datos conectada",
"paneles de analítica"
],
"dominant_colors": [
"#0f172a",
"#3b82f6",
"#8b5cf6",
"#06b6d4"
],
"mood": "tecnológico, sofisticado, dinámico y profesional"
},
"ai_quota": {
"remaining_today": 49,
"daily_limit": 50
}
}{
"status": true,
"code": 200,
"task": "ocr",
"file_id": 142,
"original_name": "recibo-servicio-hosting.png",
"mime_type": "image/png",
"result": {
"text": "INVOICE #INV-2026-8819\nFecha de emisión: 15 de Agosto de 2026\nCliente: Tech Solutions Latam S.A.\nRUT/ID: 1792348910001\nDescripción: Suscripción Plan Pro Anual Almacenamiento Cloud\nSubtotal: $120.00 USD\nIVA (15%): $18.00 USD\nTotal Pagado: $138.00 USD\nEstado: COMPLETADO (Aprobado)",
"detected_language": "es",
"lines": [
"INVOICE #INV-2026-8819",
"Fecha de emisión: 15 de Agosto de 2026",
"Cliente: Tech Solutions Latam S.A.",
"RUT/ID: 1792348910001",
"Descripción: Suscripción Plan Pro Anual Almacenamiento Cloud",
"Subtotal: $120.00 USD",
"IVA (15%): $18.00 USD",
"Total Pagado: $138.00 USD",
"Estado: COMPLETADO (Aprobado)"
],
"confidence": "alto"
},
"ai_quota": {
"remaining_today": 48,
"daily_limit": 50
}
}{
"status": true,
"code": 200,
"task": "transcribe",
"file_id": 205,
"original_name": "reunion-sincronizacion.mp3",
"mime_type": "audio/mpeg",
"result": {
"transcription": "Hola equipo. En la sesión de hoy confirmamos que la integración de la suite de IA del CDN ya soporta procesamiento directo sobre archivos privados sin necesidad de exponerlos a internet. Todos los desarrolladores pueden autenticar con su upload token mediante headers o query params. La cuota diaria se descuenta por cada petición exitosa y la respuesta incluye el balance en tiempo real.",
"detected_language": "es",
"summary": "Reunión técnica confirmando la arquitectura de seguridad y autenticación de la suite de IA sobre almacenamiento cloud.",
"duration_estimate": "45 segundos",
"speakers_count": 1,
"key_topics": [
"Almacenamiento Seguro",
"Suite de IA CDN",
"Upload Token",
"Cuotas Diarias",
"Archivos Privados"
]
},
"ai_quota": {
"remaining_today": 47,
"daily_limit": 50
}
}{
"status": true,
"code": 200,
"task": "code_refactor",
"file_id": 310,
"original_name": "data-processor.js",
"mime_type": "application/javascript",
"result": {
"language": "javascript",
"analysis": "El script original contenía variables no declaradas en el scope global, búsquedas anidadas ineficientes de complejidad cuadrática O(N^2) y falta de control de excepciones en llamadas asíncronas.",
"issues": [
{
"type": "performance",
"severity": "high",
"description": "Bucle con búsqueda recursiva Array.find() en cada iteración provocando cuello de botella de CPU.",
"line_reference": 18
},
{
"type": "security",
"severity": "medium",
"description": "Falta de sanitización en el parámetro de entrada antes de procesar los registros.",
"line_reference": 34
}
],
"refactored_code": "export async function processRecords(items = [], lookupMap = new Map()) {\n if (!Array.isArray(items)) throw new TypeError('items must be an array');\n \n return items.map(item => ({\n id: item.id,\n name: String(item.name).trim(),\n metadata: lookupMap.get(item.id) || null,\n processedAt: new Date().toISOString()\n }));\n}",
"improvements": [
"Optimización de complejidad temporal de O(N^2) a O(N) mediante Map lookup",
"Manejo defensivo de tipos y parámetros por defecto seguros",
"Migración estricta a sintaxis moderna ES Modules"
],
"time_complexity": "Original: O(N^2) -> Refactorizado: O(N)"
},
"ai_quota": {
"remaining_today": 46,
"daily_limit": 50
}
}{
"status": true,
"code": 200,
"task": "summarize",
"file_id": 415,
"original_name": "reporte-optimizacion-web.pdf",
"mime_type": "application/pdf",
"result": {
"title": "Informe de Optimización y Entrega Global de Medios 2026",
"executive_summary": "Evaluación técnica de la adopción de arquitecturas de entrega rápida en el borde para activos digitales. La optimización redujo los tiempos de carga en un 68% y mejoró las tasas de conversión mediante compresión inteligente de imágenes y distribución Anycast.",
"key_takeaways": [
"Distribución de contenidos en el borde para mínima latencia.",
"Aceleración de carga de medios a través de nodos de presencia global.",
"Procesamiento inteligente de IA para catalogación automática.",
"Capacidad de almacenamiento escalable con alta redundancia."
],
"estimated_reading_time": 3,
"language": "es",
"keywords": [
"optimizacion",
"rendimiento web",
"latencia",
"entrega global",
"ia multimodal"
]
},
"ai_quota": {
"remaining_today": 45,
"daily_limit": 50
}
}{
"status": true,
"code": 200,
"task": "palette",
"file_id": 512,
"original_name": "branding-logo-dark.png",
"mime_type": "image/png",
"result": {
"dominant_palette": [
{
"hex": "#0a0e1a",
"name": "Deep Space Navy",
"percentage_approx": 48,
"role": "background"
},
{
"hex": "#3b82f6",
"name": "Electric Royal Blue",
"percentage_approx": 26,
"role": "primary"
},
{
"hex": "#8b5cf6",
"name": "Neon Violet",
"percentage_approx": 16,
"role": "accent"
},
{
"hex": "#f8fafc",
"name": "Pure Snow White",
"percentage_approx": 10,
"role": "secondary"
}
],
"color_harmony": "análoga / fría de alto contraste",
"aesthetic_style": "dark mode moderno / fintech futurista",
"accessibility_notes": "Excelente ratio de contraste (13.8:1) entre el fondo #0a0e1a y el texto #f8fafc, cumpliendo con la certificación WCAG AAA para legibilidad web."
},
"ai_quota": {
"remaining_today": 44,
"daily_limit": 50
}
}{
"status": true,
"code": 200,
"task": "moderation",
"file_id": 618,
"original_name": "avatar-comunidad-usuario.jpg",
"mime_type": "image/jpeg",
"result": {
"is_safe": true,
"is_sensitive": false,
"nsfw_score": 0.02,
"categories": {
"adult": "unlikely",
"violence": "unlikely",
"racy": "unlikely"
},
"reason": "La imagen corresponde a un retrato fotográfico convencional en exteriores sin elementos sugerentes, armas ni violencia explícita."
},
"ai_quota": {
"remaining_today": 43,
"daily_limit": 50
}
}{
"status": true,
"code": 200,
"task": "custom",
"file_id": 810,
"original_name": "database-schema.sql",
"mime_type": "text/plain",
"result": {
"output": "El esquema de base de datos analizado define adecuadamente 4 tablas relacionales con claves foráneas en cascada. Se recomienda agregar un índice compuesto en (usuario_id, fecha_registro) para optimizar las consultas analíticas y el filtrado temporal frecuente."
},
"ai_quota": {
"remaining_today": 41,
"daily_limit": 50
}
}// Error 400: Se intentó analizar una carpeta en lugar de un archivo individual
{
"status": false,
"code": 400,
"error": "Las funciones de IA y análisis profundo solo aplican para archivos individuales, no para carpetas.",
"supported_target": "file_id | file_uuid | storage_path"
}
// Error 400: Tarea incompatible con el tipo de archivo (ej. transcribe en imagen)
{
"status": false,
"code": 400,
"error": "La tarea 'transcribe' solo es compatible con archivos de audio o video (ej. MP3, WAV, OGG, MP4, WEBM). El archivo actual es de categoría 'image'."
}
// Error 401: Token de autenticación ausente o incorrecto
{
"status": false,
"code": 401,
"error": "Upload token inválido o no existe."
}
// Error 403: Cuenta suspendida o acceso restringido
{
"status": false,
"code": 403,
"error": "Tu acceso a la IA ha sido bloqueado."
}
// Error 404: El archivo solicitado no existe en tu cuenta
{
"status": false,
"code": 404,
"error": "Archivo no encontrado o no tienes permisos para acceder a él."
}
// Error 413: Archivo excede el límite de tamaño permitido para IA
{
"status": false,
"code": 413,
"error": "El archivo es demasiado pesado para el análisis de IA. El límite actual es de 10 MB."
}
// Error 429: Cuota diaria de peticiones de IA de tu plan agotada
{
"status": false,
"code": 429,
"error": "Has alcanzado el límite diario de peticiones de IA de tu plan.",
"details": {
"type": "user_limit_reached",
"current": 50,
"limit": 50,
"hours_until_reset": 6,
"plan": "lite",
"next_recommended_plan": "go"
}
}
// Error 500: Fallo temporal del motor de procesamiento de IA
{
"status": false,
"code": 500,
"error": "Error al procesar el archivo con el motor de IA.",
"message": "Todos los modelos de la suite de IA fallaron al procesar el archivo."
}Atajo directo para clasificar y generar entre 6 y 15 etiquetas semánticas y guardarlas automáticamente en los metadatos del archivo para acelerar la búsqueda indexada.
| Parámetro | Tipo | Obligatorio | Descripción |
|---|---|---|---|
id / file_id | Integer | Condicional | ID del archivo individual en el CDN. |
file_uuid | String | Condicional | UUID del archivo (ej: "k9xL2pQ.jpg"). |
storage_path | String | Condicional | Ruta en almacenamiento seguro (ej: "usuario/k9xL2pQ.jpg"). |
const axios = require('axios');
async function autoTagFile(fileId) {
try {
const res = await axios.post('https://api.evogb.org/api/cdn/ai/tag', {
id: fileId
}, {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});
console.log("🏷️ Tags guardados:", res.data.result.tags);
console.log("📊 Cuota restante:", res.data.ai_quota.remaining_today);
} catch (error) {
console.error("❌ Error en auto-tag:", error.response?.data || error.message);
}
}
autoTagFile(108);import requests
res = requests.post('https://api.evogb.org/api/cdn/ai/tag',
json={'id': 108},
headers={'x-upload-token': 'TU_UPLOAD_TOKEN'}
)
if res.status_code == 200:
print("🏷️ Tags guardados:", res.json()['result']['tags'])
else:
print("❌ Error:", res.json())fetch('https://api.evogb.org/api/cdn/ai/tag', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-upload-token': 'TU_UPLOAD_TOKEN'
},
body: JSON.stringify({ id: 108 })
})
.then(res => res.json())
.then(data => {
if (data.status) console.log("Tags:", data.result.tags);
else console.error("Error:", data.error);
});curl -X POST "https://api.evogb.org/api/cdn/ai/tag" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 108 }'{
"status": true,
"code": 200,
"task": "tags",
"file_id": 108,
"original_name": "paisaje-montana-4k.webp",
"mime_type": "image/webp",
"result": {
"tags": [
"paisaje",
"naturaleza",
"montañas",
"atardecer",
"wallpaper",
"outdoor",
"sunset",
"4k wallpaper",
"turismo"
]
},
"ai_quota": {
"remaining_today": 49,
"daily_limit": 50
}
}| Campo | Tipo | Descripción Técnica |
|---|---|---|
status | Boolean | Indica si el proceso de auto-etiquetado se ejecutó exitosamente (true / false). |
code | Integer | Código de estado HTTP devuelto (ej: 200). |
task | String | Tipo de tarea de IA ejecutada ("tags"). |
file_id | Integer | ID numérico del archivo analizado y enriquecido. |
original_name | String | Nombre original del archivo procesado. |
mime_type | String | Tipo MIME validado del archivo. |
result.tags | Array (Strings) | Lista de etiquetas semánticas inferidas por el modelo neuronal y guardadas en la base de datos. |
ai_quota.remaining_today | Integer | Peticiones de IA restantes disponibles para el día en curso. |
ai_quota.daily_limit | Integer | Límite máximo de peticiones de IA asignadas según el plan activo. |
Permite buscar archivos y recursos mediante lenguaje natural. El motor escanea de forma simultánea los nombres de archivo, nombres de carpetas, formatos MIME y todas las etiquetas generadas previamente por la IA. No consume cuota diaria de IA (0 requests / Gratis) ya que opera sobre índices de búsqueda optimizados de tu cuenta.
| Parámetro | Tipo | Obligatorio | Descripción |
|---|---|---|---|
query | String | REQ | Término, palabra clave o concepto a buscar (ej: "factura electronica pdf", "dark mode ui"). |
limit | Integer | Opcional | Cantidad máxima de resultados (1 a 100, por defecto: 30). |
const axios = require('axios');
async function searchCdn(queryText) {
try {
const res = await axios.post('https://api.evogb.org/api/cdn/ai/search', {
query: queryText,
limit: 20
}, {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});
console.log(`🔍 Coincidencias encontradas: ${res.data.count}`);
res.data.results.forEach(file => {
console.log(`- [${file.id}] ${file.original_name} (${file.folder_name || 'Raíz'}) -> ${file.public_url}`);
console.log(` Tags: ${file.tags.join(', ')}`);
});
} catch (err) {
console.error("❌ Error en búsqueda:", err.response?.data || err.message);
}
}
searchCdn('diseño dark mode');import requests
res = requests.post('https://api.evogb.org/api/cdn/ai/search', json={
'query': 'recibo factura pdf',
'limit': 10
}, headers={'x-upload-token': 'TU_UPLOAD_TOKEN'})
if res.status_code == 200:
data = res.json()
print(f"Total encontrados: {data['count']}")
for file in data['results']:
print(f"- {file['original_name']} | URL: {file['public_url']}")
else:
print("❌ Error:", res.json())fetch('https://api.evogb.org/api/cdn/ai/search', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-upload-token': 'TU_UPLOAD_TOKEN'
},
body: JSON.stringify({
query: 'banner promocional',
limit: 15
})
})
.then(res => res.json())
.then(data => console.log(data.results));curl -X POST "https://api.evogb.org/api/cdn/ai/search" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "query": "dashboard ui", "limit": 10 }'{
"status": true,
"code": 200,
"query": "diseño dark mode",
"count": 2,
"results": [
{
"id": 108,
"file_uuid": "k9xL2pQ.png",
"original_name": "dashboard-preview.png",
"size_mb": 1.45,
"mime_type": "image/png",
"public_url": "https://cdn.evogb.org/k9xL2pQ.png",
"folder_id": 4,
"folder_name": "Assets UI",
"tags": [
"dashboard",
"dark mode",
"ui design",
"graficos",
"analytics"
],
"upload_date": "2026-08-15 18:30:22"
},
{
"id": 115,
"file_uuid": "v8mZ1aB.png",
"original_name": "hero-dark.png",
"size_mb": 2.10,
"mime_type": "image/png",
"public_url": "https://cdn.evogb.org/v8mZ1aB.png",
"folder_id": null,
"folder_name": null,
"tags": [
"hero banner",
"dark mode",
"fondo tecnologico"
],
"upload_date": "2026-08-14 11:20:10"
}
]
}| Campo | Tipo | Descripción Técnica |
|---|---|---|
status | Boolean | Indica si la búsqueda se completó correctamente (true / false). |
code | Integer | Código de estado HTTP devuelto (ej: 200). |
query | String | Término o concepto semántico consultado. |
count | Integer | Total de archivos encontrados que coincidieron con los criterios. |
results[].id | Integer | ID numérico del archivo encontrado. |
results[].file_uuid | String | UUID o identificador único del archivo. |
results[].original_name | String | Nombre original del archivo. |
results[].size_mb | Float | Peso del archivo en Megabytes (MB). |
results[].mime_type | String | Tipo MIME validado del archivo. |
results[].public_url | String | Enlace público directo HTTPS para consumir el recurso. |
results[].folder_id | Integer / null | ID de la carpeta en la que está ubicado (o null para la raíz). |
results[].folder_name | String / null | Nombre legible de la carpeta contenedora. |
results[].tags | Array (Strings) | Etiquetas indexadas que activaron la coincidencia semántica. |
results[].upload_date | String | Fecha en la que fue subido el archivo. |
Permite integrar el asistente de inteligencia artificial conversacional directamente en tus aplicaciones, bots de Discord/WhatsApp/Telegram o scripts de terminal, autenticando fácilmente con tu x-upload-token.
| Parámetro | Tipo | Obligatorio | Descripción |
|---|---|---|---|
message | String | REQ | Mensaje, pregunta o instrucción enviada al modelo neuronal. Límite de caracteres adaptado a tu plan (hasta 10,000 chars en planes Pro/Ultra). |
model | String | Opcional | Identificador del modelo de IA a emplear (por defecto: "ai-evogb-pro"). Consulta la tabla inferior de modelos disponibles. |
system_prompt | String | Opcional | Instrucción de sistema para definir el rol, tono o personalidad del asistente (ej: "Eres un arquitecto backend senior..."). |
history | Array | Opcional | Historial previo de mensajes [{ role: 'user', content: '...' }, { role: 'assistant', content: '...' }] para mantener contexto continuo. |
Puedes elegir el modelo que mejor se adapte a tu caso de uso pasando su código en el parámetro model. Haz clic en el botón de copiar para copiar el identificador exacto:
| Código del Modelo | Especialidad / Perfil | Velocidad | Casos de Uso Recomendados |
|---|---|---|---|
ai-evogb-pro ⭐ Recomendado | Multimodal General Equilibrio óptimo | Rápida (~350ms) | Modelo estándar recomendado por defecto. Ideal para chatbots, asistentes de atención, extracción de datos, redacción y consultas generales. |
ai-evogb-ultra | Razonamiento Profundo Máxima potencia | Profunda (~750ms) | Análisis arquitectónico de sistemas, resolución de problemas complejos de múltiples pasos, deducción científica y toma de decisiones crítica. |
ai-evogb-titan | Alto Rendimiento Procesamiento masivo | Balanceada (~500ms) | Procesamiento y condensación de grandes volúmenes de texto, análisis de reportes corporativos y flujos de automatización pesados. |
ai-evogb-core | Ultra Rápido Mínima latencia | Instantánea (~180ms) | Autocompletados en tiempo real, validación de formularios, clasificación de intención y microservicios de respuesta inmediata. |
ai-evogb-logic-v1 | Lógica & Algoritmos Deducción paso a paso | Precisa (~650ms) | Resolución de algoritmos, análisis de expresiones matemáticas, depuración lógica y demostraciones estructuradas. |
ai-evogb-logic-v2 | Analítica Avanzada Modelado formal | Profunda (~700ms) | Auditoría de consistencia en esquemas, análisis inferencial y validación rigurosa de condiciones lógicas complejas. |
ai-evogb-agile-v1 | Respuestas Directas Sin rodeos | Muy Rápida (~220ms) | Bots de comandos en Discord, WhatsApp, Telegram, scripts CLI y respuestas formateadas en JSON / Markdown limpio. |
ai-evogb-agile-v2 | Diálogo Interactivo Flujo conversacional | Rápida (~280ms) | Agentes conversacionales con memoria de contexto, asistentes de soporte técnico interactivo y roles personalizados. |
ai-evogb-flash-v1 | Latencia Crítica Inferencia relámpago | Ultra Baja (~150ms) | Sistemas de alta concurrencia, traducción en tiempo real, detección de idioma y respuestas síncronas. |
ai-evogb-flash-v2 | Inferencia Sintética Alta eficiencia | Ultra Baja (~180ms) | Generación de resúmenes de 1 línea, notificaciones automáticas push y moderación previa de textos. |
ai-evogb-prime-v1 | Redacción Creativa Prosa enriquecida | Rápida (~400ms) | Copywriting publicitario, redacción de correos profesionales, blogs, guiones para redes y narrativas estilizadas. |
ai-evogb-prime-v2 | Comprensión & Síntesis Análisis de documentos | Balanceada (~450ms) | Extracción de ideas principales, síntesis de minutas de reuniones y reestructuración de textos informativos. |
ai-evogb-omega-v1 | Contexto Extenso Memoria de largo alcance | Moderada (~600ms) | Análisis de manuales completos, flujos de conversación extensos con historial y extracción de múltiples variables interconectadas. |
ai-evogb-omega-v2 | Ingeniería & Código Políglota técnico | Balanceada (~500ms) | Generación, corrección y documentación de código en JavaScript, TypeScript, Python, Go, Rust, PHP, SQL, Shell, C++ y más. |
ai-evogb-legacy | Compatibilidad Flujos estándar | Estable (~450ms) | Compatibilidad continua con integraciones y aplicaciones legacy configuradas previamente. |
const axios = require('axios');
async function askNeuralBot() {
try {
const res = await axios.post('https://api.evogb.org/api/cdn/ai/chat', {
message: '¿Cómo puedo estructurar un pipeline de compresión y subida por lotes en Node.js usando la API del CDN?',
model: 'ai-evogb-pro',
system_prompt: 'Eres un senior backend architect especializado en APIs cloud de alto rendimiento.'
}, {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});
console.log("🤖 Respuesta del Asistente:\n", res.data.response || res.data.message);
if (res.data.tokens_used) {
console.log("📊 Tokens Usados:", res.data.tokens_used);
}
} catch (err) {
console.error("❌ Error en chat:", err.response?.data || err.message);
}
}
askNeuralBot();import requests
res = requests.post('https://api.evogb.org/api/cdn/ai/chat', json={
'message': '¿Cuáles son las mejores prácticas para optimizar imágenes y videos antes de subirlos a la API?',
'model': 'ai-evogb-pro',
'system_prompt': 'Eres un experto en optimización web y entrega de medios.'
}, headers={'x-upload-token': 'TU_UPLOAD_TOKEN'})
if res.status_code == 200:
print("🤖 Respuesta:\n", res.json().get('response'))
else:
print("❌ Error:", res.json())curl -X POST "https://api.evogb.org/api/cdn/ai/chat" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"message": "Hola, ¿cuáles son los límites de tamaño para el análisis de IA de imágenes en el CDN?",
"model": "ai-evogb-pro"
}'{
"status": true,
"code": 200,
"reply": "En el CDN de Evogb, los límites de tamaño para el análisis de IA son los siguientes:\n• Imágenes y Documentos: Hasta 10 MB.\n• Audios y Videos (Transcripción): Hasta 10 MB.\n• Archivos de Código (Auditoría): Hasta 3 MB.\n\nTodos los análisis se procesan directamente sobre tu almacenamiento seguro sin necesidad de exponer tus archivos públicamente.",
"response": "En el CDN de Evogb, los límites de tamaño para el análisis de IA son los siguientes:\n• Imágenes y Documentos: Hasta 10 MB.\n• Audios y Videos (Transcripción): Hasta 10 MB.\n• Archivos de Código (Auditoría): Hasta 3 MB.\n\nTodos los análisis se procesan directamente sobre tu almacenamiento seguro sin necesidad de exponer tus archivos públicamente.",
"used_model": "ai-evogb-pro",
"tokens": {
"prompt": 38,
"completion": 74,
"total": 112
}
}| Campo | Tipo | Descripción Técnica |
|---|---|---|
status | Boolean | Indica si la inferencia neuronal se completó de manera satisfactoria (true / false). |
code | Integer | Código de estado HTTP de la respuesta (ej: 200). |
reply | String | Texto de respuesta generado por el modelo de IA seleccionado. |
response | String | Alias compatible con el texto de respuesta generado. |
used_model | String | Identificador del modelo que procesó la respuesta (ej: "ai-evogb-pro"). |
tokens.prompt | Integer | Cantidad de tokens computados a partir del mensaje y contexto enviados. |
tokens.completion | Integer | Cantidad de tokens producidos en la respuesta generada. |
tokens.total | Integer | Total global de tokens computados durante la sesión de inferencia. |
Comprime y descarga paquetes ZIP completos respetando las jerarquías de carpetas, o genera archivos comprimidos directamente en la nube.
Genera en streaming continuo un archivo ZIP con todos los archivos y subcarpetas seleccionados para guardarlo directamente en tu disco local.
| Parámetro | Tipo | Obligatorio | Descripción |
|---|---|---|---|
mode | String | REQ | "selected" para IDs específicos o "folder" para comprimir toda una carpeta. |
folderIds | Array (Integers) | Opcional | IDs de las carpetas a incluir recursivamente en el archivo ZIP. |
fileIds | Array (Integers) | Opcional | IDs de archivos específicos sueltos para empaquetar. |
const axios = require('axios');
const fs = require('fs');
async function downloadBackup() {
const response = await axios.post('https://api.evogb.org/api/cdn/backup/generate', {
mode: 'selected',
folderIds: [1, 2],
fileIds: [105, 108]
}, {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' },
responseType: 'stream'
});
response.data.pipe(fs.createWriteStream('./backup_cdn.zip'));
console.log("✅ Descarga de backup iniciada.");
}
downloadBackup();Empaqueta los archivos seleccionados en un .zip directamente en los servidores del CDN y lo almacena de forma permanente en tu cuenta, devolviendo la URL pública del archivo comprimido generado.
| Parámetro | Tipo | Obligatorio | Descripción |
|---|---|---|---|
folderIds | Array (Integers) | Opcional | IDs de las carpetas que se deben empaquetar recursivamente. |
fileIds | Array (Integers) | Opcional | IDs de archivos individuales para comprimir en el ZIP. |
const axios = require('axios');
const res = await axios.post('https://api.evogb.org/api/cdn/compress', {
folderIds: [1],
fileIds: [102, 103]
}, {
headers: { 'x-upload-token': 'TU_UPLOAD_TOKEN' }
});
console.log("🔗 URL del ZIP generado:", res.data.url);{
"status": true,
"code": 200,
"url": "https://cdn.evogb.org/evogb_1771123456789.zip"
}| Campo | Tipo | Descripción Técnica |
|---|---|---|
status | Boolean | true si el archivo ZIP fue generado y almacenado en el CDN con éxito. |
code | Integer | Código de estado HTTP devuelto (200). |
url | String | Enlace HTTPS público directo para acceder y descargar el archivo comprimido. |
La API utiliza códigos HTTP estrictos para indicar el éxito o fallo de una solicitud.
| Código | Error | Causa Probable | Solución |
|---|---|---|---|
| 400 | Bad Request | Token de ejemplo o falta ID. | Usa tu token real y verifica el Body. |
| 401 | Unauthorized | Token faltante o incorrecto. | Verifica el header x-upload-token. |
| 403 | Forbidden | Almacenamiento lleno o archivo ajeno. | No puedes borrar archivos de otros usuarios. |
| 404 | Not Found | ID de archivo inexistente. | El ID ingresado no existe en la base de datos. |
| 413 | Payload Too Large | Archivo supera el peso máximo. | Comprime el archivo o sube de plan. |
| 415 | Unsupported Media Type | El tipo de archivo no está permitido. | Asegurarse de subir archivos según tú plan. |
| 429 | Too Many Requests | Límite diario de operaciones. | Espera a las 04:00 AM o mejora plan. |
| 500 | Server Error | Fallo interno. | Intenta de nuevo o contacta soporte. |
Copia y pega estos ejemplos para integrar Evogb Cloud rápidamente en tus proyectos.
Recomendamos usar axios y form-data.
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const API_URL = 'https://api.evogb.org/api/cdn';
const TOKEN = 'TU_UPLOAD_TOKEN';
const api = axios.create({
baseURL: API_URL,
headers: { 'x-upload-token': TOKEN }
});async function uploadFile() {
try {
const form = new FormData();
form.append("file", fs.createReadStream("./gato.jpg"));
const res = await api.post("/upload", form, {
headers: {
...form.getHeaders(),
"x-upload-token": TOKEN,
},
});
console.log("✅ Subido:", res.data);
} catch (err) {
console.error("❌ Error:", err.response?.data || err.message);
}
}
uploadFile();async function uploadFiles() {
try {
const form = new FormData();
// 📁 Archivos locales
form.append('file', fs.createReadStream('./foto1.jpg'));
form.append('file', fs.createReadStream('./foto2.png'));
// 🌐 Archivo desde URL
form.append('url', 'https://i.imgur.com/ejemplo.jpg');
const res = await axios.post(`${API_URL}/upload`, form, {
headers: {
...form.getHeaders(),
'x-upload-token': TOKEN
}
});
console.log(`✅ ${res.data.count} archivos subidos`);
console.log(res.data);
} catch (err) {
console.error('❌ Error:', err.response?.data || err.message);
}
}
uploadFiles();async function uploadUrl() {
try {
const form = new FormData();
form.append('url', 'https://i.imgur.com/ejemplo.jpg');
const res = await axios.post(`${API_URL}/upload`, form, {
headers: {
...form.getHeaders(),
'x-upload-token': TOKEN
}
});
console.log('✅ URL clonada correctamente');
console.log(res.data);
} catch (err) {
console.error('❌ Error:', err.response?.data || err.message);
}
}
uploadUrl();// Query Params: hide_user=true | hide_filename=true | custom_name=...
const uploadUrl = `${API_URL}/upload?hide_user=true&custom_name=banner_oficial`;
async function uploadPremium() {
try {
const form = new FormData();
form.append('url', 'https://i.imgur.com/ejemplo.jpg');
const res = await axios.post(uploadUrl, form, {
headers: {
...form.getHeaders(),
'x-upload-token': TOKEN
}
});
console.log('✅ Subida Premium desde URL:', res.data.url);
} catch (err) {
console.error('❌ Error:', err.response?.data || err.message);
}
}
uploadPremium();async function deleteFile(fileId) {
try {
const response = await axios.post(`${API_URL}/delete`,
{ id: fileId },
{ headers: { 'x-upload-token': TOKEN } }
);
console.log('🗑️ Eliminado:', response.data.message);
} catch (error) {
console.error("Error:", error.message);
}
}
// deleteFile(152);fetch('https://api.evogb.org/api/cdn/delete', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-upload-token': 'TU_TOKEN_AQUI'
},
body: JSON.stringify({ id: 152 })
})
.then(res => res.json())
.then(data => console.log(data));import requests
url = "https://api.evogb.org/api/cdn/delete"
headers = {"x-upload-token": "TU_TOKEN_AQUI"}
payload = {"id": 152}
r = requests.post(url, json=payload, headers=headers)
print(f"Eliminado: {r.json().get('message')}")<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.evogb.org/api/cdn/delete");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"x-upload-token: TU_TOKEN_AQUI",
"Content-Type: application/json"
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["id" => 152]));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>curl -X POST "https://api.evogb.org/api/cdn/delete" \
-H "x-upload-token: TU_TOKEN_AQUI" \
-H "Content-Type: application/json" \
-d '{"id": 152}'async function listFiles() {
const res = await axios.get(`${API_URL}/files`, {
headers: { 'x-upload-token': TOKEN }
});
// La API devuelve un Array directamente
console.log(`✅ Tienes ${res.data.length} archivos.`);
}async function getStats() {
const res = await axios.get(`${API_URL}/stats`, {
headers: { 'x-upload-token': TOKEN }
});
const { usage, limits, plan } = res.data;
console.log(`📊 Plan: ${plan}`);
console.log(`💾 Uso: ${usage.storage_used_mb} / ${limits.storage_total_mb} MB`);
}Recetas completas de código listas para producción combinando subida de medios, análisis con IA y procesamiento inteligente.
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const TOKEN = 'TU_UPLOAD_TOKEN';
const BASE_URL = 'https://api.evogb.org/api/cdn';
async function uploadAndProcessOcr(filePath) {
try {
// 1. Subir el archivo al CDN
const form = new FormData();
form.append('file', fs.createReadStream(filePath));
form.append('folder_path', 'documentos/ocr');
console.log('⏳ Subiendo archivo al CDN...');
const uploadRes = await axios.post(`${BASE_URL}/upload`, form, {
headers: {
...form.getHeaders(),
'x-upload-token': TOKEN
}
});
const uploadedFile = uploadRes.data.files ? uploadRes.data.files[0] : uploadRes.data;
console.log(`✅ Archivo subido con ID: ${uploadedFile.id} | URL: ${uploadedFile.public_url}`);
// 2. Extraer texto mediante OCR con la Suite de IA
console.log('🤖 Procesando OCR con modelo neuronal...');
const ocrRes = await axios.post(`${BASE_URL}/ai/analyze`, {
id: uploadedFile.id,
task: 'ocr',
save_tags: true
}, {
headers: { 'x-upload-token': TOKEN }
});
console.log('📄 Idioma Detectado:', ocrRes.data.result.detected_language);
console.log('📝 Texto Extraído:\n', ocrRes.data.result.text);
console.log(`📊 Cuota de IA restante: ${ocrRes.data.ai_quota.remaining_today}/${ocrRes.data.ai_quota.daily_limit}`);
} catch (error) {
console.error('❌ Error en el pipeline:', error.response?.data || error.message);
}
}
uploadAndProcessOcr('./factura_servicio.png');const axios = require('axios');
const fs = require('fs');
const TOKEN = 'TU_UPLOAD_TOKEN';
async function reviewAndRefactorCode(fileId) {
try {
console.log(`🔍 Analizando código fuente (ID: ${fileId})...`);
const res = await axios.post('https://api.evogb.org/api/cdn/ai/analyze', {
id: fileId,
task: 'code_refactor'
}, {
headers: { 'x-upload-token': TOKEN }
});
const { language, analysis, issues, refactored_code, improvements, time_complexity } = res.data.result;
console.log(`\n================== DIAGNÓSTICO (${language}) ==================`);
console.log(`Evaluación: ${analysis}`);
console.log(`Complejidad: ${time_complexity || 'Optimizada'}`);
console.log(`\nIssues Detectados (${issues.length}):`);
issues.forEach((issue, idx) => {
console.log(` ${idx + 1}. [${issue.severity.toUpperCase()}] Línea ${issue.line_reference || 'N/A'}: ${issue.description}`);
});
console.log('\nMejoras Aplicadas:');
improvements.forEach(imp => console.log(` • ${imp}`));
// Guardar el código optimizado localmente
fs.writeFileSync('./codigo_refactorizado.js', refactored_code, 'utf8');
console.log('\n💾 Código limpio guardado en: ./codigo_refactorizado.js');
} catch (err) {
console.error('❌ Error en revisión:', err.response?.data || err.message);
}
}
reviewAndRefactorCode(310);import requests
import json
TOKEN = "TU_UPLOAD_TOKEN"
API_URL = "https://api.evogb.org/api/cdn"
def transcribe_audio(file_id):
headers = {"x-upload-token": TOKEN, "Content-Type": "application/json"}
payload = {
"id": file_id,
"task": "transcribe"
}
print(f"🎙️ Enviando archivo {file_id} al motor de transcripción...")
response = requests.post(f"{API_URL}/ai/analyze", json=payload, headers=headers)
if response.status_code == 200:
data = response.json()
result = data.get("result", {})
print("\n✅ Transcripción Exitosa:")
print(f"• Idioma: {result.get('detected_language')}")
print(f"• Resumen: {result.get('summary')}")
print(f"• Temas Clave: {', '.join(result.get('key_topics', []))}")
print("\n--- TEXTO COMPLETO ---")
print(result.get("transcription"))
# Guardar en archivo
with open("transcripcion.txt", "w", encoding="utf-8") as f:
f.write(result.get("transcription", ""))
print("\n💾 Transcripción guardada en 'transcripcion.txt'")
else:
print(f"❌ Error {response.status_code}:", response.text)
transcribe_audio(205)// Función de búsqueda semántica con debounce para inputs de búsqueda
let searchTimeout = null;
function onSearchInputChanged(query) {
clearTimeout(searchTimeout);
if (!query || query.trim().length < 2) return;
searchTimeout = setTimeout(async () => {
try {
const response = await fetch('https://api.evogb.org/api/cdn/ai/search', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-upload-token': 'TU_UPLOAD_TOKEN'
},
body: JSON.stringify({ query: query.trim(), limit: 10 })
});
const data = await response.json();
renderSearchResults(data.results);
} catch (err) {
console.error('Error buscando archivos:', err);
}
}, 300); // 300ms debounce
}
function renderSearchResults(files = []) {
const container = document.getElementById('search-results');
container.innerHTML = files.map(file => `
<div class="file-card">
<h4>${file.original_name}</h4>
<p>Carpeta: ${file.folder_name || 'Raíz'} | Tamaño: ${file.size_mb} MB</p>
<div class="tags">
${file.tags.map(t => `<span class="tag-badge">#${t}</span>`).join('')}
</div>
<a href="${file.public_url}" target="_blank" class="btn-link">Ver Archivo</a>
</div>
`).join('');
}El ecosistema de Evogb Cloud está impulsado por una arquitectura de eventos bidireccionales de baja latencia con Socket.IO. Cualquier modificación realizada mediante la API REST, bots, scripts o el panel web se propaga inmediatamente a todas las sesiones activas sin necesidad de peticiones repetitivas (polling).
Al establecer la conexión de WebSocket, el servidor autentica la sesión de forma segura y une al socket a su sala privada exclusiva cdn_<tu_email>. En el navegador se invoca socket.emit('join_cdn') tras la conexión exitosa.
| Evento | Payload (Datos) | Descripción y Disparador |
|---|---|---|
cdn_folder_created | { folder: Object } | Emitido cuando se crea una nueva carpeta o ruta. Contiene id, name, color, parent_id y created_at. |
cdn_folder_updated | { folder: Object } | Emitido al editar el nombre, color o jerarquía padre de una carpeta existente. |
cdn_folder_deleted | { folder_ids: Array, deleted_files_count: Number, freed_storage_mb: Number } | Emitido al eliminar carpetas recursivamente. Detalla los IDs borrados y el espacio en MB liberado. |
cdn_folder_moved | { folder_id: Number, parent_id: Number|null } | Emitido al mover una carpeta dentro de otra o a la raíz. |
cdn_file_created | { file: Object, size_mb: Number } | Emitido únicamente al completar la subida y ensamblado final del archivo en el almacenamiento en la nube y base de datos. |
cdn_file_deleted | { file_id: Number, size_mb: Number } | Emitido al eliminar un archivo del almacenamiento. Notifica el peso liberado para actualizar cuotas en vivo. |
cdn_file_moved | { file_id: Number, folder_id: Number|null } | Emitido al reubicar un archivo en una carpeta específica o en la raíz. |
cdn_public_toggled | { id: Number, is_public: Number } | Emitido al alternar la visibilidad de un archivo entre privado y público (galería). |
cdn_tags_updated | { id: Number, tags: Array } | Emitido al agregar, actualizar o eliminar etiquetas (#tags) en un archivo. |
cdn_stats_updated | { download_ops_daily: Number, upload_ops_daily: Number, storage_used_mb: Number } | Emitido periódicamente al procesar descargas en segundo plano o al actualizar consumo de ancho de banda. |
cdn_daily_reset | {} | Emitido automáticamente por el cron a medianoche (00:00) para reiniciar los contadores diarios de operaciones en vivo. |
import { io } from "https://cdn.socket.io/4.7.2/socket.io.esm.min.js";
const socket = io("https://api.evogb.org", { withCredentials: true });
socket.on("connect", () => {
console.log("🟢 Conectado al bus de eventos de Evogb Cloud");
socket.emit("join_cdn");
});
// Escuchar nuevo archivo subido
socket.on("cdn_file_created", (data) => {
console.log("✨ Nuevo archivo recibido en vivo:", data.file.original_name);
console.log("🔗 URL:", data.file.public_url);
});
// Escuchar eliminación de archivo
socket.on("cdn_file_deleted", (data) => {
console.log(`🗑️ Archivo #${data.file_id} eliminado. Espacio liberado: ${data.size_mb} MB`);
});
// Escuchar actualización de consumo de descargas
socket.on("cdn_stats_updated", (data) => {
console.log("📊 Nuevas operaciones de descarga:", data.download_ops_daily);
});const { io } = require("socket.io-client");
const socket = io("https://api.evogb.org", {
extraHeaders: {
"x-upload-token": "TU_UPLOAD_TOKEN"
}
});
socket.on("connect", () => {
console.log("⚡ Bot / Worker conectado a Socket.IO");
socket.emit("join_cdn");
});
socket.on("cdn_folder_created", (data) => {
console.log("📁 Carpeta creada:", data.folder.name, "(ID:", data.folder.id, ")");
});
socket.on("cdn_daily_reset", () => {
console.log("🔄 Medianoche: Cuotas diarias restablecidas.");
});Recomendaciones para programar tu Bot o App basándose en las respuestas de la API.
Tu bot sube memes y recibe error 429.
upload_ops_limit.Subes 10 archivos y el 9 falla con 403.
storage_total_mb alcanzado./delete.Cómo reacciona el sistema ante eventos críticos. Entender esto garantiza la alta disponibilidad de tus proyectos.
Si pasas de un plan alto (ej. 2GB) a Free (50MB):
Si tu cuenta supera el download_ops_limit o ancho de banda, el CDN deja de servir tus archivos y devuelve este SVG informativo en su lugar:
El bloqueo se levanta automáticamente a las 04:00 AM Hora Colombia o si mejoras a un plan superior (Business es ilimitado).
Si alcanzas el storage_total_mb a mitad de una operación:
/api/cdn/delete o mejorar tu plan.Si expones tu token en GitHub: Regenéralo inmediatamente en el Panel Cloud. El viejo dejará de funcionar al instante.
Disponible en Plan Pro o superior. Se configura desde el Panel Cloud:
cloud.marca.com).Si tu plan Premium vence:
Configura y sirve todos tus archivos multimedia desde tu propio dominio o subdominio de marca (por ejemplo: cdn.tuweb.com o media.tudominio.xyz). Cuenta con aprovisionamiento de certificados SSL/TLS automáticos y aceleración global a través de Cloudflare.
Configura tu propio dominio para servir archivos.
La función de dominio propio está disponible en Planes Pro, Ultra y Business (o mediante el permiso granular allow_custom_domain en tu Upload Token). Si aún no cuentas con un plan compatible, puedes adquirirlo en la Tienda.
Accede a Evogb Cloud, dirígete a la sección 🌐 Dominio Personalizado, escribe el subdominio o dominio que deseas usar (ejemplo: cdn.tuweb.com) y presiona Guardar.
En el panel de tu registrador de dominio o proveedor DNS (Cloudflare, Namecheap, GoDaddy, Hostinger, etc.), crea el siguiente registro:
cdn (o tu subdominio)cdn.evogb.orgSi administras tu dominio en Cloudflare, el registro CNAME debe configurarse obligatoriamente en "Solo DNS" (Nube Gris). Si activas el proxy (Nube Naranja), los retos de validación HTTP DV de Cloudflare for SaaS fallarán y no se podrá emitir el certificado SSL.
El sistema verifica automáticamente la propagación DNS y aprovisiona el certificado SSL/TLS.
Una vez que el dominio pasa al estado ACTIVO, el servidor emite una notificación vía WebSockets (cdn_domain_activated) y actualiza en tiempo real todas las URLs de tus archivos existentes y futuros en la base de datos y en la interfaz visual, aplicando una suave animación luminosa de confirmación en tus tarjetas de archivos.
Para salvaguardar tus integraciones en producción, Evogb Cloud opera con una política de protección activa:
custom_domain = NULL).https://cdn.evogb.org/...) garantizando que sigan siendo accesibles.cdn_domain_deleted en tiempo real y actualiza la interfaz con transiciones visuales suaves sin necesidad de recargar la página.Puedes automatizar el registro y desvinculación de dominios desde tus scripts o paneles usando peticiones HTTP autenticadas:
Registra y solicita el aprovisionamiento SSL para un dominio propio.
curl -X POST "https://api.evogb.org/api/cdn/domain" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{"domain": "cdn.tuweb.com"}'Desvincula el dominio propio, elimina el certificado SSL y restaura las URLs de todos los archivos al dominio por defecto en tiempo real.
curl -X DELETE "https://api.evogb.org/api/cdn/domain" \
-H "x-upload-token: TU_UPLOAD_TOKEN"Si tu suscripción Premium (Plus+) finaliza, entras en un Periodo de Gracia de 7 días. Tus archivos NO se borran inmediatamente. Durante este tiempo, puedes acceder y descargar tus archivos, pero no subir nuevos (downgrade a Free). Si no renuevas tras esos 7 días, tu cuenta pasa a Free y se eliminarán los archivos con más de 30 días de antigüedad.
Si eres usuario Free o activaste "Ocultar Nombre", el sistema reemplaza el nombre original por un ID aleatorio (ej: a1b2c.png) para proteger la privacidad y evitar colisiones.
Lo ideal es que le pongas el nombre que gustes antes de subirlo, pero en caso de ya estar subido, en la web Evogb Cloud ve al archivo y presiona, va aparecer el panel lateral de detalles del archivo y tendrás una opción para modificar el nombre del archivo (Solo en planes premium).
En planes Plus, Pro, Ultra y Business sí: Permiten */* (Cualquier tipo de archivo), incluyendo binarios y comprimidos. En planes Free/Lite/Go/Basic, estás limitado a imágenes, PDF y multimedia básica.
cloud.miweb.com).cloud.miweb.com a cloud.evogb.org.En el Panel Cloud (Premium), usa switches para ocultar usuario/archivo. Se aplican en subidas nuevas una vez configurado.
¡Sí! Soportamos CORS (Access-Control-Allow-Origin: *). Puedes usar las URLs directamente en <img src>, Canvas, React o Bots sin bloqueos, siempre que respetes los límites de ancho de banda diarios.
Nunca sobrescribimos. Si subes foto.jpg dos veces, generamos IDs únicos: a1-foto.jpg y b2-foto.jpg. Ambos existen independientemente.
El sistema está diseñado para nunca sobrescribir archivos. Si subes foto.jpg dos veces, el sistema generará IDs únicos internos: 1. a8j9s-foto.jpg, 2. x2p4m-foto.jpg. Ambos archivos coexistirán y tendrán URLs diferentes.
El sistema aplica la lógica por defecto (Fail-safe):
1. Nombre: Usa el nombre original del archivo con un ID aleatorio al inicio (x9z-foto.jpg).
2. Carpeta: Usa tu configuración guardada en el Dashboard. Si no has configurado nada, muestra tu carpeta de usuario (/Usuario/x9z-foto.jpg).
Tienes dos opciones sencillas:
1. Modo Desarrollador: Haz una petición GET a /api/cdn/files. Recibirás un JSON con todos tus archivos y sus IDs.
2. Modo Visual (Panel): Entra a tu Dashboard (cloud.evogb.org), haz clic sobre la imagen que quieras y mira el panel lateral derecho; allí verás el ID junto a otros detalles.
No imponemos un "Throttling" artificial de velocidad en ningún plan, pero dependemos de la conexión entre tu servidor y nuestros nodos. Para archivos grandes (+100MB), recomendamos usar una conexión estable o el método de stream (Node.js) para evitar timeouts HTTP. Pero en general tendrás una experiencia fluida.
No, tus archivos no se perderán porque estan en un lugar apartado e independiente de todos nuestros servicios así que puedes estar tranquilo/a, aunque el mantenimiento pueda hacer que nuestros servicios esten fuera de línea temporalmente, los enlaces de tus archivos seguirán funcionando con normalidad.
cdn_prefs y typePlan.