Pocketbase est l’un des projets backend open-source les plus séduisants en 2026 (informations vérifiées en avril 2026, susceptibles d’évoluer). Un seul binaire de ~30 Mo qui contient une base SQLite, une API REST auto-générée, un système d’authentification (email/password, OAuth), un dashboard d’admin web, des subscriptions temps réel via WebSockets, et un système de fichiers/uploads. Pour les freelances, indie hackers et PME africaines qui veulent un backend pour app mobile ou web sans s’embêter avec une infrastructure complexe, Pocketbase est imbattable. Voici le guide pratique 2026.

Ce guide général couvre l’ensemble : pourquoi Pocketbase, installation, schéma, auth, API, hooks Go, déploiement. Les articles connexes approfondissent : déployer Pocketbase sur Coolify, auth Pocketbase avec OAuth Google, extensibilité avec hooks Go, Pocketbase vs Firebase vs Supabase.

Pourquoi Pocketbase en 2026

Un binaire unique : pas de Docker, pas de containers, pas de dépendances. Vous téléchargez, vous lancez, c’est en ligne.
Open source MIT, code Go, ~30 000 étoiles GitHub mi-2026
SQLite intégré : robuste, simple à backuper, parfait pour des projets jusqu’à plusieurs millions de lignes
Auth complète : email/password, OAuth (Google, GitHub, etc.), email verification, password reset, gestion sessions
API REST auto-générée : pour chaque collection, endpoints CRUD avec filtrage, tri, pagination
Realtime via WebSocket : subscriptions sur changements de données
Dashboard admin web moderne et clair, sans configuration
Fichiers et uploads : gestion native, intégration S3 possible
SDK officiels JS, Dart (Flutter), Swift, Kotlin

Pour qui c’est fait

App mobile (Flutter, React Native, Swift, Kotlin) qui a besoin d’un backend rapide
SaaS B2C ou B2B en early stage
Outils internes PME (CRM léger, gestion stock, formulaires)
Prototypes qui doivent évoluer en prod sans réécriture
Sites statiques qui ont besoin de quelques routes dynamiques (newsletter, contact, commentaires)

Limites à connaître

SQLite single-server : pas de cluster horizontal natif. Pour une charge supérieure à ~1000 RPS, regarder vers Postgres + framework custom ou Supabase.
Pas de migrations versionnées sophistiquées : les changements de schéma se font via le dashboard ou via fichiers de migration Go.
Customisation = Go : les hooks et extensions custom demandent de connaître Go (mais reste lisible)
Stockage local par défaut : pour scaler, configurer S3 (étape simple)

Étape 1 — Installer Pocketbase

# Télécharger le binaire (Linux x86_64)
wget https://github.com/pocketbase/pocketbase/releases/download/v0.22.x/pocketbase_0.22.x_linux_amd64.zip
unzip pocketbase_*.zip
chmod +x pocketbase

# Lancer
./pocketbase serve --http=0.0.0.0:8090

# Accéder au dashboard d'admin
# Navigateur : http://VOTRE_IP:8090/_/
# Premier accès : créer le compte super-admin

