Evogb Docs
v1.0.0 Stable

Evogb Cloud

Infraestructura de almacenamiento híbrida con gestión avanzada.

Infraestructura Híbrida

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 avanzada.

Resumen

Esta documentación cubre desde la gestión básica sobre Cloud hasta la integración avanzada (Bots, Apps, Scripts), incluyendo detalles sobre planes, límites y preferencias.

Arquitectura del Sistema

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 / Lite / Go / Basic

☁️ Nube Compartida

  • Almacenamiento: Contenedores compartidos de alta disponibilidad.
  • Retención: Caducidad variable (30 días Free; permanente Plan Lite o superior).
  • Limpieza: 04:00 AM Hora Colombia
  • Ruta Interna: free/ (URL pública).
  • Limitaciones: Sin Contenedores privados, enlaces largos, y otros de acuerdo al plan.
Plus / Pro / Ultra / Business

🔒 Nube Privada

  • Almacenamiento: Infraestructura aislada y prioritaria.
  • Retención: Permanente (mientras la suscripción este vigente).
  • Privacidad: Opciones hide_user y hide_filename.
  • Ruta Interna: premium/ (URL pública limpia en raíz).
  • Ventajas: Soporte cualquier formato MIME */* y Dominios Personalizados (Plan Pro o superior).

Nota Técnica

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.

Planes y Límites

Variables del sistema que rigen tu cuenta (consultables vía /api/cdn/stats).

Atributo JSONNombre PanelDescripción y Efecto al Límite
storage_total_mbAlmacenamientoCapacidad total. Bloqueo (403): No podrás subir más hasta liberar espacio o mejorar plan.
upload_ops_limitSubidas DiariasMáx. archivos/24h. Temp (429): Reinicia a las 04:00 AM Colombia
download_ops_limitDescargas DiariasMáx. accesos/24h. Temp (429): Ilimitado en Business.
max_file_size_mbPeso MáximoRechazo (413): Subida cancelada inmediatamente.
allowed_mime_typesFormatosLista blanca. Rechazo (415) si no permitido.
retention_daysRetenciónVida útil. Eliminación: Se borra al cumplirse el plazo (30 días).
expiring_linksLinks TemporalesEn Desarrollo: No disponible actualmente.
custom_domainDominio PropioRequiere configuración CNAME y Plan Pro o superior.
PlanPrecio (USD)StorageSubidas/DíaDownloads/DíaMax FileTipos
Free$0 (7d)50 MB102005 MBImg basic
Lite$0.60 (15d)150 MB302000(2k)10 MBImg, PDF
Go$0.99 (30d)300 MB605000(5k)15 MBImg, PDF, Audio
Basic$1.99 (30d)600 MB10015000(15k)25 MBImg, PDF, AV
Plus $3.99 (30d)1024 MB20040000(40k)50 MB*/*
Pro $6.99 (60d)2048 MB500100000(100k)100 MB*/*
Ultra $9.99 (60d)5120 MB1000250000(250k)250 MB*/*
Business $19.99 (60d)10GB5000Ilimitado1024 MB(1GB)*/*

Nota Importante

Precios y duraciones varían por variante. Planes Premium incluyen preferencias de URL y retención permanente. Para mayor información visita la tienda

Guía del Panel Web (Cloud)

El panel ubicado en cloud.evogb.org es tu centro de comando visual, con un diseño responsivo (soporte móvil) y efectos animados.

Anillos de Estado

Visualiza consumo en tiempo real:

🟢 Normal 🟡 > 50% 🔴 > 85%

Upload Token

Llave maestra para APIs. Incluye botones para mostrar, copiar y regenerar.

Filtros Avanzados

Busca por rango de peso, tipo, fecha o patrones de nombre (empieza/termina).

Prefs. Premium

Opciones de Personalización de Enlaces para ocultar usuario/archivo en URL.

Dominio Propio

Vincula tu marca (ej. cloud.tu-web.com). Incluye gestión DNS y SSL automático.

Gestión Masiva

Interfaz optimizada para grandes volúmenes. Paginación dinámica y carga fluida.

  • Navegación: Al cargar se sincronizan stats. Usa botones superiores para navegar en otros sitios de Evogb.
  • Monitoreo: Si un anillo está amarillo/rojo, revisa los iconos para instrucciones.
  • Gestión: Búsqueda , paginación (5-100 items) , y vista lista para detalles.
  • Seguridad: Cuida tu Upload Token. Permite acceso total a subidas/eliminar/ajustar.
  • Subidas: Soporte Drag & Drop, Ctrl+V. Usa el token para automatización masiva.
  • Gracia (7 días): Si expira el plan, entras en Gracia. No se borra nada por 7 días.
  • Dominios en Gracia: Siguen sirviendo archivos durante los 7 días, luego se desconectan.
  • Inspector: Clic en archivo para ver metadatos y copiar snippets HTML/MD/JSON.

Integración y API REST

Documentación técnica detallada para desarrolladores. Todas las peticiones requieren autenticación.

Base URL: https://api.evogb.org

Autenticación

Usa el header x-upload-token con tu token disponible en el Dashboard.

POST /api/cdn/upload (Subida)

Endpoint capaz de procesar archivos locales (Buffer/Stream) y URLs simultáneamente.

Parámetros Query (Personalización)

ParamTipoComportamiento
hide_userBoolean OPTtrue: URL raíz (/archivo.jpg).
false/omiso: Incluye carpeta usuario (/usuario/archivo.jpg).
hide_filenameBoolean OPTtrue: Ignora nombre original, usa solo ID aleatorio.
custom_nameString OPTDefinido: Usa tu nombre + ID corto (a1-banner.jpg).
Omiso: Usa nombre original + ID (a1-foto_original.jpg).

Ejemplo subiendo un archivo local Y URL en la misma petición.

Node.js (Axios)
const axios = require("axios");
const FormData = require("form-data");
const fs = require("fs");
const formData = new FormData();
// Archivo local
formData.append("file", fs.createReadStream("./image.jpg"));
// Archivo online (url)
formData.append("url", "https://ejemplo.com/image2.png"); // Usa una URL real
axios.post("https://api.evogb.org/api/cdn/upload", formData, {
headers: {
"x-upload-token": "TU_UPLOAD_TOKEN",
...formData.getHeaders(),
},
})
.then((res) => {
console.log(`✅ Subidos: ${res.data.count}`);
console.log(res.data);
})
.catch((err) => {
if (err.response) {
console.error("❌ Error Status:", err.response.status);
console.error("❌ Error Data:", err.response.data);
} else {
console.error("❌ Error:", err.message);
}
});
Python (Requests)
import requests
# Configuración
url_api = "https://api.evogb.org/api/cdn/upload"
token = "TU_UPLOAD_TOKEN"
# 1. Campos de texto (URL)
payload = {
"url": "https://ejemplo.com/image2.png"
}
# 2. Archivos locales
# Formato: ("nombre_archivo", contenido_binario, "tipo_mime")
try:
files = {
"file": ("image.jpg", open("./image.jpg", "rb"), "image/jpeg")
}
except FileNotFoundError:
print("❌ El archivo local no existe")
files = None
# 3. Cabeceras
headers = {
"x-upload-token": token
}
try:
# 'data' se usa para campos de texto y 'files' para el archivo binario
response = requests.post(url_api, data=payload, files=files, headers=headers)
# Verificar si la respuesta es exitosa
if response.status_code == 200:
data = response.json()
# Siguiendo la lógica de tu servidor:
# Si hay más de un archivo, vendrá la propiedad 'count'
if "count" in data:
print(f"✅ Subidos: {data['count']}")
else:
print(f"✅ Subido: 1")
print(data)
else:
print(f"❌ Error Status: {response.status_code}")
print(f"❌ Error Data: {response.text}")
except Exception as e:
print(f"❌ Error: {str(e)}")
finally:
if files and "file" in files:
files["file"][1].close()
Terminal (cURL)
curl -X POST "https://api.evogb.org/api/cdn/upload" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-F "file=@./image.jpg" \
-F "url=https://ejemplo.com/image2.png"
✅ JSON Respuesta
{
success: true,
count: 2,
files: [
{
success: true,
url: 'https://cdn.evogb.org/user/image.jpg',
filename: 'image.jpg',
type: 'file'
},
{
success: true,
url: 'https://cdn.evogb.org/user/image2.jpg',
filename: 'image2.jpg',
type: 'url'
}
]
}
GET /api/cdn/files (ver archivos)

Devuelve un Array JSON con todos los archivos de tú cuenta completo. Incluye metadatos sociales como likes, tags y estados.

JavaScript (Axios)
const axios = require("axios");
async function main() {
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);
}
main().catch((err) => {
console.error("❌ Error:", err.response?.data || err.message);
});
Python (Requests)
import requests
def main():
url = "https://api.evogb.org/api/cdn/files"
headers = {
"x-upload-token": "TU_UPLOAD_TOKEN"
}
res = requests.get(url, headers=headers)
# Lanza excepción si el status no es 2xx
res.raise_for_status()
data = res.json()
print(f"📦 Total archivos: {len(data)}")
print(data)
if __name__ == "__main__":
try:
main()
except requests.exceptions.HTTPError as e:
print("❌ Error:", e.response.text)
except Exception as e:
print("❌ Error:", str(e))
Respuesta Real (Array JSON)
[
{
"id": 10,
"user_email": "[email protected]",
"file_uuid": "Xy9K2.jpg",
"original_name": "example-image.jpg",
"size_mb": 0.32,
"mime_type": "image/jpeg",
"upload_date": "2026-01-01T10:15:30.000Z",
"public_url": "https://cdn.evogb.org/username/Xy9K2.jpg",
"storage_path": "premium/username/Xy9K2.jpg",
"is_public": 1,
"likes": 12,
"is_pinned": 0,
"tags": "[\"example\",\"cdn\"]",
"is_sensitive": 0,
"is_public_suspended": 0
},
{
"id": 65,
"user_email": "[email protected]",
"file_uuid": "Qp7M9.webp",
"original_name": "sample-banner.webp",
"size_mb": 0.58,
"mime_type": "image/webp",
"upload_date": "2026-01-02T18:45:00.000Z",
"public_url": "https://cdn.evogb.org/username/Qp7M9.webp",
"storage_path": "premium/username/Qp7M9.webp",
"is_public": 0,
"likes": 0,
"is_pinned": 1,
"tags": "[]",
"is_sensitive": 0,
"is_public_suspended": 0
}
]
GET /api/cdn/files/:id (Ver un archivo)

Obtén la metadata completa de un solo archivo mediante su ID numérico.

JavaScript
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(67);
Python
import requests
def get_file_details(file_id):
url = f"https://api.evogb.org/api/cdn/files/{file_id}"
headers = {
"x-upload-token": "TU_UPLOAD_TOKEN"
}
try:
res = requests.get(url, headers=headers)
res.raise_for_status()
data = res.json()
file = data.get("file", {})
print(f"📂 Archivo: {file.get('original_name')}")
print(f"🔗 URL: {file.get('public_url')}")
print(data)
except requests.exceptions.HTTPError as e:
# Errores 4xx / 5xx
print("❌ Error:", e.response.text)
except Exception as e:
# Errores generales
print("❌ Error:", str(e))
get_file_details(67)
Respuesta Real (JSON)
{
"id": 67,
"user_email": "[email protected]",
"file_uuid": "2kONN",
"original_name": "un_gato_persa-39",
"size_mb": 0.02,
"mime_type": "image/webp",
"upload_date": "2026-01-24T18:30:07.489Z",
"public_url": "https://cdn.evogb.org/2kONN",
"storage_path": "premium/2kONN",
"is_public": 0,
"likes": 0,
"is_pinned": 0,
"tags": "[]",
"is_sensitive": 0,
"is_public_suspended": 0
}
GET /api/cdn/stats (Consumo y Límites)

Consulta para monitorear estadísticas y recursos. Devuelve la configuración del plan y el uso en tiempo real.

Respuesta (JSON)

CategoríaCampoDescripción Técnica
RootusernameNombre de usuario del propietario de la cuenta.
typePlanIdentificador técnico del plan (ej: lite, pro, free).
Limitsstorage_total_mbCapacidad máxima de disco asignada (en MB).
upload_ops_limitTope de archivos subidos por día.
download_ops_limitTope de descargas/visualizaciones diarias permitidas.
max_file_size_mbPeso máximo permitido por archivo individual.
allowed_mime_typesArray de tipos MIME permitidos. */* indica sin restricción.
private_buckets(Boolean) Indica si el almacenamiento es aislado (Nube Privada).
expiring_links(Boolean) Indica si el plan permite generar enlaces temporales.
custom_domain(Boolean) Indica si el plan permite vincular un dominio propio.
retention_daysDías que duran los archivos antes de borrarse (ej: 30). Si es permanente, puede variar según lógica.
UsageemailCorreo electrónico asociado a la cuenta.
storage_used_mbEspacio consumido actualmente (Float preciso).
upload_ops_dailyContador de subidas realizadas hoy.
download_ops_dailyContador de descargas/vistas realizadas hoy.
custom_domainEl dominio personalizado configurado actualmente (o null).
domain_statusEstado del dominio: configured, pending, active.
last_reset_dateFecha del último reinicio de contadores (YYYY-MM-DD).
Solicitud (Node.js)
const axios = require("axios");
async function main() {
const res = await axios.get("https://api.evogb.org/api/cdn/stats", {
headers: { "x-upload-token": "TU_UPLOAD_TOKEN" },
});
console.log(
`📊 Subidas: ${res.data.usage.upload_ops_daily} / ${res.data.limits.upload_ops_limit}`
);
console.log(res.data);
}
main().catch((err) => {
console.error("❌ Error:", err.response?.data || err.message);
});
Respuesta (JSON)
{
username: 'userX',
plan: 'prod_TaCQeDihGpqcax',
typePlan: 'pro',
limits: {
storage_total_mb: 2048,
upload_ops_limit: 500,
download_ops_limit: 100000,
max_file_size_mb: 100,
allowed_mime_types: [ '*/*' ],
private_buckets: true,
expiring_links: true,
custom_domain: true,
retention_days: null
},
usage: {
email: '[email protected]',
storage_used_mb: 5.38,
upload_ops_daily: 14,
download_ops_daily: 10,
last_reset_date: '2026-01-24',
custom_domain: null,
domain_status: 'configured'
}
}
POST /api/cdn/delete (Eliminar Archivo)

