ERPNext

Für kleine und mittlere Unternehmen (KMU) ist das größte Hindernis bei der digitalen Transformation oft nicht der Wille, sondern die Kosten. Traditionelle ERP-Systeme (wie SAP, Oracle) kosten schnell Hunderttausende oder sogar Millionen an Lizenzgebühren – für die meisten KMU einfach unerschwinglich. Und kostenlose Alternativen sind oft funktional unvollständig, veraltet und kaum gepflegt.

ERPNext hat das geändert. Als 100 % kostenloses und quelloffenes Enterprise-Resource-Planning-System (ERP) bietet ERPNext eine Komplettlösung, die alle zentralen Geschäftsbereiche abdeckt: Finanzen, CRM, Vertrieb, Einkauf, Lager, Fertigung und Personalwesen. Es basiert auf dem Frappe-Framework mit einem Python + JavaScript Tech-Stack, einem modernen Web-Interface und starken Custom-Development-Möglichkeiten.

Dieser Leitfaden führt dich Schritt für Schritt durch die Installation und das Deployment von ERPNext, die Basiskonfiguration, den Einsatz der Kernmodule und Custom-Development in der Praxis – damit du schnell ein maßgeschneidertes Enterprise-ERP-System für dein Unternehmen aufbauen kannst.

ERPNext Dashboard

Was ist ERPNext?

ERPNext ist ein Open-Source-ERP-System, das von dem indischen Unternehmen Frappe Technologies entwickelt und gepflegt wird. Es wird unter der GNU General Public License (GPL) v3 veröffentlicht. Das bedeutet:

  • ✅ Kostenlos nutzbar – Keine Lizenzgebühren, egal wie viele Nutzer
  • ✅ Frei modifizierbar – Du kannst Funktionen jederzeit an deine Geschäftsanforderungen anpassen
  • ✅ Kommerziell nutzbar – Einsatz in Unternehmen ohne Einschränkung
  • ✅ Community-getrieben – Eine weltweite Community entwickelt Code und Plugins weiter

Tech-Architektur

┌─────────────────────────────────────┐
│         ERPNext (Anwendungsebene)    │
│  Finanzen | CRM | Vertrieb | Einkauf │
│  Lager | HR                         │
├─────────────────────────────────────┤
│    Frappe Framework (Framework)      │
│  DocType | REST API | Berechtigungen │
│  Workflows                           │
├─────────────────────────────────────┤
│  Python (Backend)                    │
│  MariaDB (Datenbank)                 │
│  JavaScript/Vue (Frontend)           │
│  Redis (Cache)                       │
└─────────────────────────────────────┘

Das Herzstück von ERPNext ist das Frappe Framework – ein Full-Stack-Webframework in Python. Das herausragendste Feature von Frappe: Low-Code/No-Code. Über DocTypes (Dokumenttypen) kannst du Datenmodelle, Formulare, Listenansichten und APIs erstellen, ohne großen Code schreiben zu müssen.

Warum ERPNext?

Kriterium ERPNext Odoo (Community) SAP Business One
Lizenzkosten Kostenlos (GPL v3) Community kostenlos, Kernmodule kostenpflichtig Zehntausende–Hunderttausende €/Jahr
Open-Source-Grad 100 % Open Source Open Core (einige Module proprietär) Proprietär
Nutzerbegrenzung Keine Community: keine Pro Nutzer
Tech-Stack Python + MariaDB Python + PostgreSQL Proprietär
Custom Development Frappe-Framework, Low-Code Erfordert Python-Kenntnisse Zertifizierte Entwickler nötig
Chinesisch-Support Nativ unterstützt Community-Übersetzung Offiziell unterstützt
Deployment Self-hosted / Frappe Cloud Self-hosted / Odoo.sh On-Premise / Cloud

Installation & Deployment

ERPNext bietet verschiedene Deployment-Optionen. Hier die drei gängigsten: Docker (empfohlen), manuelle Installation und Frappe Cloud (Managed).

