v0.2 — Open Source · MIT-Lizenz

Der Dateimanager, der überall eingebettet wird

PHP ≥ 8.1 + Flysystem 3. Alpine.js-UI. Local, S3, Cloudflare R2, SFTP. In wenigen Zeilen JavaScript einbetten.

PHP ≥ 8.1
Kein Framework erforderlich
~3 KB
SDK-Paketgröße
MIT
Open-Source-Lizenz
16
Unterstützte Sprachen
Vorschau

In Aktion sehen

Creating a FluxFiles share link with an expiry, a password and a download limit
Datei teilen — Ablauf, Passwort, Limit
Creating a FluxFiles upload portal with a file limit, size cap and allowed file types
Upload-Portale — ohne Konto empfangen
FluxFiles links panel listing shared links with views, downloads and revoke
Alle Links verwalten und jederzeit widerrufen
FluxFiles desktop file manager with image thumbnails
Rasteransicht mit sofortigen WebP-Thumbnails
FluxFiles browsing an S3 / R2 bucket with the local, S3 and SFTP disk switcher
Multi-Cloud — S3 / R2 / SFTP in einer UI
FluxFiles managing a remote VPS deploy directory over SFTP, same UI as the S3 bucket
Remote-VPS per SFTP — ohne FTP-Client
Editing an nginx config file inside FluxFiles with syntax highlighting
Konfigurationsdateien direkt bearbeiten — ohne SSH oder FTP
FluxFiles previewing a video inline in the detail panel
Video-, Audio- und PDF-Vorschau ohne Download
FluxFiles Bucket Doctor health checks for an S3 bucket with CORS and IAM remediation
Bucket Doctor — S3/R2-Diagnose + Korrekturen
FluxFiles activity log of file operations
Aktivitätsprotokoll — in Ihrem eigenen Bucket
FluxFiles trash with restore and delete forever
Papierkorb — wiederherstellen oder endgültig löschen
FluxFiles responsive mobile file manager
Mobil responsiv
Der Burggraben · BYOB

Die Dateien Ihrer Kunden bleiben in den Buckets Ihrer Kunden

FluxFiles ist der einbettbare Dateimanager, bei dem jeder Mandant seinen eigenen S3/R2-Bucket verbindet — und Sie speichern niemals dessen Daten oder Zugangsdaten.

  • Datensouveränität

    Dateien liegen im eigenen Cloud-Konto und der Region des Kunden — gemacht für DSGVO, Compliance und Enterprise-Beschaffung.

  • Null Daten, null Zugangsdaten im Ruhezustand

    Bucket-Zugangsdaten werden mit AES-256-GCM im JWT verschlüsselt und nur zur Laufzeit entschlüsselt — niemals in eine Datenbank oder ein Log geschrieben.

  • Speicherkosten, die gegen null gehen

    Speicher und Egress werden jedem Kunden berechnet, nicht Ihnen. Keine Rechnung, die mit der Nutzerzahl wächst.

  • Zustandslos & einbettbar

    Keine zentrale Datenbank. Betten Sie den Picker per iframe oder SDK in jede App ein; Ihr Backend stellt ein eingeschränktes, kurzlebiges Token aus.

Ihre SaaS-App
eingeschränktes JWT (verschlüsselte Creds)
FluxFiles
nur zur Laufzeit entschlüsselt
Mandant A
eigener Bucket
Mandant B
eigener Bucket
Mandant C
eigener Bucket

So funktioniert es: Ihre App verschlüsselt die Bucket-Zugangsdaten des Mandanten in ein kurzlebiges JWT (HKDF-SHA256 + AES-256-GCM). FluxFiles entschlüsselt sie nur, um die angeforderte Operation auszuführen.

Mandantenfähig

Ein Token pro Mandant — jeder mit eigenen Regeln

FluxFiles ist zustandslos: Das vom Backend ausgestellte JWT ist die Konfiguration des Mandanten. Speicherpfad, Dateigrößenlimit, Kontingent, Dateianzahl, erlaubte Typen, Rechte — alles serverseitig erzwungen. Keine Konfigdateien pro Mandant, keine Neustarts.

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

Mit BYOB kombiniert liegt jeder Mandant in seinem eigenen Bucket.

Für wen

Gebaut für Teams, die Datei-Funktionen ausliefern

Wenn Ihr Produkt Uploads braucht, fügt sich FluxFiles ein — ohne Sie zum Verwalter der Kundendaten zu machen.

SaaS & Multi-Tenant-Apps

Geben Sie jedem Kunden einen Dateimanager auf dem eigenen Bucket. Token-Scoping pro Mandant und Datenhoheit sind eingebaut.

