v0.2 — Open Source · Licence MIT

Le gestionnaire de fichiers intégrable partout

PHP ≥ 8.1 + Flysystem 3. Interface Alpine.js. Local, S3, Cloudflare R2, SFTP. Intégrez en quelques lignes de JavaScript.

PHP ≥ 8.1
Aucun framework requis
~3 KB
Taille du SDK
MIT
Licence open source
16
Langues supportées
Aperçu

Voir en action

Creating a FluxFiles share link with an expiry, a password and a download limit
Partage — expiration, mot de passe, limite
Creating a FluxFiles upload portal with a file limit, size cap and allowed file types
Portails de dépôt — sans compte
FluxFiles links panel listing shared links with views, downloads and revoke
Gérez chaque lien, révoquez-en un à tout moment
FluxFiles desktop file manager with image thumbnails
Vue grille avec vignettes WebP instantanées
FluxFiles browsing an S3 / R2 bucket with the local, S3 and SFTP disk switcher
Multi-cloud — S3 / R2 / SFTP, une seule UI
FluxFiles managing a remote VPS deploy directory over SFTP, same UI as the S3 bucket
VPS distant en SFTP — sans client FTP
Editing an nginx config file inside FluxFiles with syntax highlighting
Modifiez les fichiers de config sur place — sans SSH ni FTP
FluxFiles previewing a video inline in the detail panel
Aperçu vidéo, audio et PDF sans téléchargement
FluxFiles Bucket Doctor health checks for an S3 bucket with CORS and IAM remediation
Bucket Doctor — diagnostics S3/R2 + correctifs
FluxFiles activity log of file operations
Journal d'activité — conservé dans votre bucket
FluxFiles trash with restore and delete forever
Corbeille — restaurer ou supprimer définitivement
FluxFiles responsive mobile file manager
Adapté au mobile
L’atout · BYOB

Les fichiers de vos clients restent dans les buckets de vos clients

FluxFiles est le gestionnaire de fichiers intégrable où chaque locataire connecte son propre bucket S3/R2 — et vous ne stockez jamais ses données ni ses identifiants.

  • Souveraineté des données

    Les fichiers résident dans le compte cloud et la région du client — pensé pour le RGPD, la conformité et les achats en entreprise.

  • Zéro donnée, zéro identifiant au repos

    Les identifiants du bucket sont chiffrés en AES-256-GCM dans le JWT et déchiffrés uniquement à l’exécution — jamais écrits en base ou dans un log.

  • Un coût de stockage qui tend vers zéro

    Le stockage et l’egress sont facturés à chaque client, pas à vous. Pas de facture qui gonfle avec votre base d’utilisateurs.

  • Sans état et intégrable

    Aucune base centrale. Intégrez le sélecteur dans n’importe quelle app via iframe ou SDK ; votre backend émet un jeton restreint et de courte durée.

Votre app SaaS
JWT restreint (identifiants chiffrés)
FluxFiles
déchiffré à l’exécution uniquement
Locataire A
son bucket
Locataire B
son bucket
Locataire C
son bucket

Fonctionnement : votre app chiffre les identifiants du bucket du locataire dans un JWT de courte durée (HKDF-SHA256 + AES-256-GCM). FluxFiles ne les déchiffre que pour exécuter l’opération demandée.

Multi-tenant

Un token par tenant — chacun ses règles

FluxFiles est sans état : le JWT émis par votre backend est la config du tenant. Chemin de stockage, taille max par fichier, quota, nombre de fichiers, types autorisés, permissions — tout est appliqué côté serveur. Aucun fichier de config par tenant, aucun redémarrage.

// 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

Associez-le au BYOB pour mettre chaque tenant sur son propre bucket.

Pour qui

Conçu pour les équipes qui livrent des fonctions de fichiers

Si votre produit a besoin d'uploads, FluxFiles s'intègre — sans faire de vous le gardien des données de vos clients.

SaaS & apps multi-tenant

Offrez à chaque client un gestionnaire de fichiers sur son propre bucket. Scoping de token par tenant et souveraineté des données inclus.