Option 1: Docker-Deployment (empfohlen)

Docker ist der einfachste und sauberste Weg – ideal für schnelle Tests und Produktivumgebungen.

Systemanforderungen

  • CPU: Ab 2 Kernen
  • RAM: 4 GB minimum (8 GB empfohlen)
  • Speicher: 20 GB+
  • Betriebssystem: Ubuntu 20.04/22.04, CentOS 8+, Debian 11+

One-Click-Deployment mit docker-compose

BASH 
# 1. Docker und Docker Compose installieren
curl -fsSL https://get.docker.com | sh
sudo systemctl enable --now docker

# 2. Docker Compose installieren (falls nicht vorhanden)
sudo apt install docker-compose-plugin

# 3. Offizielles docker-compose-Repo klonen
git clone https://github.com/frappe/frappe_docker.git
cd frappe_docker

# 4. Umgebungsdatei erstellen
cp example.env .env

# .env bearbeiten – folgende Parameter setzen:
# SITE_NAME=erp.deinedomain.com
# DB_ROOT_USER=root
# DB_ROOT_PASSWORD=dein_sicheres_passwort
# ADMIN_PASSWORD=dein_admin_passwort

# 5. Dienste starten
docker compose -f compose.yaml \
  -f overrides/compose.mariadb.yaml \
  -f overrides/compose.redis.yaml \
  -f overrides/compose.noproxy.yaml \
  config > ~/docker-compose.yml

docker compose -f ~/docker-compose.yml up -d

# 6. Neue Site erstellen
docker compose -f ~/docker-compose.yml exec backend \
  bench new-site erp.deinedomain.com \
  --mariadb-root-password dein_sicheres_passwort \
  --admin-password dein_admin_passwort \
  --install-app erpnext

# 7. ERPNext aufrufen
# Browser: http://dein-server-ip:8080
# Standard-Admin: Administrator
# Passwort: das in .env gesetzte ADMIN_PASSWORD

Nginx Reverse Proxy einrichten (Produktivumgebung)

BASH 
# Kostenloses SSL-Zertifikat mit Let's Encrypt
docker compose -f ~/docker-compose.yml exec backend \
  bench setup nginx

# Oder Traefik für automatisches HTTPS-Management
docker compose -f compose.yaml \
  -f overrides/compose.traefik.yaml \
  config > ~/docker-compose-traefik.yml

docker compose -f ~/docker-compose-traefik.yml up -d

Option 2: Manuelle Installation (für tiefgreifendes Customizing)

Die manuelle Installation eignet sich für Entwickler, die das System intensiv anpassen und debuggen wollen.

BASH 
# 1. Abhängigkeiten installieren
sudo apt update
sudo apt install python3-dev python3-setuptools python3-pip \
  python3-distutils python3.10-venv software-properties-common \
  mariadb-server mariadb-client redis-server nodejs npm \
  yarn cron xvfb libfontconfig wkhtmltopdf

# 2. MariaDB konfigurieren
sudo mysql -u root -e "
  CREATE DATABASE erpnext;
  CREATE USER 'erpnext'@'localhost' IDENTIFIED BY 'dein_passwort';
  GRANT ALL PRIVILEGES ON erpnext.* TO 'erpnext'@'localhost';
  FLUSH PRIVILEGES;
"

# 3. Bench installieren (Frappe CLI-Tool)
pip3 install frappe-bench

# 4. Bench initialisieren
bench init --frappe-branch version-15 frappe-bench
cd frappe-bench

# 5. Neue Site erstellen
bench new-site erp.deinedomain.com \
  --db-name erpnext \
  --db-password dein_passwort \
  --admin-password dein_admin_passwort

# 6. ERPNext-App installieren
bench get-app --branch version-15 erpnext
bench --site erp.deinedomain.com install-app erpnext

# 7. Development-Server starten
bench start
# Aufruf: http://localhost:8000

Option 3: Frappe Cloud (Managed Hosting)

