v0.2 — Open Source · MIT-licentie

De bestandsbeheerder die overal past

PHP ≥ 8.1 + Flysystem 3. Alpine.js-UI. Local, S3, Cloudflare R2, SFTP. Sluit in met een paar regels JavaScript.

PHP ≥ 8.1
Geen framework nodig
~3 KB
SDK-bundel grootte
MIT
Open source licentie
16
Ondersteunde talen
Live voorbeeld

Bekijk het in actie

Creating a FluxFiles share link with an expiry, a password and a download limit
Deel een bestand — vervaldatum, wachtwoord, limiet
Creating a FluxFiles upload portal with a file limit, size cap and allowed file types
Uploadportalen — zonder account ontvangen
FluxFiles links panel listing shared links with views, downloads and revoke
Beheer elke link en trek hem wanneer je wilt in
FluxFiles desktop file manager with image thumbnails
Rasterweergave met directe WebP-thumbnails
FluxFiles browsing an S3 / R2 bucket with the local, S3 and SFTP disk switcher
Multi-cloud — S3 / R2 / SFTP, één UI
FluxFiles managing a remote VPS deploy directory over SFTP, same UI as the S3 bucket
Externe VPS via SFTP — geen FTP-client nodig
Editing an nginx config file inside FluxFiles with syntax highlighting
Configuratiebestanden ter plekke bewerken — zonder SSH of FTP
FluxFiles previewing a video inline in the detail panel
Video-, audio- en PDF-voorbeeld zonder downloaden
FluxFiles Bucket Doctor health checks for an S3 bucket with CORS and IAM remediation
Bucket Doctor — S3/R2-controles + oplossingen
FluxFiles activity log of file operations
Activiteitenlog — bewaard in je eigen bucket
FluxFiles trash with restore and delete forever
Prullenbak — herstellen of definitief verwijderen
FluxFiles responsive mobile file manager
Responsief op mobiel
De slotgracht · BYOB

De bestanden van je klanten blijven in de buckets van je klanten

FluxFiles is de insluitbare bestandsmanager waarbij elke tenant zijn eigen S3/R2-bucket koppelt — en jij bewaart noch hun data noch hun credentials.

  • Datasoevereiniteit

    Bestanden staan in het eigen cloud-account en de regio van de klant — gebouwd voor AVG, compliance en enterprise-inkoop.

  • Geen data, geen credentials in rust

    Bucket-credentials worden met AES-256-GCM versleuteld in de JWT en alleen tijdens runtime ontsleuteld — nooit naar een database of log geschreven.

  • Opslagkosten die naar nul schalen

    Opslag en egress worden aan elke klant gefactureerd, niet aan jou. Geen opslagrekening die meegroeit met je gebruikers.

  • Stateless en insluitbaar

    Geen centrale database. Plaats de picker in elke app via iframe of SDK; je backend geeft een scoped, kortlevend token uit.

Jouw SaaS-app
scoped JWT (versleutelde creds)
FluxFiles
ontsleutelt alleen tijdens runtime
Tenant A
eigen bucket
Tenant B
eigen bucket
Tenant C
eigen bucket

Hoe het werkt: je app versleutelt de bucket-credentials van de tenant in een kortlevende JWT (HKDF-SHA256 + AES-256-GCM). FluxFiles ontsleutelt ze alleen om de gevraagde bewerking uit te voeren.

Multi-tenant

Eén token per tenant — elk met eigen regels

FluxFiles is stateless: de JWT die je backend uitgeeft is de configuratie van de tenant. Opslagpad, maximale bestandsgrootte, quotum, aantal bestanden, toegestane types, rechten — allemaal serverzijdig afgedwongen. Geen configbestanden per tenant, geen herstarts.

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

Combineer met BYOB om elke tenant op een eigen bucket te zetten.

Voor wie

Gebouwd voor teams die bestandsfuncties uitbrengen

Als je product uploads nodig heeft, past FluxFiles erin — zonder dat jij de beheerder van de data van je klanten wordt.

SaaS- en multi-tenant-apps

Geef elke klant een bestandsmanager op de eigen bucket. Token-scoping per tenant en datasoevereiniteit zitten erin.

