So bauen Sie eine Astrologie-App: ein umfassender Leitfaden für Entwickler

🕓 Eintrag vom 2026-04-14, aktualisiert am 2026-05-09. TS / Python / PHP SDK sind jetzt in öffentlichen Registries verfügbar — @astroway/sdk (npm), astroway (PyPI), astroway/sdk (Packagist). Details im Changelog.

Möchtest du eine astrologische App erstellen. Wo fängst du an? In diesem Guide — Lösungen und Code: von der Auswahl der API bis zum Deployen eines funktionierenden Produkts.

Architekturfragen

Bevor du Code schreibst, überlege: Berechnungen auf dem Client oder auf dem Server?

Client (z.B. Swiss Ephemeris WASM im Browser):

Vorteile: keine Kosten pro Anfrage, funktioniert offline, vollständige Kontrolle
Nachteile: ~2 MB WASM pro Benutzer, komplexes Lizenzieren (kommerzielle Nutzung von Swiss Ephemeris hat Einschränkungen), du selbst übernimmst den Wartungsaufwand für den Berechnungscode

Server-API (AstroWay, Prokerala usw.):

Vorteile: keine Client-Abhängigkeiten, kleines Bundle der App, schnell auf mobilen Geräten, keine Lizenzschmerzen
Nachteile: Kosten in Krediten pro Anfrage, Verzögerung bei “kalten” Anfragen

Für die meisten Anwendungen gewinnt die Server-API. Mobile Benutzer werden nicht 2 MB WASM warten; mit Lizenznuancen solltest du dich nicht abgeben; und moderne APIs cachieren kostenlose identische Anfragen (AstroWay macht einen 5-minütigen Cache mit dem Header X-Cache: HIT).

API-Auswahl

Was zählt:

Genauigkeit — suche nach Swiss Ephemeris “unter der Haube” (±1 Winkelsekunde). Wenn die API das nicht direkt sagt — frage nach.
Abdeckung — Natal + Synastrie + Transite — Minimum. Fortschritte und Rückkehr — nächstes Level. Seltene Techniken (Rektifikation, Human Design) — das ist ein Differenzierer.
SDK-Qualität — typisierte TypeScript- und Python-SDK sparen Stunden.
Tarifmodell — credit-basiert skaliert besser als pro Anfrage, bei gemischter Last.

Für diesen Tutorial nehmen wir AstroWay API, weil es alle vier (723 Endpunkt, Swiss Ephemeris, typisierte SDK, credit-basiert) hat.

Schritt 1: Backend aufsetzen

Rufe niemals eine astrologische API direkt aus dem Browser auf — dein API-Schlüssel wird ausgespuckt. Gehe immer über dein eigenes Backend.

mkdir my-astrology-app
cd my-astrology-app
npm init -y
npm install express @astroway/sdk zod
npm install -D typescript @types/express @types/node tsx

Erstelle src/server.ts:

import express from 'express';
import { Astroway } from '@astroway/sdk';
import { z } from 'zod';

const app = express();
app.use(express.json());

const client = new Astroway({
  apiKey: process.env.ASTROWAY_API_KEY!,
});

const BirthInput = z.object({
  date: z.string(),
  time: z.string(),
  timezoneOffset: z.number(),
  latitude: z.number(),
  longitude: z.number(),
});

app.post('/api/chart', async (req, res) => {
  const parsed = BirthInput.safeParse(req.body);
  if (!parsed.success) return res.status(400).json({ error: parsed.error });

  try {
    const chart = await client.chart({
      ...parsed.data,
      houseSystem: 'P',
    });
    res.json(chart);
  } catch (err) {
    res.status(500).json({ error: String(err) });
  }
});

app.listen(3000, () => console.log('http://localhost:3000'));

Starte:

ASTROWAY_API_KEY=aw_test_... npx tsx src/server.ts

Überprüfe mit curl:

curl -X POST http://localhost:3000/api/chart \
  -H "Content-Type: application/json" \
  -d '{"date":"1990-07-14","time":"14:30:00","timezoneOffset":3,"latitude":50.4501,"longitude":30.5234}'

Erhältst eine vollständige JSON-Natal-Karte.

Schritt 2: Frontend

Passt jedes Framework. Für das Beispiel — React mit einer einfachen Form:

import { useState } from 'react';

type Chart = {
  planets: { name: string; longitude: number; sign: string; house: number }[];
  aspects: { planet1: string; planet2: string; type: string; orb: number }[];
};

export function NatalForm() {
  const [chart, setChart] = useState<Chart | null>(null);

  async function handleSubmit(formData: FormData) {
    const body = Object.fromEntries(formData.entries());
    const res = await fetch('/api/chart', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        date: body.date,
        time: body.time + ':00',
        timezoneOffset: Number(body.tz),
        latitude: Number(body.lat),
        longitude: Number(body.lng),
      }),
    });
    setChart(await res.json());
  }

  return (
    <div>
      <form action={handleSubmit}>
        <input name="date" type="date" required />
        <input name="time" type="time" required />
        <input name="tz" type="number" placeholder="Timezone offset (z.B. 3)" required />
        <input name="lat" type="number" step="0.0001" placeholder="Breitengrad" required />
        <input name="lng" type="number" step="0.0001" placeholder="Längengrad" required />
        <button>Erstelle Karte</button>
      </form>

      {chart && (
        <div>
          <h2>Planeten</h2>
          <ul>
            {chart.planets.map(p => (
              <li key={p.name}>{p.name}: {p.sign} (Haus {p.house})</li>
            ))}
          </ul>
          <h2>Aspekte</h2>
          <ul>
            {chart.aspects.map((a, i) => (
              <li key={i}>{a.planet1} {a.type} {a.planet2} (Orb {a.orb.toFixed(2)}°)</li>
            ))}
          </ul>
        </div>
      )}
    </div>
  );
}