Wenn du dich nicht um Server-Wartung kümmern willst, bietet der offizielle Frappe Cloud-Service eine bequeme Alternative:

  • Preis: $50/Monat (KMU-Paket)
  • Inklusive: Unbegrenzte Nutzer, automatische Backups, SSL-Zertifikat, technischer Support
  • Ideal für: KMU ohne eigenes IT-Ops-Team

Einfach auf frappecloud.com registrieren – kein technisches Know-how nötig.

Basiskonfiguration

Nach der Installation sind die ersten Schritte die Grundkonfiguration des Systems.

1. Unternehmenseinstellungen

Navigiere zu Einstellungen → Unternehmen und trage deine Unternehmensdaten ein:

  • Firmenname
  • Registrierte Adresse
  • Steuernummer
  • Standardwährung
  • Startmonat des Geschäftsjahrs
# Multi-Company-Architektur
Wenn dein Konzern mehrere Tochtergesellschaften hat,
kannst du mehrere Unternehmen anlegen. ERPNext unterstützt
intercompany-Transaktionen und Konzernabschlüsse.

2. Benutzer & Berechtigungen

ERPNext nutzt eine rollenbasierte Zugriffskontrolle (RBAC):

Administrator (System Manager) → Vollzugriff
Buchhalter (Accounts Manager) → Finanzmodul
Vertrieb (Sales Manager) → Vertriebsmodul
Lager (Stock Manager) → Lagermodul
Personal (HR Manager) → HR-Modul

Benutzer erstellen

PYTHON 
# Benutzer über Frappe API erstellen (Python-Skript)
import frappe

user = frappe.get_doc({
    "doctype": "User",
    "email": "max.mustermann@firma.de",
    "first_name": "Max",
    "roles": [{"role": "Sales Manager"}]
})
user.insert()

3. Stammdaten-Import

ERPNext unterstützt den Massenimport von Stammdaten über Excel/CSV:

Datentyp Import-Vorlage Beschreibung
Kunde Customer Kundendaten, Adressen, Kontaktdaten
Lieferant Supplier Lieferantendaten, Zahlungsbedingungen, Abrechnungsart
Produkt Item SKU, Spezifikation, Preis, Lagerbestand
Stückliste BOM Bill of Materials (Fertigungsmodul)
Mitarbeiter Employee Mitarbeiterdaten, Abteilung, Position

Gehe in jedem Modul zur Listenansicht → Importieren (Import), lade die Vorlage herunter, befülle sie und lade sie wieder hoch.

4. Druckvorlagen anpassen

ERPNext ermöglicht die individuelle Gestaltung von Geschäftsdrucken:

  • Rechnungen
  • Bestellungen
  • Verkaufsaufträge
  • Lieferscheine
  • Angebote

Unter Einstellungen → Druckeinstellungen kannst du eingebaute Vorlagen nutzen oder eigene HTML/Jinja-Vorlagen erstellen.

Kernmodule im Detail

ERPNext umfasst über 20 Geschäftsmodule. Hier die wichtigsten im Überblick.

💰 Finanzmodul (Accounting)

Das Finanzmodul ist das Herzstück jedes ERP-Systems. ERPNext liefert hier ein vollständiges Paket:

Kontenplan (Chart of Accounts)

ERPNext bringt Kontenpläne für verschiedene Länder mit und unterstützt individuelle Anpassungen:

Aktiva (Assets)
├── Umlaufvermögen
│   ├── Kasse und Bank
│   ├── Forderungen aus LuL
│   └── Vorräte
├── Anlagevermögen
│   ├── Gebäude
│   └── Maschinen & Geräte
Passiva (Liabilities)
├── Kurzfristige Verbindlichkeiten
│   ├── Verbindlichkeiten aus LuL
│   └── Kurzfristige Kredite
Eigenkapital (Equity)
├── Gezeichnetes Kapital
└── Gewinnrücklagen
Erträge (Income)
├── Umsatzerlöse
└── Sonstige Erträge
Aufwendungen (Expenses)
├── Wareneinsatz
├── Vertriebskosten
├── Verwaltungskosten
└── Finanzaufwendungen

