v0.2 — Código abierto · Licencia MIT

El gestor de archivos que se incrusta en cualquier lugar

PHP ≥ 8.1 + Flysystem 3. Interfaz Alpine.js. Local, S3, Cloudflare R2, SFTP. Integra con unas líneas de JavaScript.

PHP ≥ 8.1
Sin framework requerido
~3 KB
Tamaño del SDK
MIT
Licencia código abierto
16
Idiomas soportados
Vista previa

Ver en acción

Creating a FluxFiles share link with an expiry, a password and a download limit
Comparte un archivo — caducidad, contraseña, límite
Creating a FluxFiles upload portal with a file limit, size cap and allowed file types
Portales de subida — sin cuenta
FluxFiles links panel listing shared links with views, downloads and revoke
Gestiona cada enlace y revócalo cuando quieras
FluxFiles desktop file manager with image thumbnails
Vista de cuadrícula con miniaturas WebP al instante
FluxFiles browsing an S3 / R2 bucket with the local, S3 and SFTP disk switcher
Multi-nube — S3 / R2 / SFTP, una sola UI
FluxFiles managing a remote VPS deploy directory over SFTP, same UI as the S3 bucket
VPS remoto por SFTP — sin cliente FTP
Editing an nginx config file inside FluxFiles with syntax highlighting
Edita archivos de configuración in situ — sin SSH ni FTP
FluxFiles previewing a video inline in the detail panel
Vista previa de vídeo, audio y PDF sin descargar
FluxFiles Bucket Doctor health checks for an S3 bucket with CORS and IAM remediation
Bucket Doctor — diagnóstico de S3/R2 + soluciones
FluxFiles activity log of file operations
Registro de actividad — guardado en tu propio bucket
FluxFiles trash with restore and delete forever
Papelera — restaurar o eliminar para siempre
FluxFiles responsive mobile file manager
Adaptado a móvil
La ventaja · BYOB

Los archivos de tus clientes se quedan en los buckets de tus clientes

FluxFiles es el gestor de archivos embebible donde cada inquilino conecta su propio bucket S3/R2 — y tú nunca almacenas sus datos ni sus credenciales.

  • Soberanía de datos

    Los archivos viven en la cuenta cloud y la región del propio cliente — pensado para RGPD, cumplimiento y compras empresariales.

  • Cero datos, cero credenciales en reposo

    Las credenciales del bucket se cifran con AES-256-GCM dentro del JWT y solo se descifran en tiempo de ejecución — nunca se escriben en base de datos ni en logs.

  • Un coste de almacenamiento que tiende a cero

    El almacenamiento y el egress se facturan a cada cliente, no a ti. Sin factura que crezca con tu base de usuarios.

  • Sin estado y embebible

    Sin base de datos central. Embebe el selector en cualquier app por iframe o SDK; tu backend emite un token acotado y de corta duración.

Tu app SaaS
JWT acotado (credenciales cifradas)
FluxFiles
descifra solo en ejecución
Inquilino A
su bucket
Inquilino B
su bucket
Inquilino C
su bucket

Cómo funciona: tu app cifra las credenciales del bucket del inquilino en un JWT de corta duración (HKDF-SHA256 + AES-256-GCM). FluxFiles solo las descifra para ejecutar la operación solicitada.

Multiinquilino

Un token por inquilino, cada uno con sus reglas

FluxFiles es sin estado: el JWT que emite tu backend es la configuración del inquilino. Ruta de almacenamiento, tamaño máximo por archivo, cuota, número de archivos, tipos permitidos, permisos — todo aplicado en el servidor. Sin archivos de configuración por inquilino, sin reinicios.

// Your backend, per request — the token IS the tenant's config.
import { createToken } from '@fluxfiles/node';

const claims = tenant.plan === 'pro'
  // 100 MB/file · any type · 50 GB · unlimited files · own bucket
  ? { disks: ['s3'],    maxUploadMb: 100, allowedExt: null,
      maxStorageMb: 51200, maxFiles: 0 }
  // 5 MB/file · images only · 500 MB · 200 files
  : { disks: ['local'], maxUploadMb: 5,   allowedExt: ['jpg','png','webp'],
      maxStorageMb: 500,   maxFiles: 200 };