Schritt 3: Synastrie

Kompatibilität — nächstes offensichtliches Feature. Füge in src/server.ts hinzu:

const SynastryInput = z.object({
  chart1: BirthInput,
  chart2: BirthInput,
});

app.post('/api/synastry', async (req, res) => {
  const parsed = SynastryInput.safeParse(req.body);
  if (!parsed.success) return res.status(400).json({ error: parsed.error });

  const result = await client.synastry(parsed.data);
  res.json({
    score: result.compatibility.score,
    label: result.compatibility.label,
    aspects: result.crossAspects,
  });
});

Fertig. Ein Endpunkt, 50 Kredite pro Aufruf, gibt Score 0–100 und cross-Aspekte zurück.

Schritt 4: Tägliche Horoskope

Für Content-Engagement sind tägliche Horoskope ein Muss. AstroWay generiert sie mit echten Transiten:

app.post('/api/horoscope/daily', async (req, res) => {
  const parsed = BirthInput.safeParse(req.body);
  if (!parsed.success) return res.status(400).json({ error: parsed.error });

  const horoscope = await client.horoscopeDaily(parsed.data);
  res.json({
    text: horoscope.text,
    disclaimer: horoscope.disclaimer, // unbedingt in der UI speichern!
  });
});

Wichtig: AI-generierter Inhalt enthält einen Disclaimer, den du den Benutzern zeigen musst (nach den Nutzungsbedingungen). Entferne ihn nicht.

Schritt 5: Caching

Tägliche Horoskope sind für alle Benutzer mit dem gleichen Geburtstag und ähnlichen Natal-Karten gleich. Cachiere aggressiv:

import { LRUCache } from 'lru-cache';

const cache = new LRUCache<string, any>({ max: 1000, ttl: 86400 * 1000 });

app.post('/api/horoscope/daily', async (req, res) => {
  const key = JSON.stringify(req.body);
  const cached = cache.get(key);
  if (cached) return res.json(cached);

  const horoscope = await client.horoscopeDaily(req.body);
  cache.set(key, horoscope);
  res.json(horoscope);
});

In AstroWay gibt es auch ein eingebautes 5-minütiges Server-Caching (X-Cache: HIT), aber für langfristigen Inhalt benötigst du deinen eigenen Cache.

Schritt 6: Deployen

Passt jede Plattform. Für einen schnellen Start — Vercel oder Railway:

# vercel.json
{ "functions": { "src/server.ts": { "runtime": "@vercel/node" } } }

In der Plattform-Steuerung stelle die Umgebungsvariable ASTROWAY_API_KEY ein.

Budgetplanung

Wenn du bis hierher gekommen bist — schätze dein monatliches Kreditverbrauch vor dem Start:

credits/month = DAU × (avg_charts_per_user × 20
                     + avg_synastries × 50
                     + avg_horoscopes × 20) × 30

Für 100 DAU mit 1 Karte + 1 Horoskop + 0,3 Synastrien pro Benutzer pro Tag:

100 × (20 + 20 + 0,3 × 50) × 30 = 165 000 Kredite / Monat

Das ist der Starter-Plan für 19 $/Monat (200.000 Kredite).

Was kommt als Nächstes

Fortgeschrittene Funktionen, die du hinzufügen solltest, wenn du wächst:

Transit-Überlagerung — /v1/transits zeigt aktuelle Planetenpositionen auf der Natal-Karte
Fortschritte — /v1/progressions für die psychologische Entwicklung
Sonnenumkehr — /v1/solar-return für den “Prognose auf ein Jahr ab dem Geburtstag”
Human Design — Human Design API öffnet ein ganz neues Funktionsfeld
Astro-Kartografie — /v1/acg kartiert, wo der Benutzer leben sollte

Jede Funktion ist schwer zu implementieren, aber — ein API-Aufruf mit AstroWay.

Los geht’s

Erhalte einen kostenlosen API-Schlüssel — 10.000 Kredite / Monat
Vollständige API-Referenz — alle 723 Endpunkte
Geburts-Karten-API — detaillierte Dokumentation des Endpunkts der Karte

AstroWay team

Das Engineering-Team von AstroWay API. Wir verpacken Swiss Ephemeris in reines REST und schreiben über die langweiligen Details, die wirklich wichtig sind.

// darauf aufbauen

Derselbe Swiss Ephemeris wie in Solar Fire — in 4 Zeilen Code.

Kostenloser Schlüssel ohne Kreditkarte. 5.000 Aufrufe pro Monat vor der ersten Zahlung.

API-Schlüssel erhalten → Dokumentation