Automatische Buchungssätze

Verkaufs-, Einkaufs- und Lagerbuchungen in ERPNext generieren automatisch Buchungssätze:

PYTHON 
# Automatische Buchung bei Verkaufsrechnung
Soll: Forderungen aus LuL       €10.000
    Haben: Umsatzerlöse              €8.849,56
            Umsatzsteuer              €1.150,44

# Automatische Buchung bei Wareneingang
Soll: Warenbestand              €5.000
    Haben: Verbindlichkeiten aus LuL  €5.000

Finanzberichte

  • Bilanz – Echtzeit-Überblick der Finanzlage
  • GuV (Gewinn- und Verlustrechnung) – periodenbezogene Gegenüberstellung von Erträgen und Aufwendungen
  • Cashflow-Rechnung – Nachverfolgung von Zahlungsströmen
  • Forderungs-/Verbindlichkeits-Altersanalyse – Überwachung des Ausfallrisikos

📦 Lagermodul (Stock)

Lagerverwaltung

Multi-Lager- und Multi-Platz-Verwaltung:

Hauptlager
├── Bereich A – Rohmaterial
│   ├── A-01 Elektronikbauteile
│   └── A-02 Strukturkomponenten
├── Bereich B – Fertigprodukte
│   ├── B-01 Versandbereit
│   └── B-02 Geprüft
└── Bereich C – Retouren

Lagerbewegungen

Vorgang Beschreibung
Wareneingang Einkaufseingang, Produktionseingang, Retoureneingang
Warenausgang Verkaufsausgang, Materialbereitstellung, Ausschluss
Umlagerung Transfer zwischen Lagern
Inventur Regelmäßiger Abgleich von Buchbestand und Ist-Bestand
Serien-/Chargenverfolgung Präzise Nachverfolgung jedes Produkts

Lagerwarnungen

Definiere Mindestbestandsschwellen – das System warnt automatisch bei Unterschreitung:

PYTHON 
# Lagerwarnung per Frappe-Skript setzen
frappe.db.set_value("Item", "ITEM-001", "re_order_level", 100)
frappe.db.set_value("Item", "ITEM-001", "warehouse", "Hauptlager")

🤝 CRM- & Vertriebsmodul

Verkaufsprozess

Lead
  ↓
Chance (Opportunity)
  ↓
Angebot (Quotation)
  ↓
Verkaufsauftrag (Sales Order)
  ↓
Lieferschein (Delivery Note)
  ↓
Verkaufsrechnung (Sales Invoice)
  ↓
Zahlungseingang (Payment Entry)

CRM-Highlights

  • Lead-Management – Herkunft tracken, Vertriebler zuordnen, Follow-ups dokumentieren
  • Opportunity-Funnel – Visuelle Sales Pipeline
  • Angebotsvorlagen – Professionelle Angebote in Sekunden
  • Kundenportal – Kunden sehen Aufträge und Rechnungen selbstständig
  • E-Mail-Integration – E-Mails automatisch mit Kunden verknüpfen

👥 Personalwesen (HRMS)

Mitarbeiterverwaltung

  • Mitarbeiterstamm (persönliche Daten, Verträge, Notfallkontakte)
  • Organisationsstruktur (Abteilungen, Positionen, Berichtslinien)
  • Onboarding/Offboarding-Prozesse

Zeiterfassung & Urlaub

PYTHON 
# Anwesenheitsregeln konfigurieren
attendance_policy = {
    "working_hours": "09:00-18:00",
    "late_entry_threshold": 15,  # Minuten
    "early_exit_threshold": 15,
    "holiday_list": "2026 – gesetzliche Feiertage"
}