Agences & freelances

Livrez une médiathèque soignée à chaque client sans monter une infra de stockage par projet.

Intégrations CMS & éditeurs

Ajoutez un sélecteur de médias à CKEditor, TinyMCE, Summernote ou votre propre éditeur via le SDK iframe.

Outils internes & tableaux de bord

Ajoutez uploads, aperçus et opérations de fichiers auditées à vos panneaux d'admin en un après-midi.

Fonctionnalités

Tout ce dont un gestionnaire de fichiers moderne a besoin

Conçu pour les développeurs qui ont besoin de flexibilité.

Multi-stockage

Local, AWS S3, Cloudflare R2, SFTP via Flysystem v3 — changez par la config, sans modifier le code.

Intégration partout

iframe + SDK postMessage. L'UI autonome utilise Alpine.js (zéro build). Compatible avec tout framework.

Auth JWT + portée

Préfixe de chemin par utilisateur, permissions, liste blanche de disques, mode owner-only.

AI auto-tag

Claude / OpenAI vision — alt texte, titre, tags automatiques.

Recadrage d'image

Outil de recadrage avec ratios prédéfinis.

Optimisation d'image

Variantes WebP automatiques — miniature, moyen, grand.

Uploads présignés

Le navigateur uploade directement vers S3/R2 — zéro bande passante serveur.

Upload par morceaux

S3 multipart pour fichiers > 10Mo.

Recherche plein texte

Recherche indexée par noms, titres, tags — basée fichier, sans base de données.

Opérations en masse

Sélection multiple : déplacer, copier, supprimer, télécharger.

Transfert cross-disk

Copier/déplacer entre Local ↔ S3 ↔ R2.

Corbeille

Suppression réversible avec purge automatique.

Métadonnées SEO

Titre, alt, légende, tags — métadonnées objet S3 (cloud) ou JSON sidecar (local). Recherche plein texte.

Mode sombre

Clair / sombre / auto dans l'UI et le SDK.

16 langues

Anglais par défaut. Définissez la locale via SDK, URL (?locale=) ou FLUXFILES_LOCALE. RTL pour l'arabe.

Journal d'audit

Toutes les actions d'écriture enregistrées.

Limitation de débit

Token bucket par utilisateur pour la protection API.

Quota de stockage

Limites par utilisateur via JWT claims.

Buckets BYOB

Les utilisateurs apportent leur S3/R2 — identifiants chiffrés dans le JWT (AES-256-GCM).

Détection des doublons

Correspondance SHA-256 — ignore les uploads redondants sauf écrasement forcé.

Rafraîchissement du token SDK

onTokenRefresh sur 401 — refresh fusionné, retry, et updateToken() pour rotation proactive.

Bucket Doctor

Diagnostique n’importe quel disque S3/R2 — identifiants, lecture/écriture/suppression, presign, CORS, multipart — avec des correctifs IAM et CORS prêts à coller. Intégrez un bucket BYOB en quelques minutes.

SDK de jetons Node

Émettez des jetons FluxFiles depuis n’importe quel backend JS (Express, Next.js, Nuxt) avec @fluxfiles/node — compatible octet par octet avec le cœur PHP. Aucun PHP requis pour émettre des jetons.

Disque SFTP

Un 3ᵉ pilote après S3/R2 — transformez tout VPS ou hébergement en gestionnaire.

Éditeur code / config

Éditez fichiers texte et config (wp-config.php, .env) dans le navigateur, façon cPanel.

Zip & Extraction

Téléchargez une sélection en zip ou extrayez sur place — anti zip-slip & bombe.

Filigrane

Appliquez un filigrane texte ou logo à la volée — le fichier source reste intact.

WebP + AVIF à la demande

Servez toute taille d'image en AVIF/WebP mis en cache via une seule URL (négociée par Accept), avec srcset responsive prêt.

Permissions SFTP

Modifiez les permissions Unix (chmod) sur disques SFTP via une boîte façon cPanel.

Tableau de bord d'usage