const token = createToken({
  secret: process.env.FLUXFILES_SECRET,
  userId: tenant.id,
  prefix: `tenant_${tenant.id}/`,   // isolates each tenant's files
  perms:  ['read', 'write', 'delete'],
  ...claims,
});
prefix disks / BYOB max_upload max_storage max_files allowed_ext perms

Combínalo con BYOB para poner a cada inquilino en su propio bucket.

Para quién es

Hecho para equipos que entregan funciones de archivos

Si tu producto necesita subidas, FluxFiles se integra — sin convertirte en el guardián de los datos de tus clientes.

SaaS y apps multi-inquilino

Da a cada cliente un gestor de archivos en su propio bucket. Alcance de token por inquilino y soberanía de datos incluidos.

Agencias y freelancers

Entrega una biblioteca multimedia pulida a cada cliente sin montar infraestructura de almacenamiento por proyecto.

Integraciones de CMS y editores

Añade un selector de medios a CKEditor, TinyMCE, Summernote o tu propio editor mediante el SDK por iframe.

Herramientas internas y paneles

Añade subidas, vistas previas y operaciones de archivos auditadas a tus paneles de admin en una tarde.

Características

Todo lo que un gestor de archivos moderno necesita

Construido para desarrolladores que necesitan flexibilidad.

Multi-almacenamiento

Local, AWS S3, Cloudflare R2, SFTP vía Flysystem v3 — cambia con config, sin tocar código.

Incrusta en cualquier lugar

iframe + SDK postMessage. La UI standalone usa Alpine.js (sin build). Funciona con cualquier framework.

Auth JWT + alcance

Prefijo de ruta por usuario, permisos, lista blanca de discos, modo solo propietario.

AI auto-tag

Claude / OpenAI vision — alt text, título, tags automáticos.

Recorte de imagen

Herramienta de recorte con proporciones predefinidas.

Optimización de imagen

Variantes WebP automáticas — miniatura, mediano, grande.

Subidas presignadas

El navegador sube directamente a S3/R2 — cero ancho de banda en tu servidor.

Subida por partes

S3 multipart para archivos > 10MB.

Búsqueda de texto completo

Búsqueda indexada por nombres, títulos, tags — basada en archivos, sin base de datos.

Operaciones masivas

Selección múltiple: mover, copiar, eliminar, descargar.

Transferencia cross-disk

Copiar/mover entre Local ↔ S3 ↔ R2.

Papelera

Eliminación recuperable con purga automática.

Metadatos SEO

Título, alt, leyenda, tags — metadatos de objeto S3 (nube) o JSON sidecar (local). Búsqueda de texto completo.

Modo oscuro

Claro / oscuro / auto en UI y SDK.

16 idiomas

Inglés por defecto. Establece locale vía SDK, URL (?locale=) o FLUXFILES_LOCALE. RTL para árabe.

Registro de auditoría

Todas las acciones de escritura registradas.

Limitación de velocidad

Token bucket por usuario para protección API.

Cuota de almacenamiento

Límites por usuario vía JWT claims.

Buckets BYOB

Los usuarios traen su propio S3/R2 — credenciales cifradas en JWT (AES-256-GCM).

Detección de duplicados

Coincidencia SHA-256 omite cargas redundantes salvo sobrescritura forzada.

Renovación de token SDK

onTokenRefresh en 401 — refresh coalescido, reintento y updateToken() para rotación proactiva.

Bucket Doctor

Diagnostica cualquier disco S3/R2 — credenciales, lectura/escritura/borrado, presign, CORS, multipart — con correcciones de IAM y CORS listas para pegar. Conecta buckets BYOB en minutos.

SDK de tokens Node

Emite tokens de FluxFiles desde cualquier backend JS (Express, Next.js, Nuxt) con @fluxfiles/node — compatible byte a byte con el núcleo PHP. No necesitas PHP para emitir tokens.

Disco SFTP

Un 3.er driver tras S3/R2 — convierte cualquier VPS o hosting en gestor de archivos.

Editor de código / config

Edita archivos de texto y config (wp-config.php, .env) en el navegador, estilo cPanel.

Zip y Extraer

Descarga una selección como zip o extrae un archivo — protegido contra zip-slip y bombas.

Marca de agua

Aplica una marca de agua de texto o logo al vuelo — el archivo original no se toca.