Eliminación definitiva. Libera espacio en storage_used_mb inmediatamente.

¿Cómo obtener el ID?

Puedes obtener el id numérico de dos formas:

  • Vía API: Usando el endpoint GET /api/cdn/files (Listado).
  • Vía Visual: En el Panel Cloud, haz clic sobre cualquier archivo. Se abrirá un inspector lateral donde verás el campo ID.
Solicitud cURL
curl -X POST "https://api.evogb.org/api/cdn/delete" \
-H "x-upload-token: TU_UPLOAD_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "id": 105 }'

Códigos de Error

La API utiliza códigos HTTP estrictos para indicar el éxito o fallo de una solicitud.

CódigoErrorCausa ProbableSolución
400Bad RequestToken de ejemplo o falta ID.Usa tu token real y verifica el Body.
401UnauthorizedToken faltante o incorrecto.Verifica el header x-upload-token.
403ForbiddenAlmacenamiento lleno o archivo ajeno.No puedes borrar archivos de otros usuarios.
404Not FoundID de archivo inexistente.El ID ingresado no existe en la base de datos.
413Payload Too LargeArchivo supera el peso máximo.Comprime el archivo o sube de plan.
415Unsupported Media TypeEl tipo de archivo no está permitido.Asegurarse de subir archivos según tú plan.
429Too Many RequestsLímite diario de operaciones.Espera a las 04:00 AM o mejora plan.
500Server ErrorFallo interno.Intenta de nuevo o contacta soporte.