Visualisez le stockage d'un coup d'œil — quota et répartition par type et dossier.

Aperçu média

Aperçu image, vidéo, audio & PDF en ligne ; médias locaux privés diffusés en sécurité.

Installation rapide

Opérationnel en 2 minutes

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 avec

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

Intégrations

Des adaptateurs prêts à l'emploi pour votre stack

Les adaptateurs officiels intègrent nativement FluxFiles aux frameworks et éditeurs que vous utilisez déjà.

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

Intégration

Intégrez-le en quelques lignes

Chargez fluxfiles.js, passez un JWT généré côté serveur, et insérez un gestionnaire de fichiers complet — ou une fenêtre de sélection — dans n'importe quelle page.

<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)}
    />
  );
}

Les jetons sont générés côté serveur — n'envoyez jamais votre secret au navigateur.

Pourquoi FluxFiles

Conçu pour ce que les autres ont oublié

Glissez pour comparer
Fonctionnalité FluxFiles elFinder Laravel-FM RichFilemanager Responsive FM
S3 + R2 + Local + SFTP
Intégration tout framework
Auth JWT + portée
Métadonnées SEO
AI auto-tag
Recadrage d'image
Upload par morceaux
Recherche plein texte
Mode sombre
16 langues
PHP ≥ 8.1
Maintenance active
UI moderne
face aux SaaS de fichiers

Auto-hébergé et intégrable — pas un énième SaaS d’upload

Les API de fichiers hébergées sont excellentes, mais elles stockent vos données et facturent à l’usage. FluxFiles tourne dans votre stack, chaque locataire sur son propre bucket.

Glissez pour comparer
Capacité FluxFiles Filestack Uploadcare Cloudinary Supabase Storage
Auto-hébergé (tourne dans votre infra)
BYOB — le bucket de chaque client
UI de gestion de fichiers intégrable
Open source (MIT)
Aucun frais SaaS au stockage / à l’upload
Multi-stockage (S3 / R2 / local)
Portée de jeton par locataire intégrée

Le comparatif reflète les offres par défaut habituelles ; chaque produit excelle dans son domaine. La niche de FluxFiles est la combinaison intégrable, auto-hébergée et bring-your-own-bucket.

Produits à vendre

Bien plus que gérer des fichiers — les vendre et les recevoir

Le cœur gratuit intègre un gestionnaire de fichiers. Les modules payants en font des produits que vos clients paient.

Pro

Branded Share

Envoyez un lien en libre-service à votre marque vers n'importe quel fichier ou dossier — avec expiration, mot de passe, limite de téléchargement et analytics. Votre logo, votre domaine.

  • Liens à expiration / protégés par mot de passe
  • Limites de téléchargement + analytics
  • Jeton restreint — pas de compte pour le destinataire
Pro

Upload Portals

Une page publique « envoyez-nous vos fichiers » qui atterrit directement dans votre stockage. Parfait pour agences, photographes et onboarding client — pas de compte pour l'envoyeur.

  • Portail public → votre bucket
  • Limites taille / type / expiration par portail
  • Envoi anonyme, restreint au propriétaire
Enterprise

Compliance bundle

Antivirus, provenance de contenu C2PA et rétention d'audit — pour déploiements réglementés et entreprise.

WordPress

Un plugin au lieu de trois

Sur WordPress, FluxFiles est à la fois un portail de fichiers client ET un gestionnaire de médias — remplaçant les plugins séparés de dossiers, cloud et offload.

Capacité FluxFiles FileBird WP Media Folder WP Offload
Dossiers média
Stockage S3 / R2 / SFTP
Offload + réécriture d'URL
Portails d'envoi client
Liens de partage de marque
Prix typique Une licence 49 $/an 69 $/an payant

Dossiers + cloud + offload + portails client en un — au lieu de payer FileBird et WP Media Folder et WP Offload séparément.

Tarifs

Cœur gratuit. Ne payez que les modules payants.

Le cœur MIT est gratuit à vie. Passez aux deux produits phares — Partage de marque + Portails d'envoi — et au-delà.