WebP + AVIF bajo demanda

Sirve cualquier tamaño de imagen como AVIF/WebP en caché por una sola URL (negociada por Accept), con srcset responsive listo.

Permisos SFTP

Cambia permisos Unix (chmod) en discos SFTP con un diálogo estilo cPanel.

Panel de uso

Mira el almacenamiento de un vistazo — cuota y desglose por tipo y carpeta.

Vista previa de medios

Vista en línea de imagen, vídeo, audio y PDF; medios locales privados en streaming seguro.

Instalación rápida

Funcionando en 2 minutos

composer require fluxfiles/fluxfiles
cp .env.example .env

# .env
FLUXFILES_SECRET=your-random-32-char-secret
FLUXFILES_ALLOWED_ORIGINS=https://yourapp.com

require_once 'vendor/autoload.php';

$token = fluxfiles_token(
    userId: 'user-123',
    perms: ['read', 'write', 'delete'],
    disks: ['local', 's3', 'r2'],
    prefix: 'user-123/',
    maxUploadMb: 10,
    allowedExt: null,
    ttl: 3600
);
composer require fluxfiles/laravel
php artisan vendor:publish --tag=fluxfiles-config

# .env — point the adapter at your FluxFiles server
FLUXFILES_ENDPOINT=https://fm.yourdomain.com
FLUXFILES_SECRET=your-secret-min-32-chars

# Optional: match CORS on the FluxFiles host
# FLUXFILES_ALLOWED_ORIGINS=https://yourapp.com

# Config: config/fluxfiles.php
npm install @fluxfiles/node

// Express / Next.js route — mint a token from your JS backend (no PHP)
import { createToken } from '@fluxfiles/node';

app.get('/fluxfiles-token', (req, res) => {
    const token = createToken({
        secret: process.env.FLUXFILES_SECRET, // >= 32 bytes
        userId: req.user.id,
        perms: ['read', 'write', 'delete'],
        prefix: `users/${req.user.id}`,
        ttl: 3600,
    });
    res.json({ token });
});
<!-- Demo: unpkg. In production, serve fluxfiles.js from your FluxFiles host -->
<script src="https://unpkg.com/fluxfiles@latest/fluxfiles.js"></script>

<script>
FluxFiles.open({
    endpoint: 'https://your-api.com',
    token: 'eyJhbGci...',
    disk: 'local',
    mode: 'picker',
    container: '#file-picker',
    onSelect: function(file) {
        console.log('Selected:', file.url);
    },
    async onTokenRefresh() {
        const r = await fetch('/api/auth/refresh-fluxfiles-token');
        const { token } = await r.json();
        return token;
    }
});
</script>
npm install @fluxfiles/react

import { FluxFilesModal } from '@fluxfiles/react';

<FluxFilesModal
    open={open}
    endpoint="https://your-api.com"
    token={token}
    onSelect={(file) => console.log(file)}
    onClose={() => setOpen(false)}
/>
npm install @fluxfiles/vue

<script setup>
import { FluxFilesModal } from '@fluxfiles/vue';
</script>

<FluxFilesModal
    v-model:open="open"
    endpoint="https://your-api.com"
    :token="token"
    @select="onSelect"
    @close="open = false"
/>
git clone https://github.com/thai-pc/fluxfiles.git
docker build -f fluxfiles/docker/Dockerfile.prod -t fluxfiles fluxfiles

docker run -p 8080:80 \\
  -e FLUXFILES_SECRET=your-random-32-char-secret \\
  fluxfiles

# UI: http://localhost:8080/public/index.html
git clone https://github.com/thai-pc/fluxfiles.git
cd fluxfiles
composer install -d packages/core
cp .env.example .env

cd packages/core
php -S localhost:8080 router.php

# UI:  http://localhost:8080/public/index.html
# API: http://localhost:8080/api/fm/list?disk=local&path=

Compatible con

Laravel WordPress React / Next.js Vue / Nuxt CKEditor 4 TinyMCE Summernote Any framework

Integraciones

Adaptadores listos para tu stack

Los adaptadores oficiales integran FluxFiles de forma nativa en los frameworks y editores que ya usas.

Laravel
PHP
WordPress
Plugin
React
Component
Vue / Nuxt
Component
CKEditor 4
Plugin
TinyMCE
Plugin
Summernote
Plugin

