API Entwicklung / Ansteuerung

API Client Entwicklung in PHP/JS/GO

Falls die Suche mit composer nach einem geeigneten Client fehl schlägt, erstellen wir eine Client Komponente.
  • super schnell: Wir erstellen eine Service Komponente und nutzen eine Lib wie GuzzleHttp. Ist geeignet, wenn nicht so viele vers. Endpunkte angesteuert werden.
  • komfortabel: Wir erstellen ein Modul (z.B. Laravel oder Symfony) mit Fascades, Ressources, ServiceProvider, komplett unabh. vom Projekt entwickelt und versioniert
Gut zu wissen: Erfahrungsgemäß hängen die gezogenen API Packages immer etwas hinter dem tatsächlichen Stand hinterher.

Bereits angesteuerte APIs

  • SID Sportinformationsdienst (eigener API Client als Laravel Package)
  • Sportmonks AP
  • Chatgtp, DeepL, Claude
  • Gitlab
  • Bezahlsysteme:Paypal, Payrexx, Mollie
  • Hetzner Cloud

interne API ansteuern

Egal, ob monolithische Systeme wie Laravel oder eine klare Trennung zwischen Frontend und Backend, intern sollte im Backend immer alles als API laufen. Schnell testbar, klare Logiktrennung.

API Endpunkte testen

  • Httpie, ggf auch schnell per curl
  • Insonium (unser Favorit)/ Insomnia
  • Postman (im Team)

API Strategie

API-Versionierung ist ein wesentlicher Bestandteil einer robusten API-Strategie. Durch die Implementierung einer sinnvollen Versionierung können wir Änderungen an der API verwalten, die Kompatibilität mit verschiedenen Client-Versionen gewährleisten und eine kontinuierliche Weiterentwicklung ermöglichen.

API Node /Express.js

Express.js API mit JWT

app.get("/v1/api/progress", authenticateToken, async (req, res) => {
  let param = {};
  (req.query.headless) ? param['headless'] = req.query.headless : param['headless'] = true;
  (req.query.keywords) ? param['keywords'] = req.query.keywords : param['keywords'] = [];
  (req.query.provider) ? param['provider'] = req.query.provider : param['provider'] = null;
  return await response(req, res, param, scraper);
});

JWT Middleware

const jwt = require('jsonwebtoken');
require('dotenv').config();
const SECRET_KEY = process.env.JSON_WEB_TOKEN;

function authenticateToken(req, res, next) {
if (process.env.APP_ENV === 'prod'|| process.env.APP_ENV === 'production'||
    process.env.APP_ENV === 'stage'|| process.env.APP_ENV === 'staging'|| 
    process.env.APP_ENV === 'test'|| process.env.APP_ENV === 'testing') {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];

        if (!token) {
            return res.status(401).json({error: 'Access denied. No token provided.'});
        }

        jwt.verify(token, SECRET_KEY, (err, user) => {
            if (err) {
                return res.status(403).json({error: 'Invalid token.'});
            }
            req.user = user; // Payload
            next();
        });
    }else{
        console.log(`App running on : ${process.env.APP_ENV}. NO auth needed.`);
        next();
    }
}

module.exports = {
  authenticateToken,
};

REST Api FAQ

In modernen Fullstack-Anwendungen sind APIs das Rückgrat der Kommunikation zwischen Frontend und Backend – und oft weit darüber hinaus. Als spezialisierte Agentur mit Fokus auf PHP (Laravel/Lumen) und JavaScript (Node.js/Express), entwickeln wir robuste, skalierbare API-Clients und -Serverstrukturen für unterschiedlichste Anforderungen.

Wir konzipieren und implementieren performante API-Clients – z. B. in Laravel via integrierter HTTP-Client-Funktionalität oder mit Axios/Fetch im JavaScript-Umfeld. Ob einfache REST-Endpoints oder komplexe, authentifizierte Integrationen via OAuth2 oder JWT – wir sorgen für sichere und wartbare Kommunikationsebenen in euren Systemen.