Bureaus en freelancers

Lever elke klant een verzorgde mediabibliotheek zonder per project opslaginfra op te zetten.

CMS- en editor-integraties

Plaats een mediakiezer in CKEditor, TinyMCE, Summernote of je eigen editor via de iframe-SDK.

Interne tools en dashboards

Voeg uploads, previews en geaudite bestandsbewerkingen toe aan admin-panels in een middag.

Functies

Alles wat een moderne bestandsbeheerder nodig heeft

Gebouwd voor ontwikkelaars die flexibiliteit nodig hebben.

Multi-opslag

Lokaal, AWS S3, Cloudflare R2, SFTP via Flysystem v3 — wissel via config, geen codewijziging.

Overal integreren

iframe + postMessage SDK. Standalone UI gebruikt Alpine.js (geen build). Werkt met elk framework.

JWT-auth + scoping

Pad-prefix per gebruiker, rechten, schijf-whitelist, alleen-eigenaar modus.

AI auto-tag

Claude / OpenAI vision — automatisch alt-tekst, titel, tags.

Afbeelding bijsnijden

Inline bijsnijdtool met beeldverhouding-presets.

Afbeelding optimalisatie

Automatische WebP-varianten — thumb, medium, groot.

Vooraf ondertekende uploads

Browser uploadt rechtstreeks naar S3/R2 — nul bandbreedte op uw server.

Chunk upload

S3 multipart voor bestanden > 10MB.

Zoeken in volledige tekst

Geïndexeerde zoekopdracht op namen, titels, tags — bestandsgebaseerd, geen database.

Bulkbewerkingen

Multi-select verplaatsen, kopiëren, verwijderen, downloaden.

Cross-disk overdracht

Kopiëren/verplaatsen tussen Lokaal ↔ S3 ↔ R2.

Prullenbak

Herstelbare verwijderingen met automatische opschoning.

SEO-metadata

Titel, alt, bijschrift, tags — S3-objectmetadata (cloud) of sidecar JSON (lokaal). Zoeken in volledige tekst.

Donkere modus

Licht / donker / auto in UI en SDK.

16 talen

Standaard Engels. Stel taal in via SDK, URL (?locale=) of FLUXFILES_LOCALE. RTL voor Arabisch.

Auditlogboek

Alle schrijfacties gelogd voor compliance.

Snelheidsbeperking

Token bucket per gebruiker voor API-bescherming.

Opslagquota

Limieten per gebruiker via JWT-claims.

BYOB-buckets

Gebruikers koppelen eigen S3/R2 — inloggegevens versleuteld in JWT (AES-256-GCM).

Duplicaatdetectie

SHA-256-match slaat redundante uploads over tenzij geforceerd overschrijven.

SDK-token vernieuwen

onTokenRefresh bij 401 — samengevoegde refresh, opnieuw proberen, updateToken().

Bucket Doctor

Diagnosticeer elke S3/R2-schijf — credentials, lezen/schrijven/verwijderen, presign, CORS, multipart — met kant-en-klare IAM- en CORS-fixes. Onboard BYOB-buckets in minuten.

Node token SDK

Genereer FluxFiles-tokens vanuit elke JS-backend (Express, Next.js, Nuxt) met @fluxfiles/node — byte-compatibel met de PHP-core. Geen PHP nodig om tokens uit te geven.

SFTP-schijf

Een 3e driver na S3/R2 — maak van elke VPS of host een bestandsbeheerder.

Code-/config-editor

Bewerk tekst- en configbestanden (wp-config.php, .env) in de browser, cPanel-stijl.

Zip & Uitpakken

Download een selectie als zip of pak een archief uit — beveiligd tegen zip-slip & bom.

Watermerk

Pas direct een tekst- of logo-watermerk toe ter bescherming — bron blijft ongemoeid.

On-demand WebP + AVIF

Serveer elke afbeeldingsgrootte als gecachte AVIF/WebP via één URL (Accept-onderhandeld), met kant-en-klare responsieve srcset.

SFTP-rechten