Integración

Intégralo en pocas líneas

Carga fluxfiles.js, pasa un JWT emitido en el servidor y coloca un gestor de archivos completo — o un modal de selección — en cualquier página.

<script src="https://fm.example.com/fluxfiles.js"></script>

FluxFiles.open({
  endpoint: 'https://fm.example.com',
  token: 'eyJhbGci...',   // JWT from your backend
  disk: 'local',
  mode: 'picker',         // select & close
  theme: 'auto',
  onSelect(file) {
    // { url, key, name, size, disk, meta, variants }
    document.querySelector("#img").src = file.url;
  },
});
<div id="fm" style="height:600px"></div>

FluxFiles.open({
  endpoint: 'https://fm.example.com',
  token: 'eyJhbGci...',
  mode: 'browser',          // full manager, stays open
  container: '#fm',         // omit for a modal overlay
  disks: ['local', 's3', 'r2'],
});

FluxFiles.on('FM_EVENT', (e) => console.log(e.event));
FluxFiles.navigate('/photos/2024');
import { FluxFilesModal } from '@fluxfiles/react';

function Picker({ open, setOpen, token }) {
  return (
    <FluxFilesModal
      open={open}
      endpoint="https://fm.example.com"
      token={token}
      onSelect={(file) => console.log(file.url)}
      onClose={() => setOpen(false)}
    />
  );
}

Los tokens se emiten en el servidor — nunca envíes tu secreto al navegador.

Por qué FluxFiles

Construido para lo que otros olvidaron

Desliza para comparar
Característica FluxFiles elFinder Laravel-FM RichFilemanager Responsive FM
S3 + R2 + Local + SFTP
Incrustar en cualquier framework
Auth JWT + alcance
Metadatos SEO
AI auto-tag
Recorte de imagen
Subida por partes
Búsqueda de texto
Modo oscuro
16 idiomas
PHP ≥ 8.1
Mantenimiento activo
UI moderna
frente a SaaS de archivos

Autoalojado y embebible — no otro SaaS de subida

Las API de archivos alojadas son geniales, pero almacenan tus datos y facturan por uso. FluxFiles corre en tu stack, cada inquilino en su propio bucket.

Desliza para comparar
Capacidad FluxFiles Filestack Uploadcare Cloudinary Supabase Storage
Autoalojado (corre en tu infraestructura)
BYOB — el bucket propio de cada cliente
UI de gestor de archivos embebible
Código abierto (MIT)
Sin tarifas SaaS por almacenamiento / subida
Multi-almacenamiento (S3 / R2 / local)
Alcance de token por inquilino integrado

La comparación refleja las ofertas por defecto habituales; cada producto destaca en lo suyo. El nicho de FluxFiles es la combinación embebible, autoalojado y bring-your-own-bucket.

Productos vendibles

Más que gestionar archivos — véndelos y recíbelos

El núcleo gratis integra un gestor de archivos. Los módulos de pago lo convierten en productos por los que tus clientes pagan.

Pro

Branded Share

Envía un enlace autoservicio con tu marca a cualquier archivo o carpeta — con caducidad, contraseña, límite de descargas y analíticas. Tu logo, tu dominio.

  • Enlaces con caducidad / protegidos por contraseña
  • Límites de descarga + analíticas
  • Token restringido — sin cuenta para el destinatario
Pro

Upload Portals

Una página pública «envíanos tus archivos» que aterriza directo en tu almacenamiento. Perfecto para agencias, fotógrafos y onboarding de clientes — sin cuenta para quien sube.

  • Portal público → tu bucket
  • Límites de tamaño / tipo / caducidad por portal
  • Subida anónima, restringida al propietario
Enterprise

Compliance bundle

Antivirus, procedencia de contenido C2PA y retención de auditoría — para despliegues regulados y de empresa.

WordPress

Un plugin en vez de tres

En WordPress, FluxFiles es a la vez un portal de archivos para clientes Y un gestor de medios — reemplazando plugins separados de carpetas, nube y offload.

Capacidad FluxFiles FileBird WP Media Folder WP Offload
Carpetas de medios
Almacenamiento S3 / R2 / SFTP
Offload + reescritura de URL
Portales de subida de clientes
Enlaces de compartir con marca
Precio típico Una licencia 49 $/año 69 $/año de pago