Snippets & Ejemplos

Copia y pega estos ejemplos para integrar Evogb Cloud rápidamente en tus proyectos.

Configuración Previa (Node.js)

Recomendamos usar axios y form-data.

config.js
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 }
});
Subida de Archivos

Subida Básica

Node.js
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();

Subida Múltiple

Node.js (Múltiple)
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();

Subida desde URL

Node.js (URL Externa)
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();

Subida Premium (Privacidad)

Node.js (Params)
// 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();
Eliminar Archivo (Multi-Lenguaje)
Node.js (Axios)
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);
Browser (Fetch)
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));
Python (Requests)
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 (cURL)
<?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;
?>
Terminal (cURL)
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}'
Consultas (Listar & Stats)
Listar Archivos (Node.js)
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.`);
}
Obtener Stats (Node.js)
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`);
}

Lógica de Integración

Recomendaciones para programar tu Bot o App basándose en las respuestas de la API.

Escenario Bot (429)

Tu bot sube memes y recibe error 429.

  • Diagnóstico: Superaste upload_ops_limit.
  • Acción Code: Pausar subidas o guardar en cola local.
  • Reintento: Programar a las 04:00 AM Hora Colombia

Disco Lleno (403)

Subes 10 archivos y el 9 falla con 403.

  • Diagnóstico: storage_total_mb alcanzado.
  • Acción Code: Detener loop. Llamar endpoint /delete.
  • No hacer: Reintentar inmediatamente (bucle infinito).