C’est tout. Pocketbase tourne, l’API est disponible sur /api/*, le dashboard sur /_/, et la base de données est dans ./pb_data/.

Étape 2 — Créer une collection

Dans le dashboard admin → Collections → New collection. Choisissez le type (Base, Auth, View). Pour une app classique, créez une collection posts de type Base avec :

title : text, required, min 3 max 200
content : editor (rich text)
author : relation vers users, required, single
published : bool, default false
cover : file (single, image)

Configurez les API rules : qui peut lire, créer, modifier, supprimer. Exemples :

List/View : published = true || @request.auth.id != ""
Create : @request.auth.id != "" (user authentifié)
Update/Delete : @request.auth.id = author.id (auteur uniquement)

Étape 3 — Utiliser depuis JS / TS

import PocketBase from "pocketbase";

const pb = new PocketBase("https://api.exemple.sn");

// Auth
const authData = await pb.collection("users").authWithPassword(
  "user@exemple.sn",
  "secret123",
);

// Lister posts publiés
const posts = await pb.collection("posts").getList(1, 20, {
  filter: 'published = true',
  sort: '-created',
  expand: 'author',
});

// Créer un post
const created = await pb.collection("posts").create({
  title: "Hello",
  content: "World",
  author: pb.authStore.model.id,
  published: true,
});

// Subscribe realtime
pb.collection("posts").subscribe("*", (e) => {
  console.log(e.action, e.record);
});

Étape 4 — Authentification

Pocketbase gère nativement plusieurs flows d’auth :

Email/password classique
Email verification (envoi d’un lien)
Password reset
OAuth providers (Google, GitHub, GitLab, Apple, Facebook, etc.) — voir notre guide OAuth Pocketbase
Sessions JWT, refresh automatique
Multi-collection auth (users + admins + autre)

Étape 5 — Hooks Go pour personnalisation

Pour ajouter de la logique métier custom (validation, notifications, agrégations), utilisez les hooks Go. Pocketbase est lui-même un framework Go que vous pouvez compiler avec votre code custom :

// main.go
package main

import (
    "log"
    "github.com/pocketbase/pocketbase"
    "github.com/pocketbase/pocketbase/core"
)

func main() {
    app := pocketbase.New()

    app.OnRecordCreateRequest("posts").BindFunc(func(e *core.RecordRequestEvent) error {
        log.Println("Nouveau post :", e.Record.GetString("title"))
        return e.Next()
    })

    if err := app.Start(); err != nil {
        log.Fatal(err)
    }
}

Voir notre guide hooks Go Pocketbase pour des cas concrets : envoi email Mobile Money, intégration WhatsApp Business, calculs personnalisés.

Étape 6 — Déployer en production

Coolify : déploiement en un clic, voir notre tutoriel
systemd : un service Linux simple sur VPS Hetzner — voir guide systemd (similaire approche)
Docker : image officielle non maintenue, mais Dockerfile facile à écrire
fly.io ou Railway : hébergement managé qui simplifie

Pour HTTPS, mettez Caddy ou Traefik devant Pocketbase. Pocketbase écoute en HTTP en interne, le reverse proxy fait HTTPS.

Étape 7 — Backups

SQLite = un fichier ./pb_data/data.db. Backup = copier ce fichier (idéalement via sqlite3 .backup pour éviter les corruptions). Automatisation cron quotidien :

#!/bin/bash
# /etc/cron.daily/pb-backup
DATE=$(date +%Y%m%d-%H%M%S)
sqlite3 /opt/pocketbase/pb_data/data.db ".backup /tmp/pb-$DATE.db"
gzip /tmp/pb-$DATE.db
aws s3 cp /tmp/pb-$DATE.db.gz s3://backups/pocketbase/
rm /tmp/pb-$DATE.db.gz

Adaptation Afrique de l’Ouest

Pocketbase est particulièrement adapté pour les projets ouest-africains : un seul VPS Hetzner CX23 à 4 €/mois suffit pour une app qui sert 1000-10 000 utilisateurs actifs quotidiens. La base SQLite est performante et facile à sauvegarder. L’absence de complexité opérationnelle libère du temps pour bâtir le produit.

Erreurs fréquentes

Erreur	Cause	Solution
« database is locked »	Trop d’écritures concurrentes	Activer WAL : sqlite3 ./pb_data/data.db « PRAGMA journal_mode=WAL »
API rules trop ouvertes	Pas de filtre auth	Toujours @request.auth.id != « »
Email verification ne marche pas	SMTP pas configuré	Settings → Mail Settings (Brevo, Mailtrap)
Uploads volumineux refusés	Limite 5 Mo par défaut	Augmenter dans collection schema

Sur un angle proche

Déployer Pocketbase sur Coolify
Auth Pocketbase OAuth Google
Hooks Go Pocketbase
Pocketbase vs Firebase vs Supabase
Documentation officielle : pocketbase.io/docs

Étape 1 : télécharger et installer Pocketbase sur Ubuntu 24.04

Pocketbase est distribué sous forme d’un binaire Go unique, sans dépendance, idéal pour un VPS Hetzner CX22 à 4,90 EUR/mois (3 215 FCFA) hébergé à Falkenstein avec une latence raisonnable depuis Dakar ou Abidjan.

# Télécharger la dernière release stable
cd /opt
sudo wget https://github.com/pocketbase/pocketbase/releases/download/v0.23.4/pocketbase_0.23.4_linux_amd64.zip
sudo unzip pocketbase_0.23.4_linux_amd64.zip
sudo chmod +x pocketbase
# Vérifier
./pocketbase --version

La sortie attendue affiche la version 0.23.x. Pocketbase fonctionne sans base externe : la donnée est stockée dans un fichier SQLite local, ce qui simplifie radicalement l’infrastructure pour un projet africain.

Étape 2 : créer le compte super-admin et démarrer le serveur

Au premier lancement, Pocketbase ouvre un onglet d’inscription pour le super-admin. Sur un VPS sans interface graphique, créez le compte en CLI puis démarrez le serveur en écoute sur 127.0.0.1.

# Créer le super-admin en CLI
sudo ./pocketbase superuser create admin@exemple.io MotDePasseFort123
# Démarrer en mode développement (port 8090)
./pocketbase serve --http=127.0.0.1:8090
# Sortie attendue :
# Server started at http://127.0.0.1:8090
# REST API: http://127.0.0.1:8090/api/
# Admin UI: http://127.0.0.1:8090/_/

L’interface admin est accessible via un tunnel SSH ssh -L 8090:127.0.0.1:8090 user@vps depuis votre poste à Dakar. Évitez d’exposer le port 8090 directement sur Internet sans reverse proxy.

Étape 3 : configurer Nginx en reverse proxy avec HTTPS Let’s Encrypt

Pour un usage production, placez Nginx devant Pocketbase avec un certificat Let’s Encrypt. Le HTTPS est non-négociable pour toute API consommée par une app mobile au Sénégal ou en Côte d’Ivoire.

# /etc/nginx/sites-available/pocketbase
server {
    server_name api.exemple.io;
    location / {
        proxy_pass http://127.0.0.1:8090;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
# Activer + Let's Encrypt
sudo ln -s /etc/nginx/sites-available/pocketbase /etc/nginx/sites-enabled/
sudo certbot --nginx -d api.exemple.io

Certbot configure automatiquement le HTTPS et le renouvellement. Vérifiez avec curl -I https://api.exemple.io/api/health — la réponse doit contenir {« code »:200}.

Étape 4 : créer une collection users et activer l’authentification

Pocketbase fournit nativement une collection users avec hashage bcrypt et tokens JWT. Configurez-la depuis l’admin UI puis testez l’inscription via API.

# Inscription d'un utilisateur via API
curl -X POST https://api.exemple.io/api/collections/users/records \
  -H "Content-Type: application/json" \
  -d '{
    "email": "test@exemple.io",
    "password": "MotDePasseFort456",
    "passwordConfirm": "MotDePasseFort456"
  }'
# Réponse : objet user avec id et created

Le mot de passe est hashé en bcrypt côté serveur — jamais stocké en clair. La connexion suivante via /api/collections/users/auth-with-password retourne un JWT à inclure dans le header Authorization: Bearer ….

Étape 5 : créer une collection métier avec règles d’accès

Pour un MVP de marketplace au Sénégal, créez une collection annonces avec champs titre, prix (en FCFA), description, image et propriétaire. Les règles définissent qui peut lire ou écrire.

# Règles recommandées (admin UI → collection → API rules)
List/View  : @request.auth.id != ""
Create     : @request.auth.id != "" && @request.data.user = @request.auth.id
Update     : user = @request.auth.id
Delete     : user = @request.auth.id

Avec ces règles, un utilisateur ne peut modifier ou supprimer que ses propres annonces. La règle Create empêche d’usurper un autre user en forgeant le champ user dans la requête.

Étape 6 : intégrer Pocketbase dans une app React ou Svelte

Le SDK JavaScript officiel simplifie l’intégration côté frontend. Une app Vite + React déployée sur Cloudflare Pages consomme l’API en moins de 50 lignes.

# Installer le SDK
npm install pocketbase
# src/lib/pb.js
import PocketBase from 'pocketbase';
export const pb = new PocketBase('https://api.exemple.io');
# Exemple d'inscription depuis React
await pb.collection('users').create({
  email, password, passwordConfirm: password
});
await pb.collection('users').authWithPassword(email, password);

Le SDK gère automatiquement le stockage du token dans localStorage et le rattache aux requêtes suivantes. Pour un build mobile React Native, utilisez AsyncStorage à la place via l’option authStore.

Étape 7 : utiliser les realtime subscriptions pour le chat ou notifications

Pocketbase intègre nativement Server-Sent Events (SSE) pour pousser les changements aux clients. Idéal pour un chat ou un suivi de commandes Wave en temps réel.

# Souscrire aux nouvelles annonces depuis le frontend
pb.collection('annonces').subscribe('*', (e) => {
  if (e.action === 'create') {
    console.log('Nouvelle annonce :', e.record);
  }
});
# Désabonnement à la destruction du composant
pb.collection('annonces').unsubscribe();

Le canal SSE consomme peu de ressources serveur — un VPS CX22 supporte facilement 500 connexions simultanées. Pour scaler au-delà, placez un Cloudflare Tunnel devant pour la mise en cache des assets.

Étape 8 : sauvegarder la base SQLite quotidiennement

Tout votre projet tient dans le fichier pb_data/data.db. Une sauvegarde quotidienne chiffrée vers un object storage Hetzner ou Backblaze B2 protège contre la perte de données.

# /usr/local/bin/pb-backup.sh
#!/bin/bash
DATE=$(date +%Y%m%d)
sqlite3 /opt/pb_data/data.db ".backup /tmp/pb-$DATE.db"
gpg --batch --yes --passphrase-file /root/.pb-pass \
  -c /tmp/pb-$DATE.db
rclone copy /tmp/pb-$DATE.db.gpg backup:pocketbase/
rm /tmp/pb-$DATE.db*
# Crontab : 0 3 * * * /usr/local/bin/pb-backup.sh

Le .backup SQLite est cohérent même si l’application écrit en parallèle. Le chiffrement GPG empêche un opérateur cloud de lire vos données — important si votre client final exige la conformité aux lois locales sur les données personnelles.

Étape 9 : étendre Pocketbase avec des hooks Go ou JavaScript

Au-delà du CRUD standard, Pocketbase accepte des hooks pour la logique métier : envoyer un SMS Wave après une commande, calculer la TVA OHADA, ou appeler une API externe.

# pb_hooks/main.pb.js (chargé automatiquement)
onRecordAfterCreateRequest((e) => {
  if (e.record.collection().name === "commandes") {
    const total = e.record.get("montant");
    const tva = total * 0.18;
    e.record.set("tva_fcfa", tva);
    $app.dao().saveRecord(e.record);
  }
}, "commandes")

Les hooks JavaScript tournent dans un moteur Goja embarqué — pas de Node.js à installer. Pour des traitements plus lourds, recompilez Pocketbase avec un module Go custom — la documentation officielle détaille la procédure.

Étape 10 : monitorer Pocketbase en production

Surveillez le CPU, la RAM, la taille du fichier SQLite et le nombre de connexions SSE. Une fuite de souscription non fermée fait grossir la mémoire au fil des semaines.

# Métriques rapides en CLI
ps aux | grep pocketbase
ls -lh /opt/pb_data/data.db
ss -ant state established | grep :8090 | wc -l
# Logs Pocketbase
journalctl -u pocketbase -f

Configurez Uptime Kuma sur un autre VPS pour pinger /api/health chaque minute. Une alerte Telegram en cas de coupure permet une intervention en moins de 5 minutes — critique pour une marketplace générant des ventes Mixx by Yas en continu.

À lire ensuite, consultez notre tutoriel pour déployer une app Svelte sur Cloudflare Pages et le guide sauvegarde chiffrée VPS vers Backblaze B2.

Étape 11 : configurer un service systemd pour la résilience

En production, ne lancez jamais Pocketbase manuellement. Un service systemd redémarre le binaire après crash ou reboot — indispensable pour un VPS qui peut être redémarré par Hetzner pour maintenance.

# /etc/systemd/system/pocketbase.service
[Unit]
Description=Pocketbase
After=network.target
[Service]
Type=simple
User=pocketbase
WorkingDirectory=/opt/pocketbase
ExecStart=/opt/pocketbase/pocketbase serve --http=127.0.0.1:8090
Restart=always
RestartSec=5
[Install]
WantedBy=multi-user.target
# Activer
sudo systemctl enable --now pocketbase

Vérifiez avec sudo systemctl status pocketbase — l’état doit être active (running). En cas de crash, systemd relance le processus en 5 secondes, garantissant une disponibilité supérieure à 99,9 %.

Étape 12 : durcir l’accès admin avec une règle Nginx geo-fence

L’interface admin /_/ ne devrait être accessible que depuis vos IP de confiance. Une règle Nginx limite l’accès à votre IP fixe ou un VPN WireGuard hébergé à Dakar.

# Bloc Nginx restrictif
location /_/ {
    allow 41.83.0.0/16;   # Votre plage Sonatel
    allow 10.8.0.0/24;    # VPN interne
    deny all;
    proxy_pass http://127.0.0.1:8090;
}

Cette protection réduit drastiquement la surface d’attaque. Même si un mot de passe admin fuite, l’attaquant ne pourra pas atteindre l’interface depuis une IP non autorisée. Combiné au 2FA TOTP activable depuis Pocketbase 0.22, votre admin est solidement verrouillé.