In Fullstack-Projekten setzen wir auf eine saubere Trennung zwischen Services und Domains. Innerhalb monolithischer oder verteilter Systeme (Microservices) nutzen wir interne API-Calls zur Entkopplung von Funktionalitäten – beispielsweise bei servicebasierten Authentifizierungen, Payment-Gateways oder Content-Verwaltung.

Tech-Stack Beispiele:

  • Laravel – REST-APIs mit Ressourcen & FormRequests
  • Lumen – Lightweight-Microservices mit JWT-Auth
  • Express.js – API-Server mit Middleware-System & TypeScript
  • Go (Golang) – Performante Microservices mit strukturierten JSON-Routen

APIs müssen getestet werden – automatisiert und manuell. Für einen stabilen Betrieb setzen wir auf ein mehrstufiges Test-Setup:

Manuelles Testing:

  • Postman – Endpoint-Definition, Auth-Tests, Mock-Server
  • Insomnia – Umgebungskonfiguration, Collection-Speicherung
  • HTTPie – Schnelle CLI-Tests bei Entwicklung und Debugging

Automatisiertes Testing:

  • PHPUnit / Pest (Laravel) – Unit-, Feature- und API-Tests mit Mocks und Factories
  • Supertest / Jest (Node.js) – Integrationstests für Express-basierte APIs
  • Go testing package – Lightweight und performant für REST-Endpunkte

In unserer täglichen Arbeit als Agentur begegnet uns eine zentrale Herausforderung immer wieder: der zuverlässige Austausch von Daten zwischen verschiedenen Systemen. Genau hier setzen wir auf REST-APIs – moderne Schnittstellen, die das Fundament vieler Webanwendungen bilden.

Aber was genau ist eine REST-API – und wie funktioniert sie?

REST steht für Representational State Transfer – ein Architekturstil für Netzwerkanwendungen. Wenn wir REST-APIs entwickeln, setzen wir auf diesen Standard, um Systeme schnell, sicher und flexibel miteinander zu verbinden.

REST-APIs verwenden HTTP-Anfragen, um Daten abzurufen (GET), zu erstellen (POST), zu aktualisieren (PUT) oder zu löschen (DELETE). Dabei bleibt jede Anfrage zustandslos, was bedeutet: Jede Information, die der Server benötigt, steckt bereits in der Anfrage. Das macht unsere Lösungen besonders skalierbar – egal ob wir ein Firebase-System anbinden oder ein eigenes Backend konzipieren.

In der Praxis sprechen viele von REST oder RESTful APIs – wir auch. Technisch korrekt wäre "RESTful API", wenn sich die Schnittstelle vollständig an die REST-Prinzipien hält. Für unsere Kunden ist vor allem entscheidend: Die Schnittstelle ist leistungsfähig, gut dokumentiert und effizient im Einsatz.

Bei der API-Entwicklung setzen wir auf klare Prinzipien:

- Uniform Interface: Klare und einheitliche Schnittstellendefinitionen
- Client-Server-Trennung: Frontend und Backend sind unabhängig voneinander entwickelbar
- Zustandslosigkeit: Jede Anfrage ist in sich abgeschlossen
- Datenformate wie JSON oder XML: Flexibel, leichtgewichtig und weit verbreitet

Diese Prinzipien machen unsere REST-APIs einfach erweiterbar, testbar und wartbar.

Wenn wir REST-APIs für unsere Kunden konzipieren, achten wir auf eine saubere Struktur:

- REST-Endpunkte: URLs, über die auf Ressourcen zugegriffen wird
- HTTP-Methoden (GET, POST, PUT, DELETE): Zum Durchführen von CRUD-Operationen
- REST-URLs: Klar strukturiert, häufig mit Parametern
- REST Calls: Die eigentlichen HTTP-Anfragen, mit denen Daten ausgetauscht werden
- REST-Interface: Die Gesamtheit aller definierten Endpunkte und Methoden

So stellen wir sicher, dass jede Schnittstelle nachvollziehbar dokumentiert und leicht integrierbar ist.