Wijzig Unix-bestandsrechten (chmod) op SFTP-schijven met een cPanel-achtig dialoog.

Gebruiksdashboard

Opslag in één oogopslag — quota plus uitsplitsing per type en map.

Mediavoorbeeld

Inline voorbeeld van beeld, video, audio & PDF; privé lokale media veilig gestreamd.

Snel installeren

Klaar in 2 minuten

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=

Werkt met

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

Integraties

Kant-en-klare adapters voor jouw stack

Officiële adapters bouwen FluxFiles native in de frameworks en editors die je al gebruikt.

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

Insluiten

Sluit het in een paar regels in

Laad fluxfiles.js, geef een server-uitgegeven JWT mee en plaats een volledige bestandsbeheerder — of een bestandskiezer-modal — op elke pagina.

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

Tokens worden serverzijdig uitgegeven — stuur je secret nooit naar de browser.

Waarom FluxFiles

Gebouwd voor wat anderen vergaten

Veeg om te vergelijken
Functie FluxFiles elFinder Laravel-FM RichFilemanager Responsive FM
S3 + R2 + Lokaal + SFTP
Integreren in elk framework
JWT-auth + scoping
SEO-metadata
AI auto-tag
Afbeelding bijsnijden
Chunk upload
Zoeken in volledige tekst
Donkere modus
16 talen
PHP ≥ 8.1
Actief onderhouden
Moderne UI
vs. file-API-SaaS

Self-hosted en insluitbaar — niet zomaar een upload-SaaS

Gehoste file-API's zijn prima, maar ze bewaren je data en rekenen per gebruik. FluxFiles draait in je eigen stack, met elke tenant op zijn eigen bucket.

Veeg om te vergelijken
Mogelijkheid FluxFiles Filestack Uploadcare Cloudinary Supabase Storage
Self-hosted (draait in je eigen infra)
BYOB — eigen bucket per klant
Insluitbare bestandsmanager-UI
Open source (MIT)
Geen SaaS-kosten per opslag / per upload
Multi-storage (S3 / R2 / lokaal)
Token-scoping per tenant ingebouwd

De vergelijking weerspiegelt typische standaardaanbiedingen; elk product blinkt uit in zijn eigen domein. De niche van FluxFiles is de insluitbare, self-hosted, bring-your-own-bucket-combinatie.

Verkoopbare producten

Meer dan bestanden beheren — verkoop en ontvang ze

De gratis kern integreert een bestandsbeheerder. De betaalde modules maken er producten van waar je klanten voor betalen.

Pro

Branded Share

Stuur een gebrande self-service link naar elk bestand of map — met vervaldatum, wachtwoord, downloadlimiet en weergave-analytics. Jouw logo, jouw domein.

  • Vervallende / wachtwoordbeveiligde links
  • Downloadlimieten + weergave-analytics
  • Beperkt token — geen account voor de ontvanger
Pro

Upload Portals

Een publieke «stuur ons je bestanden»-pagina die direct in je opslag belandt. Perfect voor bureaus, fotografen en klant-onboarding — geen account voor de uploader.

  • Publiek portaal → jouw bucket
  • Grootte- / type- / vervallimieten per portaal
  • Anoniem uploaden, eigenaar-scoped
Enterprise

Compliance bundle

Virusscan, C2PA-inhoudsherkomst en auditbewaring — voor gereguleerde en enterprise-implementaties.

WordPress

Eén plugin in plaats van drie

Op WordPress is FluxFiles zowel een klant-bestandsportaal ALS een mediabeheerder — vervangt aparte map-, cloud- en offload-plugins.

Mogelijkheid FluxFiles FileBird WP Media Folder WP Offload
Mediamappen
S3 / R2 / SFTP-opslag
Offload + URL-herschrijving
Klant-uploadportalen
Branded share-links
Typische prijs Eén licentie $49/jaar $69/jaar betaald

Mappen + cloud + offload + klantportalen in één — in plaats van FileBird en WP Media Folder en WP Offload apart te betalen.

Prijzen

Kern gratis. Betaal alleen voor betaalde modules.

De MIT-kern is voor altijd gratis. Upgrade naar de twee kernproducten — Branded Share + Upload-portalen — en meer.