Agenturen & Freelancer

Liefern Sie jedem Kunden eine gepflegte Mediathek, ohne pro Projekt Speicher-Infrastruktur aufzubauen.

CMS- & Editor-Integrationen

Binden Sie einen Medien-Picker per iframe-SDK in CKEditor, TinyMCE, Summernote oder Ihren eigenen Editor ein.

Interne Tools & Dashboards

Ergänzen Sie Admin-Panels an einem Nachmittag um Uploads, Vorschauen und auditierte Dateioperationen.

Funktionen

Alles, was ein moderner Dateimanager braucht

Gebaut für Entwickler, die Flexibilität brauchen.

Multi-Speicher

Lokal, AWS S3, Cloudflare R2, SFTP über Flysystem v3 — per Konfiguration wechseln, kein Code-Change.

Überall einbetten

iframe + postMessage SDK. Standalone-UI mit Alpine.js (ohne Build). Funktioniert mit jedem Framework.

JWT-Auth + Scoping

Pfad-Präfix pro Nutzer, Berechtigungen, Disk-Whitelist, Owner-only-Modus.

AI Auto-Tag

Claude / OpenAI Vision — automatisch Alt-Text, Titel, Tags.

Bildzuschnitt

Inline-Zuschnitt mit Seitenverhältnis-Vorlagen.

Bildoptimierung

Automatische WebP-Varianten — Thumb, Mittel, Groß.

Vorsignierte Uploads

Browser lädt direkt zu S3/R2 hoch — null Bandbreite auf Ihrem Server.

Chunk-Upload

S3 Multipart für Dateien > 10MB.

Volltextsuche

Indizierte Suche über Namen, Titel, Tags — dateibasiert, ohne Datenbank.

Massenoperationen

Mehrfachauswahl: Verschieben, Kopieren, Löschen, Herunterladen.

Cross-Disk-Transfer

Kopieren/Verschieben zwischen Lokal ↔ S3 ↔ R2.

Papierkorb

Wiederherstellbares Löschen mit automatischer Bereinigung.

SEO-Metadaten

Titel, Alt, Beschriftung, Tags — S3-Objektmetadaten (Cloud) oder Sidecar-JSON (lokal). Volltextsuche.

Dunkelmodus

Hell / dunkel / auto in UI und SDK.

16 Sprachen

Standard Englisch. Locale über SDK, URL (?locale=) oder FLUXFILES_LOCALE. RTL für Arabisch.

Audit-Protokoll

Alle Schreibaktionen werden protokolliert.

Ratenbegrenzung

Token Bucket pro Benutzer zum API-Schutz.

Speicherkontingent

Benutzerlimits über JWT-Claims.

BYOB-Buckets

Nutzer bringen eigenes S3/R2 — Zugangsdaten verschlüsselt im JWT (AES-256-GCM).

Duplikaterkennung

SHA-256-Match überspringt redundante Uploads außer bei erzwungenem Überschreiben.

SDK-Token-Refresh

onTokenRefresh bei 401 — zusammengefasster Refresh, Retry und updateToken() für proaktive Rotation.

Bucket Doctor

Diagnostiziert jedes S3/R2-Laufwerk — Zugangsdaten, Lesen/Schreiben/Löschen, Presign, CORS, Multipart — mit einfügefertigen IAM- und CORS-Fixes. BYOB-Buckets in Minuten einrichten.

Node-Token-SDK

Stellen Sie FluxFiles-Tokens aus jedem JS-Backend (Express, Next.js, Nuxt) mit @fluxfiles/node aus — Byte-kompatibel mit dem PHP-Kern. Kein PHP zur Token-Ausstellung nötig.

SFTP-Laufwerk

Ein 3. Treiber nach S3/R2 — jeder VPS oder Webspace wird zum Dateimanager.

Code-/Config-Editor

Text- und Konfigdateien (wp-config.php, .env) im Browser bearbeiten, à la cPanel.

Zip & Entpacken

Auswahl als Zip laden oder Archiv entpacken — gegen Zip-Slip & -Bombe geschützt.

Wasserzeichen

Text- oder Logo-Wasserzeichen on-the-fly zum Vorschauschutz — Quelle bleibt unberührt.

On-Demand WebP + AVIF

Jede Bildgröße als gecachtes AVIF/WebP über eine URL ausliefern (Accept-verhandelt), mit fertigem responsivem srcset.

SFTP-Rechte

Unix-Dateirechte (chmod) auf SFTP-Laufwerken per cPanel-artigem Dialog ändern.