Gratuit (Cœur)

$0 à vie

Le gestionnaire de fichiers MIT complet, auto-hébergé.

Commencer
  • Stockage Local / S3 / R2 / SFTP, portée JWT
  • WebP + AVIF à la demande + optimisation image/PDF
  • Filigrane, hook de versions, tableau de bord d'usage, tags IA
  • 7 adaptateurs + BYO-embed terminal / PDF / office / e-signature
Le plus populaire

Pro

$79 /an

Envoyez et recevez des fichiers avec vos clients.

BientôtBientôt
  • Tout le gratuit
  • Partage de marque — liens avec expiration / mot de passe / limite / analytics
  • Portails d'envoi — « envoyez-nous des fichiers » public, sans compte
  • Support prioritaire + mises à jour

Studio

$299 /an

Construisez un produit sur FluxFiles.

BientôtBientôt
  • Tout le Pro
  • Versioning + Webhooks (Zapier/Make/n8n)
  • IA Vision + OCR (votre clé)
  • Paliers multi-locataires + marque blanche

Enterprise

Sur mesure

Conformité, à grande échelle.

Contacter les ventes
  • Tout le Studio
  • Antivirus + provenance C2PA + rétention d'audit
  • Passerelle SSO + intégration sur mesure
  • SLA + feuille de route prioritaire

Tarif fixe, sites illimités — pas de facturation à l'usage. L'annuel économise ~2 mois ; option à vie disponible. Remboursement 14 jours. TVA acheteur gérée au paiement.

FAQ

Questions fréquentes

FluxFiles est-il gratuit et open source ?
Oui — sous licence MIT, auto-hébergeable gratuitement, et publié sur Composer et npm. Aucun palier payant ni limite d'usage.
Où mes fichiers sont-ils stockés ?
Là où vous le décidez : disque local, AWS S3, Cloudflare R2 ou un serveur distant via SFTP, le tout via Flysystem. Le stockage vous appartient — rien ne transite par un tiers.
Comment fonctionne l'authentification ?
JWT sans état (HS256) : vous générez un jeton côté serveur avec des revendications fines (permissions, disques, portée de chemin, limites), de sorte que chaque utilisateur ne voit que ce que vous autorisez.
Mes utilisateurs ont-ils besoin d'un compte FluxFiles ?
Non. FluxFiles fait confiance au JWT émis par votre propre application, donc il se branche sur votre authentification existante — aucun système d'utilisateurs séparé.
Puis-je l'intégrer dans mon application ou mon éditeur existant ?
Oui — l'iframe + le SDK JS fonctionne dans n'importe quelle page, avec des adaptateurs officiels pour Laravel, WordPress, React, Vue/Nuxt, CKEditor 4, TinyMCE et Summernote.
De quoi ai-je besoin pour l'exécuter ?
PHP 8.1+ avec quelques extensions courantes et Composer. Pointez-le vers un disque, définissez un secret et les origines autorisées, puis lancez-le — il tourne sur un petit VPS.
Que comprennent les offres payantes ?
Le cœur est gratuit (MIT). Les offres payantes débloquent les modules de portail : Partage de marque (liens expirants/protégés) et Portails d'envoi (« envoyez-nous des fichiers » public), plus Versioning, Webhooks, IA Vision/OCR et un bundle de conformité aux niveaux supérieurs.
Comment activer une licence ?
Après l'achat, vous recevez une clé de licence. Définissez FLUXFILES_LICENSE_KEY dans votre environnement et les modules payants se débloquent — vérifiés hors ligne (sans appel réseau), donc utilisables en air-gap.
Achat unique ou abonnement ?
Les deux. Mensuel pour un démarrage sans engagement, annuel pour économiser (~2 mois offerts), ou à vie en une fois. Une licence expirée continue d'exécuter votre version ; seuls les mises à jour/support s'arrêtent.

Prêt à intégrer FluxFiles ?

Ajoutez un gestionnaire de fichiers prêt pour la production à votre application en quelques minutes — sans dépendance à un framework, sous licence MIT.