# Urlaubsarten
leave_types = [
    {"name": "Erholungsurlaub", "max_leaves": 24},
    {"name": "Krankheit", "max_leaves": 10},
    {"name": "Unbezahlt", "max_leaves": 0},  # Genehmigungspflichtig
    {"name": "Heirat", "max_leaves": 3},
]

Gehaltsabrechnung

  • Gehaltsstruktur (Grundgehalt, Bonus, Zulagen, Abzüge)
  • Automatische Steuerberechnung
  • Gehaltsabrechnungen generieren und auszahlen
  • Sozialversicherungs- und Beitragsberechnung

🏭 Fertigungsmodul (Manufacturing)

Stückliste (BOM)

Produkt: Smart Speaker V2.0
├── Hauptplatine (x1)
│   ├── Hauptprozessor (x1)
│   ├── Speichermodul (x2)
│   └── WiFi-Modul (x1)
├── Audiokomponente (x1)
│   ├── Lautsprecher (x2)
│   └── Verstärkerplatine (x1)
├── Gehäuse (x1)
└── Netzteil (x1)

Fertigungsauftragsprozess

Produktionsplanung (Production Plan)
  ↓
Fertigungsauftrag (Work Order)
  ↓
Materialbereitstellung (Material Transfer)
  ↓
Fertigung (Manufacture)
  ↓
Qualitätsprüfung (Quality Inspection)
  ↓
Einlagerung (Stock Entry)

Custom Development in der Praxis

Die größte Stärke von ERPNext: seine Erweiterbarkeit. Mit dem Frappe-Framework kannst du mit minimalem Code maßgeschneiderte Funktionen entwickeln.

Entwicklungsumgebung einrichten

BASH 
# 1. Development-Site erstellen
bench new-site dev.localhost --force
bench use dev.localhost

# 2. Eigene App erstellen
bench new-app my_custom_app

# Verzeichnisstruktur:
# my_custom_app/
# ├── my_custom_app/
# │   ├── __init__.py
# │   ├── hooks.py          # App-Hook-Konfiguration
# │   ├── modules.txt        # Modulliste
# │   ├── custom_doctype/    # Benutzerdefinierte DocTypes
# │   └── api.py             # Custom APIs
# └── setup.py

Benutzerdefinierte DocTypes (Low-Code)

DocTypes sind das Kernkonzept von Frappe – sie vereinen Datenbanktabelle, Formular und API in einem.

Beispiel: „Projektmanagement"-Modul erstellen

PYTHON 
# DocType per Python-Code definieren
import frappe
from frappe.model.document import Document

class ProjectTask(Document):
    pass

# In hooks.py registrieren
# doc_events = {
#     "Project Task": {
#         "on_update": "my_custom_app.tasks.notify_assignee"
#     }
# }

DocType-Feldtypen

Feldtyp Verwendung Beispiel
Data Einzeiliger Text Projektname
Long Text Mehrzeiliger Text Projektbeschreibung
Select Dropdown-Auswahl Status (aktiv/abgeschlossen/storniert)
Date Datum Startdatum
Currency Geldbetrag Budget
Link Verknüpfung zu anderem DocType Kunde verknüpfen
Table Untertabelle (1:n) Aufgabenliste
Attach Dateianhang Projektdokumente

Custom APIs

PYTHON 
# my_custom_app/api.py
import frappe
from frappe import _

@frappe.whitelist()
def get_project_summary(project_name):
    """Projektzusammenfassung abrufen"""
    project = frappe.get_doc("Project", project_name)

    tasks = frappe.get_all("Project Task",
        filters={"project": project_name},
        fields=["task_name", "status", "assigned_to", "deadline"]
    )

    return {
        "project_name": project.project_name,
        "status": project.status,
        "budget": project.budget,
        "tasks": tasks,
        "completion": project.percentage_complete
    }

# Aufruf:
# GET /api/method/my_custom_app.api.get_project_summary?project_name=PRJ-001

Custom Workflows