Carpetas + nube + offload + portales de clientes en uno — en vez de pagar FileBird y WP Media Folder y WP Offload por separado.

Precios

Núcleo gratis. Paga solo por los módulos de pago.

El núcleo MIT es gratis para siempre. Mejora a los dos productos estrella — Compartir con marca + Portales de subida — y más.

Gratis (Núcleo)

$0 para siempre

El gestor de archivos MIT completo, autoalojado.

Empezar
  • Almacenamiento Local / S3 / R2 / SFTP, alcance JWT
  • WebP + AVIF bajo demanda + optimización imagen/PDF
  • Marca de agua, hook de versiones, panel de uso, etiquetado IA
  • 7 adaptadores + BYO-embed terminal / PDF / office / firma electrónica
Más popular

Pro

$79 /año

Envía y recibe archivos con tus clientes.

PróximamentePróximamente
  • Todo lo gratis
  • Compartir con marca — enlaces con caducidad / contraseña / límite / analíticas
  • Portales de subida — «envíanos archivos» público, sin cuenta
  • Soporte prioritario + actualizaciones

Studio

$299 /año

Construye un producto sobre FluxFiles.

PróximamentePróximamente
  • Todo lo Pro
  • Versionado + Webhooks (Zapier/Make/n8n)
  • IA Visión + OCR (tu clave)
  • Niveles multi-inquilino + marca blanca

Enterprise

A medida

Cumplimiento, a escala.

Contactar ventas
  • Todo lo Studio
  • Antivirus + procedencia C2PA + retención de auditoría
  • Puente SSO + onboarding a medida
  • SLA + hoja de ruta prioritaria

Tarifa plana, sitios ilimitados — sin cobro por archivo/llamada. El anual ahorra ~2 meses; opción de por vida disponible. Reembolso 14 días. IVA del comprador gestionado al pagar.

Preguntas frecuentes

Preguntas frecuentes

¿FluxFiles es gratuito y de código abierto?
Sí — con licencia MIT, autoalojable gratis y publicado en Composer y npm. Sin niveles de pago ni límites de uso.
¿Dónde se almacenan mis archivos?
Donde tú lo indiques: disco local, AWS S3, Cloudflare R2 o un servidor remoto vía SFTP, todo a través de Flysystem. El almacenamiento es tuyo — nada pasa por un tercero.
¿Cómo funciona la autenticación?
JWT sin estado (HS256): emites un token en el servidor con claims granulares (permisos, discos, alcance de ruta, límites), así cada usuario solo ve lo que permites.
¿Mis usuarios necesitan una cuenta de FluxFiles?
No. FluxFiles confía en el JWT que emite tu propia app, así que se conecta a tu autenticación existente — sin un sistema de usuarios aparte.
¿Puedo integrarlo en mi app o editor actual?
Sí — el iframe + SDK de JS funciona en cualquier página, con adaptadores oficiales para Laravel, WordPress, React, Vue/Nuxt, CKEditor 4, TinyMCE y Summernote.
¿Qué necesito para ejecutarlo?
PHP 8.1+ con algunas extensiones comunes y Composer. Apúntalo a un disco, define un secreto y los orígenes permitidos, y sírvelo — funciona en un VPS pequeño.
¿Qué incluyen los planes de pago?
El núcleo es gratis (MIT). Los planes de pago desbloquean módulos de portal: Compartir con marca (enlaces con caducidad/contraseña) y Portales de subida («envíanos archivos» público), más Versionado, Webhooks, IA Visión/OCR y un paquete de cumplimiento en niveles superiores.
¿Cómo activo una licencia?
Tras la compra recibes una clave de licencia. Define FLUXFILES_LICENSE_KEY en tu entorno y los módulos se desbloquean — verificados sin conexión (sin llamadas), así que funciona en entornos aislados.
¿Pago único o suscripción?
Ambos. Mensual para empezar sin compromiso, anual para ahorrar (~2 meses gratis), o de por vida en un pago. Una licencia caducada sigue ejecutando tu versión; solo se pausan actualizaciones/soporte.

¿Listo para integrar FluxFiles?

Añade un gestor de archivos listo para producción a tu aplicación en minutos, sin atarte a ningún framework y con licencia MIT.