Nutzungs-Dashboard

Speicher auf einen Blick — Kontingent plus Aufschlüsselung nach Typ und Ordner.

Medienvorschau

Inline-Vorschau für Bild, Video, Audio & PDF; private lokale Medien sicher gestreamt.

Schnellinstallation

In 2 Minuten einsatzbereit

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=

Kompatibel mit

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

Integrationen

Sofort einsatzbereite Adapter für Ihren Stack

Offizielle Adapter binden FluxFiles nativ in die Frameworks und Editoren ein, die Sie bereits nutzen.

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

Einbetten

In wenigen Zeilen einbetten

Laden Sie fluxfiles.js, übergeben Sie ein serverseitig erzeugtes JWT und setzen Sie einen vollwertigen Dateimanager — oder ein Dateiauswahl-Modal — in jede Seite.

<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 werden serverseitig erzeugt — geben Sie Ihr Secret niemals an den Browser weiter.

Warum FluxFiles

Gebaut für das, was andere vergessen haben

Wischen zum Vergleichen
Funktion FluxFiles elFinder Laravel-FM RichFilemanager Responsive FM
S3 + R2 + Local + SFTP
Jedes Framework einbetten
JWT-Auth + Scoping
SEO-Metadaten
AI Auto-Tag
Bildzuschnitt
Chunk-Upload
Volltextsuche
Dunkelmodus
16 Sprachen
PHP ≥ 8.1
Aktiv gewartet
Moderne UI
vs. Datei-API-SaaS

Selbst gehostet und einbettbar — kein weiteres Upload-SaaS

Gehostete Datei-APIs sind großartig, aber sie speichern Ihre Daten und rechnen nach Nutzung ab. FluxFiles läuft in Ihrem Stack, jeder Mandant auf seinem eigenen Bucket.

Wischen zum Vergleichen
Funktion FluxFiles Filestack Uploadcare Cloudinary Supabase Storage
Selbst gehostet (läuft in Ihrer Infrastruktur)
BYOB — der eigene Bucket jedes Kunden
Einbettbare Dateimanager-UI
Open Source (MIT)
Keine SaaS-Gebühren pro Speicher / Upload
Multi-Storage (S3 / R2 / lokal)
Token-Scoping pro Mandant integriert

Der Vergleich spiegelt typische Standardangebote wider; jedes Produkt glänzt in seinem Bereich. Die Nische von FluxFiles ist die Kombination aus einbettbar, selbst gehostet und Bring-your-own-Bucket.

Verkäufliche Produkte

Mehr als Dateien verwalten — sie verkaufen und empfangen

Der kostenlose Kern bettet einen Dateimanager ein. Die kostenpflichtigen Module machen daraus Produkte, für die Ihre Kunden zahlen.

Pro

Branded Share

Senden Sie einen gebrandeten Self-Service-Link zu jeder Datei oder jedem Ordner — mit Ablauf, Passwort, Download-Limit und Aufruf-Analytics. Ihr Logo, Ihre Domain.

  • Ablaufende / passwortgeschützte Links
  • Download-Limits + Aufruf-Analytics
  • Beschränktes Token — kein Konto für den Empfänger
Pro

Upload Portals

Eine öffentliche „Schick uns deine Dateien“-Seite, die direkt in Ihren Speicher landet. Perfekt für Agenturen, Fotografen und Kunden-Onboarding — kein Konto für den Uploader.

  • Öffentliches Portal → Ihr Bucket
  • Größe/Typ/Ablauf-Limits pro Portal
  • Anonymer Upload, eigentümerbeschränkt
Enterprise

Compliance bundle

Virenscan, C2PA-Inhaltsherkunft und Audit-Aufbewahrung — für regulierte und Enterprise-Deployments.

WordPress

Ein Plugin statt drei

Auf WordPress ist FluxFiles zugleich ein Kunden-Dateiportal UND ein Medienmanager — ersetzt separate Ordner-, Cloud- und Offload-Plugins.

Funktion FluxFiles FileBird WP Media Folder WP Offload
Medienordner
S3 / R2 / SFTP-Speicher
Offload + URL-Rewrite
Kunden-Upload-Portale
Branded Share-Links
Typischer Preis Eine Lizenz 49 $/Jahr 69 $/Jahr kostenpflichtig

Ordner + Cloud + Offload + Kundenportale in einem — statt FileBird und WP Media Folder und WP Offload getrennt zu zahlen.

Preise

Kern kostenlos. Nur für kostenpflichtige Module zahlen.