Ciclo de Vida y Escenarios

Cómo reacciona el sistema ante eventos críticos. Entender esto garantiza la alta disponibilidad de tus proyectos.

Downgrade (Premium a Free)

Si pasas de un plan alto (ej. 2GB) a Free (50MB):

  • Sobre Cuota: Entras en congelamiento. No puedes subir nada hasta liberar espacio.
  • Gracia (Días 1-7): Archivos viejos NO se borran. Tienes 7 días para descargar los archivos y hacer backups local si crees que no vas a renovar Plan.
  • Día 8: Se borran automáticamente archivos con antigüedad > 30 días.
  • Privacidad: Los enlaces viejos privados se mantienen, pero nuevas subidas serán según Tú Plan .

Límite Excedido (Bloqueo Visual)

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:

LÍMITE EXCEDIDOAncho de banda agotadoActualiza tu plan en Evogbapi.evogb.org

Recuperación

El bloqueo se levanta automáticamente a las 04:00 AM Hora Colombia o si mejoras a un plan superior (Business es ilimitado).

Error 403: Disco Lleno

Si alcanzas el storage_total_mb a mitad de una operación:

  • La subida falla. No reintentes inmediatamente.
  • Debes llamar a /api/cdn/delete o mejorar tu plan.

Token Comprometido