Gratis (Kern)

$0 voor altijd

De volledige MIT-bestandsbeheerder, self-hosted.

Aan de slag
  • Local / S3 / R2 / SFTP-opslag, JWT-scoping
  • On-demand WebP + AVIF + afbeelding/PDF-optimalisatie
  • Watermerk, versie-hook, gebruiksdashboard, AI-autotag
  • 7 adapters + BYO-embed terminal / PDF / office / e-signing
Populairst

Pro

$79 /jaar

Verstuur en ontvang bestanden met klanten.

BinnenkortBinnenkort
  • Alles uit Gratis
  • Branded Share — links met vervaldatum / wachtwoord / limiet / analytics
  • Upload-portalen — publiek «stuur ons bestanden», zonder account
  • Prioriteitssupport + updates

Studio

$299 /jaar

Bouw een product op FluxFiles.

BinnenkortBinnenkort
  • Alles uit Pro
  • Versiebeheer + Webhooks (Zapier/Make/n8n)
  • AI Vision + OCR (eigen sleutel)
  • Multi-tenant niveaus + white-label

Enterprise

Op maat

Compliance, op schaal.

Contact sales
  • Alles uit Studio
  • Virusscan + C2PA-herkomst + auditbewaring
  • SSO-bridge + maatwerk onboarding
  • SLA + prioriteitsroadmap

Vast tarief, onbeperkte sites — geen kosten per bestand/aanroep. Jaarlijks bespaart ~2 maanden; lifetime-optie beschikbaar. 14 dagen retour. Btw koper afgehandeld bij afrekenen.

FAQ

Veelgestelde vragen

Is FluxFiles gratis en open source?
Ja — MIT-gelicentieerd, gratis zelf te hosten en gepubliceerd op Composer en npm. Geen betaalde niveaus of gebruikslimieten.
Waar worden mijn bestanden opgeslagen?
Waar je het op richt: lokale schijf, AWS S3, Cloudflare R2 of een externe server via SFTP, allemaal via Flysystem. De opslag is van jou — niets gaat via een derde partij.
Hoe werkt authenticatie?
Stateless JWT (HS256): je geeft serverzijdig een token uit met fijnmazige claims (rechten, disks, padbereik, limieten), zodat elke gebruiker alleen ziet wat jij toestaat.
Hebben mijn gebruikers een FluxFiles-account nodig?
Nee. FluxFiles vertrouwt op de JWT die je eigen app uitgeeft, dus het sluit aan op je bestaande authenticatie — geen apart gebruikerssysteem.
Kan ik het insluiten in mijn bestaande app of editor?
Ja — de iframe + JS-SDK werkt op elke pagina, met officiële adapters voor Laravel, WordPress, React, Vue/Nuxt, CKEditor 4, TinyMCE en Summernote.
Wat heb ik nodig om het te draaien?
PHP 8.1+ met enkele gangbare extensies en Composer. Richt het op een schijf, stel een secret en toegestane origins in, en serveer — het draait op een kleine VPS.
Wat bevatten de betaalde niveaus?
De kern is gratis (MIT). Betaalde niveaus ontgrendelen portaalmodules: Branded Share (vervallende/wachtwoordlinks) en Upload-portalen (publiek «stuur ons bestanden»), plus Versiebeheer, Webhooks, AI Vision/OCR en een compliance-bundel op hogere niveaus.
Hoe activeer ik een licentie?
Na aankoop krijg je een licentiesleutel. Stel FLUXFILES_LICENSE_KEY in je omgeving in en de modules ontgrendelen — offline geverifieerd (geen phone-home), dus ook air-gapped bruikbaar.
Eenmalig of abonnement?
Beide. Maandelijks voor een vrijblijvende start, jaarlijks om te besparen (~2 maanden gratis), of eenmalig lifetime. Een verlopen licentie blijft je versie draaien; alleen updates/support pauzeren.

Klaar om FluxFiles in te bouwen?

Voeg in enkele minuten een productieklare bestandsbeheerder toe aan je app — geen framework-lock-in, MIT-gelicentieerd.