KI-Agenten bauen heute Websites in Minuten – aber sie binden Google Fonts per CDN ein. Das ist ein DSGVO-Verstoß. Mit realmaker LocalFonts haben wir einen MCP-Server entwickelt, der KI-Coding-Assistenten befähigt, Google Fonts automatisch herunterzuladen und lokal in Webprojekte einzubinden. Datenschutzkonform, vollautomatisch, ohne dass der Entwickler einen einzigen Font manuell anfassen muss.
Das neue Problem: KI-Agenten und Google Fonts
Die Art, wie Websites entstehen, hat sich fundamental verändert. KI-gestützte Coding-Assistenten generieren heute ganze Webprojekte in Minuten – Frontend, Backend, Styling, alles. Was früher Tage dauerte, passiert jetzt in einer einzigen Prompt-Session.
Aber es gibt ein Problem, das dabei fast immer übersehen wird: KI-Agenten binden Google Fonts standardmäßig per CDN ein. In nahezu jedem generierten CSS steht eine Zeile wie diese:
@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap');Für den KI-Agenten ist das die einfachste Lösung – ein Einzeiler, funktioniert sofort, sieht gut aus. Aber für den deutschen Rechtsraum ist es eine Zeitbombe. Denn bei jeder Einbindung werden Nutzerdaten an Google-Server in den USA übermittelt: IP-Adresse, Browser-Informationen, Zugriffszeit. Ohne Einwilligung. Ohne Rechtsgrundlage.
Und das passiert nicht einmal, sondern bei jedem einzelnen Seitenaufruf. Tausende von Websites, generiert von KI-Agenten, gehen mit eingebautem DSGVO-Verstoß live – weil der Entwickler dem Agenten vertraut hat und die Font-Einbindung nicht manuell geprüft hat.
KI-Coding-Assistenten haben Google Fonts in ihrem Trainingsdatensatz milliardenfach gesehen. Sie generieren standardmäßig Code, der Schriftarten per CDN von Google lädt. Jede so erstellte Website verstößt gegen die DSGVO – und der Betreiber haftet, nicht die KI. Bußgelder bis zu 20 Millionen Euro oder 4% des Jahresumsatzes sind möglich.
Genau dieses Problem hat uns motiviert, realmaker LocalFonts zu entwickeln. Nicht als weiteres Font-Hosting-Tool. Sondern als MCP-Server, der KI-Agenten beibringt, Fonts richtig einzubinden – lokal, datenschutzkonform, automatisch.
Kurzer Rückblick: Das LG-München-Urteil
Für alle, die den Hintergrund kennen möchten: Am 20. Januar 2022 hat das Landgericht München I (Az. 3 O 17493/20) ein wegweisendes Urteil gefällt. Ein Website-Betreiber wurde zur Zahlung von 100 Euro Schadensersatz verurteilt – weil er Google Fonts direkt von Google-Servern eingebunden hatte, ohne Einwilligung der Besucher.
Was danach kam, war eine regelrechte Abmahnwelle. Tausende Website-Betreiber erhielten Abmahnungen, oft mit Forderungen zwischen 150 und 500 Euro. Das Urteil hat unmissverständlich klargestellt: Wer Google Fonts per CDN einbindet, verstößt gegen Artikel 6 Abs. 1 DSGVO.
Die Lösung war bekannt: Fonts lokal hosten. Was für einen einzelnen Entwickler machbar ist – herunterladen, @font-face schreiben, auf den Server laden – wird bei KI-generierten Projekten zum Massenproblem. Denn der KI-Agent weiß nichts von DSGVO, LG München oder Abmahnrisiken. Er kennt nur den Code aus seinen Trainingsdaten.
Die Ironie: Wir haben die Werkzeuge, um Websites schneller zu bauen als je zuvor. Aber diese Werkzeuge produzieren standardmäßig Code, der in Deutschland rechtswidrig ist. Das musste sich ändern.
Was ist ein MCP-Server?
Bevor wir in die Details von LocalFonts einsteigen, kurz zum Konzept: MCP steht für Model Context Protocol – ein offener Standard, der es KI-Agenten ermöglicht, externe Dienste und Tools zu nutzen.
Stell dir das so vor: Ein KI-Coding-Assistent kann von Haus aus Text generieren, Code schreiben, Dateien lesen und bearbeiten. Aber er kann nicht selbstständig im Internet suchen, keine APIs aufrufen und keine spezialisierten Werkzeuge nutzen – es sei denn, man gibt ihm welche. Genau das macht MCP.
| Ohne MCP | Mit MCP |
|---|---|
| KI generiert Google-Fonts-CDN-Link aus Trainingsdaten | KI ruft MCP-Tool auf und bekommt lokale Font-Dateien |
| Schriftarten werden von Google-Servern geladen | Schriftarten liegen lokal im Projektordner |
| IP-Adresse geht an Google (DSGVO-Verstoß) | Kein externer Kontakt (DSGVO-konform) |
| Entwickler muss manuell korrigieren | Automatisch richtig, ohne Nacharbeit |
Ein MCP-Server stellt dem KI-Agenten spezialisierte Tools zur Verfügung. Im Fall von realmaker LocalFonts sind das Tools zum Suchen, Herunterladen und Einbinden von Schriftarten. Der Agent kann diese Tools bei Bedarf aufrufen – genau wie ein Handwerker, der zum richtigen Werkzeug greift.
realmaker LocalFonts: So funktioniert es
Das Konzept von LocalFonts ist elegant in seiner Einfachheit:
- Der KI-Agent braucht eine Schriftart für ein Webprojekt
- Statt einen Google-Fonts-CDN-Link zu generieren, ruft er das LocalFonts-MCP-Tool auf
- Das Tool liefert: Download-Befehle für die Font-Dateien, fertiges CSS mit lokalen Pfaden und eine HTML-Einbindung
- Der Agent führt die Befehle aus: Fonts werden direkt ins Projekt heruntergeladen
- Ergebnis: Die Schriftarten liegen lokal im Projektordner – kein externer Server, kein Google-Kontakt, DSGVO-konform
Der entscheidende Punkt: Die Fonts werden nicht von fonts.realmaker.de ausgeliefert. Unser Server ist ein Vermittler – er kennt den kompletten Google-Fonts-Katalog, weiß welche Weights und Formate verfügbar sind, und gibt dem KI-Agenten die Werkzeuge an die Hand, um die Fonts lokal einzurichten. Am Ende liegen die woff2-Dateien im Projekt des Entwicklers, nicht auf unserem Server.
realmaker LocalFonts ist kein Font-CDN und kein Proxy. Die Schriftdateien werden direkt in den Projektordner des Entwicklers heruntergeladen. Beim Seitenaufruf der fertigen Website kontaktiert der Browser keinen externen Server – die Fonts liegen lokal auf dem eigenen Webserver. Das ist echtes Self-Hosting, automatisiert durch KI.
Die sechs MCP-Tools im Detail
Der MCP-Server stellt KI-Agenten sechs spezialisierte Tools zur Verfügung. Jedes Tool hat eine klar definierte Aufgabe – vom Durchstöbern des Katalogs bis zur kompletten Installation:
search_fonts – Schriftarten finden
Durchsucht den Katalog mit 1.600+ Schriftarten nach Name, Kategorie (sans-serif, serif, monospace, display, handwriting) oder Stil. Liefert eine übersichtliche Liste passender Fonts mit allen verfügbaren Varianten. Perfekt, wenn der Agent eine passende Schriftart auswählen soll.
get_font_css – CSS generieren
Generiert produktionsfertiges @font-face CSS für die gewünschte Schriftart – mit lokalen Dateipfaden statt CDN-URLs. Der Agent kann Weights, Styles und das gewünschte Format angeben. Das CSS ist sofort einsatzbereit, mit korrekten relativen Pfaden zwischen CSS-Ordner und Font-Verzeichnis.
download_font – Download-URLs und Befehle
Liefert alle Download-URLs und fertige curl-Befehle für die gewünschten Font-Dateien. Der Agent erhält ein komplettes Bash-Skript, das er direkt ausführen kann – mkdir für den Ordner, curl für jede Datei. Unterstützt woff2, woff und ttf.
install_font – Alles in einem Schritt
Das mächtigste Tool: Kombiniert Download-Befehle, @font-face CSS und HTML-Einbindung in einer einzigen Antwort. Der Agent bekommt alles, was er braucht, um eine Schriftart komplett in ein Projekt zu integrieren. Inklusive korrekter Pfadberechnung zwischen CSS- und Font-Verzeichnis.
get_font_link – HTML-Link-Tag
Generiert ein fertiges HTML-Link-Tag zur Einbindung im Head-Bereich. Nützlich, wenn der Agent schnell eine Referenz braucht, ohne die komplette Installation durchzuführen.
list_popular_fonts – Beliebte Schriftarten
Zeigt die meistgenutzten Fonts, sortiert nach Beliebtheit. Hilft dem Agenten bei der Auswahl, wenn keine spezifische Schriftart vorgegeben ist – er kann dem Nutzer die Top-Fonts empfehlen.
Das install_font-Tool ist dabei der Star. Ein einziger Aufruf und der Agent hat alles, was er braucht:
install_font Response
├── Step 1: Download-Befehle
│ ├── mkdir -p assets/fonts/roboto
│ ├── curl -s -o roboto/400-normal.woff2 [URL]
│ ├── curl -s -o roboto/600-normal.woff2 [URL]
│ └── curl -s -o roboto/700-normal.woff2 [URL]
├── Step 2: Fertiges @font-face CSS
│ ├── @font-face (400, normal, woff2)
│ ├── @font-face (600, normal, woff2)
│ └── @font-face (700, normal, woff2)
│ └── Pfade relativ: ../fonts/roboto/400-normal.woff2
└── Step 3: HTML-Einbindung
└──
Der Workflow: Vom Prompt zur lokalen Schriftart
Schauen wir uns den konkreten Ablauf an. Ein Entwickler sagt seinem KI-Assistenten: „Erstelle mir eine Landing-Page mit der Schriftart Inter.“
Ohne LocalFonts (der riskante Weg)
Der KI-Agent generiert eine HTML-Datei. Im Head steht:
<!-- KI-Agent generiert standardmäßig einen CDN-Link -->
<link rel="stylesheet"
href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap">Die Seite sieht gut aus. Die Schrift lädt. Alles funktioniert. Aber: Jeder Besucher sendet seine IP-Adresse an Google. Der Entwickler hat das vielleicht gar nicht bemerkt, weil der KI-Agent die Entscheidung getroffen hat. Die Website geht live – mit eingebautem DSGVO-Verstoß.
Mit LocalFonts (der sichere Weg)
Der KI-Agent erkennt, dass er das LocalFonts-MCP-Tool nutzen kann. Er ruft install_font auf:
# Was der KI-Agent im Hintergrund macht:
# 1. Font-Dateien herunterladen
mkdir -p assets/fonts/inter
curl -s -o "assets/fonts/inter/400-normal.woff2" "https://fonts.realmaker.de/v1/font/inter/400-normal.woff2"
curl -s -o "assets/fonts/inter/600-normal.woff2" "https://fonts.realmaker.de/v1/font/inter/600-normal.woff2"
curl -s -o "assets/fonts/inter/700-normal.woff2" "https://fonts.realmaker.de/v1/font/inter/700-normal.woff2"Dann schreibt der Agent das CSS – nicht mit CDN-URLs, sondern mit lokalen Pfaden:
/* Generiert vom KI-Agent via LocalFonts MCP – DSGVO-konform */
@font-face {
font-family: 'Inter';
font-style: normal;
font-weight: 400;
font-display: swap;
src: url('../fonts/inter/400-normal.woff2') format('woff2');
}
@font-face {
font-family: 'Inter';
font-style: normal;
font-weight: 600;
font-display: swap;
src: url('../fonts/inter/600-normal.woff2') format('woff2');
}
@font-face {
font-family: 'Inter';
font-style: normal;
font-weight: 700;
font-display: swap;
src: url('../fonts/inter/700-normal.woff2') format('woff2');
}Die Dateistruktur im Projekt sieht danach so aus:
mein-webprojekt/ ├── index.html ├── assets/ │ ├── css/ │ │ ├── style.css │ │ └── fonts.css ← @font-face Deklarationen │ └── fonts/ │ └── inter/ │ ├── 400-normal.woff2 ← Lokal heruntergeladen │ ├── 600-normal.woff2 ← Lokal heruntergeladen │ └── 700-normal.woff2 ← Lokal heruntergeladen └── ...
Kein einziger externer Request. Die Schriftarten liegen physisch im Projektordner. Wenn die Website online geht, lädt der Browser die Fonts vom eigenen Server. Google erfährt nichts. Der Besucher ist geschützt. Der Betreiber ist rechtssicher.
Das install_font-Tool berechnet automatisch den relativen Pfad zwischen dem CSS-Verzeichnis und dem Font-Ordner. Egal ob dein CSS in assets/css/ oder in styles/ liegt – die src: url()-Pfade im generierten CSS stimmen immer. Der KI-Agent gibt einfach css_path und fonts_dir an, den Rest erledigt das Tool.
1.600+ Fonts im Katalog
realmaker LocalFonts spiegelt den kompletten Google-Fonts-Katalog – alle 1.600+ Schriftfamilien in allen verfügbaren Weights und Stilen. Der Katalog synchronisiert sich täglich automatisch. Wenn Google eine neue Schriftart veröffentlicht, ist sie innerhalb von 24 Stunden bei uns verfügbar.
Was im Katalog steckt
- 1.600+ Schriftfamilien, komplett gespiegelt
- Alle Weights (100 bis 900) und Stile (normal, italic)
- 5 Kategorien: Sans-Serif, Serif, Monospace, Display, Handwriting
- 3 Formate: woff2 (Free), woff und ttf (Pro)
- Tägliche Synchronisation mit dem Google-Fonts-Repository
- Beliebtheits-Ranking basierend auf realen Nutzungsdaten
Die Fonts werden lazy heruntergeladen – erst wenn ein Agent eine bestimmte Schriftart zum ersten Mal anfragt, wird sie von Google geholt, verarbeitet und gecacht. Ab dem zweiten Aufruf liegt sie direkt bereit. So belegen nur die tatsächlich nachgefragten Fonts Speicherplatz auf dem Server.
Der User-Agent-Trick
Ein technisches Detail, das Font-Nerds freuen wird: Google Fonts liefert unterschiedliche Formate je nach Browser. Um die optimalen woff2-Dateien zu bekommen, simuliert unser Server einen modernen Chrome-Browser. Für woff-Dateien wird ein älterer Firefox verwendet, für ttf ein Android-Browser. So bekommen wir immer exakt das gewünschte Format – ohne Kompromisse.
Die REST-API für Entwickler
Neben der MCP-Integration bietet LocalFonts auch eine klassische REST-API. Für Entwickler, die Fonts in ihre eigenen Tools, Build-Pipelines oder Workflows integrieren möchten:
| Endpoint | Methode | Funktion |
|---|---|---|
| /v1/fonts | GET | Katalog durchsuchen (Name, Kategorie, Subset) |
| /v1/css | GET | @font-face CSS generieren (mit lokalen oder CDN-Pfaden) |
| /v1/font/{family}/{variant} | GET | Einzelne Font-Datei herunterladen (woff2/woff/ttf) |
| /v1/register | POST | Account erstellen, API-Key erhalten (anonym moeglich) |
| /v1/account | GET | Verbrauch und Account-Info pruefen |
# Schnell einen API-Key erstellen (anonym, keine E-Mail nötig)
curl -X POST https://fonts.realmaker.de/v1/register
# → {"api_key": "rf_a1b2c3...", "tier": "free", "daily_limit": 100}
# Font-Katalog durchsuchen
curl "https://fonts.realmaker.de/v1/fonts?search=inter&category=sans-serif"
# CSS generieren (mit lokalen Pfaden)
curl "https://fonts.realmaker.de/v1/css?family=Inter&weights=400,600,700&local_paths=true&api_key=rf_..."
# Einzelne Font-Datei herunterladen
curl -o inter-400-normal.woff2 "https://fonts.realmaker.de/v1/font/inter/400-normal.woff2?api_key=rf_..."Du brauchst weder E-Mail noch Passwort, um einen API-Key zu erstellen. Ein einfacher POST-Request ohne Body reicht aus. Das ist bewusst so designt – ein Dienst, der DSGVO-Konformität ermöglicht, sollte selbst möglichst wenig Daten erheben.
Technik unter der Haube
Für die Technik-Interessierten: So ist realmaker LocalFonts aufgebaut.
realmaker LocalFonts
├── MCP-Server (JSON-RPC 2.0)
│ ├── Session-Management
│ ├── 6 spezialisierte Tools
│ └── API-Key-Validierung pro Tool
├── REST-API (Slim 4 Framework)
│ ├── /v1/fonts (Katalog-Suche)
│ ├── /v1/css (CSS-Generierung)
│ ├── /v1/font/ (Font-Download)
│ ├── /v1/register (Registrierung)
│ └── /v1/account (Nutzung)
├── Middleware-Chain
│ ├── CORS (Preflight-Handling)
│ ├── Auth (API-Key-Validierung, SHA256)
│ ├── Rate-Limiting (tagliches Kontingent)
│ └── Usage-Logging (Analytics)
├── Services
│ ├── GoogleFontsSync (Katalog-Sync)
│ ├── GoogleFontFetcher (CSS parsen + Download)
│ ├── FontDownloader (Lazy-Loading)
│ └── CssGenerator (@font-face Erstellung)
├── Storage
│ ├── /fonts/ (gecachte Font-Dateien)
│ ├── /cache/ (File-basierter Cache)
│ └── /logs/ (Monolog)
└── Datenbank (MySQL 8)
├── fonts (1.600+ Eintraege)
├── font_variants (Weights, Styles, Formate)
├── users + api_keys
└── usage_log + font_requests
| Komponente | Technologie | Warum |
|---|---|---|
| Backend | PHP 8.2 + Slim 4 | Leichtgewichtig, schnell, überall hostbar |
| MCP-Protokoll | JSON-RPC 2.0 über HTTP | Standard-Protokoll für KI-Tool-Integration |
| Datenbank | MySQL 8 / MariaDB | Font-Katalog, Nutzerverwaltung, Analytics |
| Caching | File-basiert (kein Redis nötig) | Einfach, keine externe Abhängigkeit |
| API-Key-Sicherheit | SHA256-Hash, timing-safe Vergleich | Keys werden nie im Klartext gespeichert |
Die gesamte Infrastruktur läuft auf einem einzigen VPS – kein Redis, kein komplexes Cloud-Setup. PHP-FPM und Nginx reichen völlig aus. Das macht LocalFonts nicht nur schnell, sondern auch einfach zu warten und günstig zu betreiben.
Pakete und Preise
Ein Dienst, der DSGVO-Probleme löst, sollte selbst keine Hürden aufbauen. Deshalb ist der Free-Plan dauerhaft kostenlos – mit echtem Mehrwert, nicht als künstlich beschränkte Testversion.
| Free | Pro | Enterprise |
|---|---|---|
| Kostenlos | 9 Euro / Monat | Individuell |
| 100 Requests / Tag | 10.000 Requests / Tag | Unlimitiert |
| woff2-Format | woff2 + woff + ttf | Alle Formate + Custom |
| Alle 6 MCP-Tools | Alle 6 MCP-Tools | MCP + Priority Support |
| REST-API | REST-API | REST-API + Whitelabel |
| Anonyme Registrierung | E-Mail optional | Dedizierter Support |
100 Requests pro Tag klingt wenig? Bedenke: Die Fonts werden einmal heruntergeladen und liegen dann lokal im Projekt. Ein typisches Webprojekt braucht 2-3 API-Calls (Suche + Download). Damit kannst du pro Tag über 30 komplette Projekte mit lokalen Fonts ausstatten. Für die meisten Freelancer und kleinen Agenturen reicht der Free-Plan dauerhaft.
Einrichtung in 2 Minuten
Den MCP-Server mit deinem KI-Coding-Assistenten zu verbinden, dauert keine 2 Minuten. So geht’s:
API-Key erstellen
Registriere dich auf fonts.realmaker.de – anonym, ohne E-Mail, kostenlos. Du bekommst sofort einen API-Key (beginnt mit rf_). Alternativ per Terminal: curl -X POST https://fonts.realmaker.de/v1/register
MCP-Server verbinden
Fuege den MCP-Server zu deinem KI-Coding-Assistenten hinzu. Der Befehl sieht je nach Tool unterschiedlich aus, aber das Prinzip ist immer gleich: MCP-URL und API-Key angeben. Ab sofort hat dein Agent Zugriff auf alle LocalFonts-Tools.
Fonts einbinden lassen
Ab jetzt kann dein KI-Agent bei jedem neuen Webprojekt automatisch lokale Fonts einbinden. Sag einfach: ‚Verwende die Schriftart Montserrat‘ – der Agent nutzt das install_font-Tool, laedt die Dateien herunter und bindet sie lokal ein. Kein manuelles Eingreifen noetig.
realmaker LocalFonts funktioniert mit jedem KI-Coding-Assistenten, der das MCP-Protokoll unterstützt. Das Protokoll ist ein offener Standard – die Integration ist nicht auf ein bestimmtes Tool beschränkt. Prüfe in der Dokumentation deines Assistenten, ob MCP-Server unterstützt werden.
Fazit: Die Zukunft der Font-Integration ist automatisiert
KI-gestützte Webentwicklung ist keine Zukunftsmusik – sie ist Realität. Millionen von Websites werden heute mit Hilfe von KI-Agenten erstellt. Aber solange diese Agenten standardmäßig Google Fonts per CDN einbinden, entstehen millionenfach DSGVO-Verstöße. Manuell nachbessern? Funktioniert bei einem Projekt. Aber nicht bei zehn, zwanzig oder hundert.
realmaker LocalFonts löst dieses Problem an der Wurzel. Nicht indem es den Entwickler zwingt, etwas zu tun – sondern indem es dem KI-Agenten beibringt, es richtig zu machen. Der Agent sucht die passende Schriftart, lädt sie herunter, schreibt das CSS mit lokalen Pfaden und bindet alles korrekt ein. Vollautomatisch. DSGVO-konform. Ohne dass der Entwickler einen einzigen Font manuell anfassen muss.
Das Ziel war nicht, ein weiteres Font-Hosting-Tool zu bauen. Das Ziel war, KI-Agenten datenschutzkonform zu machen – beim Thema Fonts, automatisch, von Anfang an.
Michael Rademacher, Gründer realmaker
Und das Beste: Du kannst sofort loslegen. Kostenlos, ohne E-Mail, ohne Kreditkarte. 100 Requests pro Tag, der komplette Google-Fonts-Katalog, alle sechs MCP-Tools. Registriere dich, verbinde den MCP-Server und lass deinen KI-Agenten von jetzt an Fonts richtig einbinden.
realmaker LocalFonts auf einen Blick
- MCP-Server fuer KI-Agenten – Fonts werden lokal ins Projekt heruntergeladen
- 1.600+ Google Fonts, taeglich synchronisiert, alle Weights und Stile
- 6 spezialisierte MCP-Tools – von der Suche bis zur kompletten Installation
- Kein CDN, kein Proxy – echtes lokales Self-Hosting, DSGVO-konform
- REST-API fuer eigene Tools, Build-Pipelines und Workflows
- Free-Plan dauerhaft kostenlos – anonyme Registrierung, kein Haken
KI-Agenten DSGVO-konform machen
Jetzt kostenlos starten
Registriere dich, verbinde den MCP-Server und lass deinen KI-Agenten von jetzt an Google Fonts automatisch lokal einbinden. Kein Risiko, keine Kosten.
Häufige Fragen
Nein. Der MCP-Server gibt deinem KI-Agenten die Befehle zum Herunterladen – aber die Font-Dateien werden lokal in deinem Projektordner gespeichert. Wenn deine Website online geht, lädt der Browser die Schriftarten von deinem eigenen Server. Es gibt keinen laufenden Kontakt zu fonts.realmaker.de oder Google. Der einzige Moment, in dem unser Server beteiligt ist, ist der einmalige Download während der Entwicklung.
Mit jedem, der das MCP-Protokoll unterstützt. MCP ist ein offener Standard, der von immer mehr KI-Tools implementiert wird. Darüber hinaus kannst du die REST-API auch direkt nutzen – per curl, in Build-Skripten oder in jedem anderen Workflow, der HTTP-Requests senden kann.
So wenig wie möglich. Du kannst dich komplett anonym registrieren – ohne E-Mail, ohne Passwort. Wir speichern nur den gehashten API-Key und anonymisierte Nutzungsstatistiken (welche Endpoints aufgerufen wurden). Keine IP-Adressen, keine persönlichen Profile. Ein Dienst, der DSGVO-Konformität ermöglicht, muss selbst vorbildlich sein.
Absolut. Die REST-API funktioniert völlig unabhängig vom MCP-Server. Du kannst die Fonts per curl herunterladen, das CSS über die API generieren lassen und alles manuell in dein Projekt einbinden. Der MCP-Server ist das Sahnehäubchen für die KI-gestützte Entwicklung – aber die API steht jedem offen.
Ja. Der Free-Plan mit 100 Requests pro Tag, Zugang zu allen 1.600+ Fonts und allen sechs MCP-Tools ist dauerhaft kostenlos. Kein Trial, kein Ablaufdatum. Der Pro-Plan für 9 Euro im Monat richtet sich an Agenturen und Power-User, die mehr Requests und zusätzliche Formate (woff, ttf) brauchen.
realmaker LocalFonts ist ein Produkt von realmaker – deiner Kreativagentur für Film, Web und KI-Lösungen.