Der MIT-Kern ist für immer kostenlos. Upgrade auf die zwei Hauptprodukte — Branded Share + Upload-Portale — und mehr.

Kostenlos (Kern)

$0 für immer

Der vollständige MIT-Dateimanager, selbstgehostet.

Loslegen
  • Local / S3 / R2 / SFTP-Speicher, JWT-Scoping
  • On-Demand WebP + AVIF + Bild-/PDF-Optimierung
  • Wasserzeichen, Versions-Hook, Nutzungs-Dashboard, KI-Auto-Tag
  • 7 Adapter + BYO-embed Terminal / PDF / Office / E-Signatur
Am beliebtesten

Pro

$79 /Jahr

Dateien mit Kunden senden und empfangen.

DemnächstDemnächst
  • Alles aus Kostenlos
  • Branded Share — Links mit Ablauf / Passwort / Limit / Analytics
  • Upload-Portale — öffentliches „Schick uns Dateien“, ohne Konto
  • Prioritäts-Support + Updates

Studio

$299 /Jahr

Ein Produkt auf FluxFiles aufbauen.

DemnächstDemnächst
  • Alles aus Pro
  • Versionierung + Webhooks (Zapier/Make/n8n)
  • KI-Vision + OCR (eigener Key)
  • Mandantenfähige Stufen + White-Label

Enterprise

Individuell

Compliance, skaliert.

Vertrieb kontaktieren
  • Alles aus Studio
  • Virenscan + C2PA-Herkunft + Audit-Aufbewahrung
  • SSO-Bridge + individuelles Onboarding
  • SLA + priorisierte Roadmap

Pauschal, unbegrenzte Sites — keine Abrechnung pro Datei/Aufruf. Jährlich spart ~2 Monate; Lifetime-Option verfügbar. 14 Tage Rückgabe. Käufer-USt. beim Checkout.

FAQ

Häufige Fragen

Ist FluxFiles kostenlos und Open Source?
Ja — MIT-lizenziert, kostenlos selbst hostbar und auf Composer und npm veröffentlicht. Keine kostenpflichtigen Stufen, keine Nutzungslimits.
Wo werden meine Dateien gespeichert?
Wo immer Sie es festlegen: lokale Festplatte, AWS S3, Cloudflare R2 oder ein entfernter Server per SFTP über Flysystem. Der Speicher gehört Ihnen — nichts läuft über Dritte.
Wie funktioniert die Authentifizierung?
Zustandsloses JWT (HS256): Sie erzeugen serverseitig ein Token mit feingranularen Claims (Berechtigungen, Disks, Pfad-Scope, Limits), sodass jeder Nutzer nur sieht, was Sie erlauben.
Brauchen meine Nutzer ein FluxFiles-Konto?
Nein. FluxFiles vertraut dem JWT aus Ihrer eigenen App und fügt sich so in Ihre bestehende Authentifizierung ein — kein separates Nutzersystem.
Kann ich es in meine bestehende App oder meinen Editor einbetten?
Ja — iframe + JS-SDK funktioniert auf jeder Seite, mit offiziellen Adaptern für Laravel, WordPress, React, Vue/Nuxt, CKEditor 4, TinyMCE und Summernote.
Was brauche ich, um es zu betreiben?
PHP 8.1+ mit einigen gängigen Erweiterungen und Composer. Auf einen Disk verweisen, Secret und erlaubte Origins setzen, dann starten — läuft auf einem kleinen VPS.
Was enthalten die kostenpflichtigen Stufen?
Der Kern ist kostenlos (MIT). Kostenpflichtige Stufen schalten Portal-Module frei: Branded Share (ablaufende/passwortgeschützte Links) und Upload-Portale (öffentliches „Schick uns Dateien“), plus Versionierung, Webhooks, KI-Vision/OCR und ein Compliance-Bundle in höheren Stufen.
Wie aktiviere ich eine Lizenz?
Nach dem Kauf erhalten Sie einen Lizenzschlüssel. Setzen Sie FLUXFILES_LICENSE_KEY in Ihrer Umgebung und die Module werden freigeschaltet — offline verifiziert (kein Phone-Home), also auch air-gapped nutzbar.
Einmalig oder Abo?
Beides. Monatlich für einen unverbindlichen Start, jährlich zum Sparen (~2 Monate gratis) oder einmalig als Lifetime. Eine abgelaufene Lizenz führt Ihre Version weiter aus; nur Updates/Support pausieren.

Bereit, FluxFiles einzubinden?

Fügen Sie Ihrer App in wenigen Minuten einen produktionsreifen Dateimanager hinzu – ohne Framework-Bindung, MIT-lizenziert.