title: MyFin created: 2026-06-07 updated: 2026-06-07 type: app tags: [catalogue, budgeting, python, django, finance, personnel, budget] confidence: medium contested: false sources: [https://selfh.st/apps/?tag=budgeting, https://github.com/afaneca/myfin, https://myfin.app/]

MyFin 🐍

Application de budgeting personnel écrite en Python/Django, conçue pour un usage familial ou individuel. Suivi de comptes, transactions récurrentes, budgets, objectifs d'épargne et tableau de bord sobre.

Métadonnée	Valeur
Site web	https://myfin.app/
GitHub	https://github.com/afaneca/myfin
License	AGPL-3.0
Langage	Python (Django)
Étoiles	⭐42
Dernière MAJ	2026-03-25
Catégorie	cat-budgeting

Description

MyFin est une application web de gestion de finances personnelles écrite en Python avec Django (full-stack : backend + templates Django + un peu de JS). Le projet vise à fournir un outil simple mais complet pour suivre ses comptes, gérer ses budgets par catégorie, et visualiser ses finances sur un tableau de bord clair. C'est l'un des rares projets de budgeting en Python/Django à côté d'ExpenseOwl (Flask).

Les fonctionnalités principales : comptes multiples (chèque, épargne, cartes, crédit, investissement), transactions (revenus/dépenses/transferts) avec catégorisation, budgets mensuels par catégorie avec alertes en cas de dépassement, transactions récurrentes (salaires, abonnements, factures), objectifs d'épargne avec barre de progression et date cible, catégories hiérarchiques avec icônes, tableau de bord avec vue d'ensemble (solde total, revenus/mois, dépenses/mois, taux d'épargne), graphiques (camembert des dépenses par catégorie, évolution du solde sur 12 mois, comparaison budget/réel), multi-utilisateurs natif (compte familial/partage), import CSV depuis banques, export CSV/Excel.

L'architecture Django est un choix solide : ORM puissant, admin Django gratuit (pour la gestion), système d'auth mature, structure MVC éprouvée. L'UI utilise les templates Django + Bootstrap (ou Tailwind selon la version) + Chart.js pour les graphes. Pas de build JS complexe, pas de SPA — l'interface se recharge normalement, ce qui est amplement suffisant pour un usage de gestion budget.

L'avantage de MyFin sur Firefly III : bien plus simple à installer et utiliser (interface moins riche mais plus directe), et la stack Python est familière à beaucoup d'auto-hébergeurs. L'inconvénient : projet jeune (~42⭐), moins battle-tested — à tester avant production critique.

Installation

Via Docker (recommandé)

# docker-compose.yml
services:
  myfin:
    image: ghcr.io/afaneca/myfin:latest
    container_name: myfin
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
    ports:
      - "8000:8000"
    environment:
      - DJANGO_SECRET_KEY=***      - DJANGO_DEBUG=false
      - DJANGO_ALLOWED_HOSTS=budget.example.com
      - DB_HOST=db
      - DB_PORT=5432
      - DB_NAME=myfin
      - DB_USER=myfin
      - DB_PASSWORD=***      - DJANGO_TIME_ZONE=Europe/Paris
    healthcheck:
      test: ["CMD", "wget", "--spider", "-q", "http://localhost:8000/"]
      interval: 30s
      timeout: 10s
      retries: 3

  db:
    image: postgres:16-alpine
    container_name: myfin-db
    restart: unless-stopped
    environment:
      - POSTGRES_DB=myfin
      - POSTGRES_USER=myfin
      - POSTGRES_PASSWORD=***    volumes:
      - myfin-db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U myfin -d myfin"]
      interval: 10s
      timeout: 5s
      retries: 10

volumes:
  myfin-db:

⚠️ Vérifier l'image exacte sur le GHCR (le tag latest peut évoluer).

Installation manuelle (Django)

Pré-requis : Python 3.10+, pip, PostgreSQL 14+, Node.js 18+ (assets).
git clone https://github.com/afaneca/myfin.git && cd myfin
Créer un venv : python3 -m venv venv && source venv/bin/activate
pip install -r requirements.txt
Configurer .env ou settings.py (SECRET_KEY, DB, ALLOWED_HOSTS, TIME_ZONE).
Migrations : python manage.py migrate
Créer le superuser : python manage.py createsuperuser
python manage.py collectstatic --noinput
python manage.py runserver (dev) ou via Gunicorn/uWSGI (prod).
Reverse proxy Nginx/Caddy en front (HTTPS obligatoire).

Configuration

DJANGO_SECRET_KEY : clé Django critique — générer via python -c "import secrets; print(secrets.token_urlsafe(50))".
DJANGO_DEBUG=false : obligatoire en production.
Premier lancement : se connecter avec le superuser créé, créer les comptes bancaires, configurer les catégories.
Comptes : créer un compte par produit bancaire, saisir le solde initial.
Catégories : créer l'arborescence, assigner des icônes.
Budgets : par mois, par catégorie.
Récurrences : configurer salaires, abonnements, factures récurrentes.
HTTPS : obligatoire via reverse proxy (Traefik/Caddy) + SECURE_SSL_REDIRECT=True dans settings.
Backups : pg_dump quotidien + copie des médias (reçus téléversés).
Timezone Europe/Paris : configurer pour des dates/heures correctes.

Alternatives

Open Source

app-actual-budget — référence local-first (TypeScript)
app-firefly-iii — gestion finances complète (PHP)
app-sure — plateforme Elixir moderne
app-expenseowl — minimaliste Python (Flask)
app-monetr — alternative Go
app-budget-board — dashboard TypeScript
Maybe (Ruby) / Perfin (Go) — projets alternatifs

Propriétaires

YNAB — référence du zero-based (~14$/mois)
Monarch Money — UX premium (~99$/an)
Mint (ex-Intuit) — abandonné
PocketGuard — mobile-first

Sécurité

HTTPS obligatoire via reverse proxy.
DJANGO_SECRET_KEY : généré aléatoirement (50+ caractères), ne jamais commit dans Git.
DJANGO_DEBUG=false : désactive les pages d'erreur verbeuses en prod.
PostgreSQL : user dédié, mot de passe fort, limiter au réseau Docker interne.
CSRF : natif Django, ne pas désactiver.
Headers de sécurité : SECURE_SSL_REDIRECT, SECURE_HSTS_SECONDS, SECURE_CONTENT_TYPE_NOSNIFF, X_FRAME_OPTIONS='DENY' dans settings.
2FA : non natif, à compenser via reverse proxy (Authelia) ou module tiers (django-otp).
Backups 3-2-1 : pg_dump + médias, tester la restauration.
Updates Django : suivre les releases de sécurité (CVE), Django publie des patches rapides.
Logs : logs Django standards, intégration avec Sentry ou Grafana Loki.
Admin Django : restreindre l'accès par IP ou via reverse proxy auth.

Ressources

Site officiel : https://myfin.app/
GitHub : https://github.com/afaneca/myfin
Documentation : https://github.com/afaneca/myfin/wiki
selfh.st : https://selfh.st/apps/?tag=budgeting

Pages Liées

cat-budgeting — catégorie parente
app-actual-budget — concurrent direct
app-firefly-iii — référence (PHP, plus mature)
app-expenseowl — alternative Python (Flask, minimaliste)
app-sure — alternative Elixir
recettes-docker-compose — templates de déploiement
securisation-home-lab — bonnes pratiques

7.4 KiB Raw Blame History