PYTHON 
# Genehmigungsworkflow für Bestellungen
workflow = {
    "workflow_name": "Purchase Approval",
    "document_type": "Purchase Order",
    "states": [
        {"state": "Draft", "allow_edit": "Purchase Manager"},
        {"state": "Pending Approval", "allow_edit": "Purchase Manager"},
        {"state": "Approved", "allow_edit": "Director"},
        {"state": "Rejected", "allow_edit": "Director"},
    ],
    "transitions": [
        {"from": "Draft", "to": "Pending Approval", "action": "Submit", "allowed": "Purchase Manager"},
        {"from": "Pending Approval", "to": "Approved", "action": "Approve", "allowed": "Director"},
        {"from": "Pending Approval", "to": "Rejected", "action": "Reject", "allowed": "Director"},
    ]
}

Custom Reports

PYTHON 
# my_custom_app/reports/sales_summary.py
import frappe

def execute(filters=None):
    columns = [
        {"fieldname": "customer", "label": "Kunde", "fieldtype": "Link", "options": "Customer", "width": 200},
        {"fieldname": "total_sales", "label": "Umsatz", "fieldtype": "Currency", "width": 150},
        {"fieldname": "total_qty", "label": "Menge", "fieldtype": "Int", "width": 100},
    ]

    conditions = ""
    if filters.get("from_date"):
        conditions += f" AND si.posting_date >= '{filters.from_date}'"
    if filters.get("to_date"):
        conditions += f" AND si.posting_date <= '{filters.to_date}'"

    data = frappe.db.sql(f"""
        SELECT
            si.customer,
            SUM(si.grand_total) as total_sales,
            SUM(si.total_qty) as total_qty
        FROM `tabSales Invoice` si
        WHERE si.docstatus = 1 {conditions}
        GROUP BY si.customer
        ORDER BY total_sales DESC
    """, as_dict=True)

    return columns, data

Frontend-Anpassungen

ERPNext nutzt Vue.js und Jinja-Templates. Du kannst Folgendes anpassen:

JAVASCRIPT 
// Custom Form Script
frappe.ui.form.on('Sales Order', {
    refresh: function(frm) {
        // Custom Button hinzufügen
        frm.add_custom_button('PDF exportieren', function() {
            frappe.call({
                method: 'my_custom_app.api.export_pdf',
                args: { docname: frm.doc.name },
                callback: function(r) {
                    window.open(r.message.url);
                }
            });
        });
    },

    validate: function(frm) {
        // Custom Validierung
        if (frm.doc.discount > 20) {
            frappe.throw('Rabatt darf 20 % nicht überschreiten');
        }
    }
});

Betrieb & Optimierung

Backup & Recovery

BASH 
# Site-Backup
bench --site erp.deinedomain.com backup

# Backup in die Cloud
bench --site erp.deinedomain.com backup --with-files

# Backup wiederherstellen
bench --site erp.deinedomain.com restore /pfad/zur/datenbank.sql.gz

# Automatisches Backup (in crontab eintragen)
0 2 * * * cd /home/frappe/frappe-bench && bench backup-all-sites

Performance-Optimierung

PYTHON 
# 1. Redis-Cache aktivieren (in site_config.json)
{
    "cache_redis": "redis://localhost:6379"
}

# 2. Datenbank-Index-Optimierung
# Index für häufig abgefragte Felder erstellen
frappe.db.add_index("Sales Invoice", ["customer", "posting_date"])

# 3. Gunicorn Multi-Process aktivieren
# In der Bench-Konfiguration setzen
bench config set-common-config -c gunicorn_workers 4

Monitoring & Logging

BASH 
# Bench-Logs anzeigen
bench --site erp.deinedomain.com logs

# MariaDB Slow Queries anzeigen
mysql -u root -e "SHOW VARIABLES LIKE 'slow_query_log%';"

# Server-Ressourcen überwachen
htop
iotop

ERPNext FAQ

F1: Für welche Unternehmensgröße ist ERPNext geeignet?