Si expones tu token en GitHub: Regenéralo inmediatamente en el Panel Cloud. El viejo dejará de funcionar al instante.

Dominios y Periodo de Gracia

Configuración de Dominio

Disponible en Plan Pro o superior. Se configura desde el Panel Cloud:

  1. Ingresa tu dominio (ej: cloud.marca.com).
  2. El sistema te dará un registro CNAME.
  3. Añádelo en tu proveedor DNS (Cloudflare: Proxy OFF/Gris).
  4. El sistema valida el SSL automáticamente y migra tus enlaces.

Periodo de Gracia

Si tu plan Premium vence:

  • Estado: Entras en Gracia por 7 días.
  • Archivos: NO se borran. Siguen accesibles.
  • Dominio: Sigue activo durante los 7 días.
  • Final: Si no renuevas al día 8, el dominio se desconecta y los archivos > 30 días se eliminan. Evita esto renovando tú Plan en la Tienda

Preguntas Frecuentes (FAQ)

¿Qué pasa si mi plan vence?

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.

¿Por qué mi archivo tiene un nombre raro?

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.

¿Cómo puedo cambiar el nombre de un archivo?

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).

¿Puedo subir archivos .exe o .zip?

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.

¿Cómo configuro mi Dominio Propio?

  1. Ve al Panel Cloud > Dominio Personalizado (disponible en Pro+).
  2. Ingresa tu dominio (ej: cloud.miweb.com).
  3. En tu proveedor de dominio, crea un registro CNAME apuntando cloud.miweb.com a cloud.evogb.org.
  4. Espera la propagación DNS. Nuestro sistema se encargará de ajustar el resto.

¿Cómo manejo preferencias de URL?

En el Panel Cloud (Premium), usa switches para ocultar usuario/archivo. Se aplican en subidas nuevas una vez configurado.

¿Hotlinking y CORS?

¡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.

¿Archivos con el mismo nombre?

Nunca sobrescribimos. Si subes foto.jpg dos veces, generamos IDs únicos: a1-foto.jpg y b2-foto.jpg. Ambos existen independientemente.

¿Archivos duplicados?

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.

¿Qué pasa si no envío parámetros de nombre?

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).

¿Cómo obtengo el ID de un archivo?

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.

¿Hay límite de velocidad de subida?

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.

¿Perderé mis archivos en mantenimiento?

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.

Migración y Actualizaciones

  • Usuarios Existentes: Si tu cuenta es antigua, el sistema migra automáticamente datos como cdn_prefs y typePlan.
  • Actualizaciones: El sistema verifica esquemas al inicio (Agrega datos si faltan). Contacta soporte si ves errores.
  • Mantenimiento: Limpiezas diarias a las 04:00 AM Hora Colombia. No afecta para archivos permanentes. Para más información consulta Tabla de Planes