A: ERPNext passt für Mikro- bis Mittelunternehmen (1–500 Mitarbeiter): - Mikrounternehmen (1–50 MA): Selbst hosten, kostenlos, schnell startklar - Mittelunternehmen (50–500 MA): Multi-Company, Multi-Lager, Multi-Währung für komplexe Anforderungen - Großunternehmen (500+ MA): Skalierbar über Frappe Cloud oder eigenes Cluster-Setup

F2: Gibt es ERPNext auf Deutsch?

A: ERPNext unterstützt mehrere Sprachen nativ, darunter Deutsch. Du kannst die Sprache in den Systemeinstellungen umschalten. Die Community arbeitet kontinuierlich an der Verbesserung der Lokalisierung, einschließlich branchenspezifischer Anforderungen.

F3: Was ist der Unterschied zwischen ERPNext und Odoo?

A: Die Hauptunterschiede: - Open-Source-Grad: ERPNext ist 100 % quelloffen (GPL), Odoo Community fehlt Kernmodule wie Finanzen - Preis: ERPNext komplett kostenlos, Odoo Enterprise pro-Nutzer-pflichtig - Custom Development: ERPNexts Frappe-Framework hat stärkere Low-Code-Fähigkeiten, Odoo erfordert mehr Coding - Ökosystem: Beide haben aktive Communities, Odoo ist im europäischen Raum etablierter

F4: Welche Server-Hardware braucht selbst gehostetes ERPNext?

A: Mindestanforderungen: - 2 Kerne + 4 GB RAM + 20 GB Speicher – für Tests und kleine Teams (<20 MA) - 4 Kerne + 8 GB RAM + 50 GB Speicher – für Mittelunternehmen (20–100 MA) - 8 Kerne + 16 GB RAM + 100 GB+ SSD – für Großunternehmen (100+ MA)

SSD-Speicher wird empfohlen, um die Datenbankleistung zu steigern.

F5: Kann ERPNext mit anderen Systemen integriert werden?

A: Ja. ERPNext bietet REST-APIs und Webhooks für die Integration mit: - E-Commerce: Shopify, WooCommerce - Zahlungs-Gateways: Stripe, PayPal - Logistik: DHL, FedEx, UPS - Drittsysteme: Über API-Anbindung praktisch jedes externe System

PYTHON 
# ERPNext REST API Beispiel
import requests

# Kundenliste abrufen
response = requests.get(
    "https://erp.deinedomain.com/api/resource/Customer",
    headers={"Authorization": "token api_key:api_secret"}
)
customers = response.json()

# Verkaufsauftrag erstellen
response = requests.post(
    "https://erp.deinedomain.com/api/resource/Sales Order",
    headers={"Authorization": "token api_key:api_secret", "Content-Type": "application/json"},
    json={"customer": "CUST-001", "items": [{"item_code": "ITEM-001", "qty": 10}]}
)

Fazit

ERPNext ist eine der ausgereiftesten und umfassendsten Open-Source-ERP-Lösungen auf dem Markt. Es deckt nicht nur den täglichen Bedarf von KMU ab, sondern bietet durch das Frappe-Framework auch leistungsstarke Erweiterungsmöglichkeiten für maßgeschneiderte Custom-Developments.

Schnellstart-Pfad: 1. Docker One-Click-Deployment (5 Minuten) 2. Unternehmen, Benutzer und Stammdaten konfigurieren 3. Mit dem Finanz- oder CRM-Modul beginnen 4. Nach Bedarf weitere Module schrittweise aktivieren 5. Bei Bedarf Custom Development für spezielle Anforderungen

Ob du ein gerade gegründetes Startup oder ein Unternehmen im Prozess der digitalen Transformation bist – ERPNext ist einen genauen Blick wert. 100 % kostenlos, quelloffen, aktive Community – das ist der Kernvorteil von ERPNext.

Besuche die ERPNext-Website oder das GitHub-Repo für weitere Informationen.