Automatisiere die Kundenberichterstattung mit der Kinsta-API und Google AI

Für moderne Agenturen ist ein hochwertiges, konsistentes Berichtswesen unerlässlich, um das Vertrauen ihrer Kunden zu erhalten und eine langfristige Loyalität aufzubauen. Mit übersichtlichen, informativen Berichten kannst du Verkaufstrends überwachen, die Wirksamkeit von Kampagnen nachweisen, den Return on Investment (ROI) berechnen und vieles mehr.

Für eine Agentur, die Dutzende oder sogar Hunderte von Websites verwaltet, kann die Erstellung dieser regelmäßigen Berichte jedoch zu einem großen Engpass werden, der die Skalierbarkeit deines Betriebs beeinträchtigt.

Deshalb ist es wichtig, die Datenabfrage zu optimieren und zu automatisieren. Dadurch wird die Effizienz wiederhergestellt und dein Team kann sich auf wichtige Aufgaben konzentrieren – wie die Entwicklung neuer Projekte.

In diesem Artikel erfährst du, wie du die Kinsta-API nutzen kannst, um deine Hosting-Daten automatisch abzurufen und strategische Berichte mit der Kraft der KI zu erstellen.

Bist du bereit, dein Berichtssystem zu skalieren? Lies weiter.

Zugriff auf Kinsta Analytics über MyKinsta und Kinsta API

Kinsta-Kunden haben über das MyKinsta-Hosting-Dashboard Zugang zu einer Vielzahl von Daten. Du kannst auf die Daten deines Plans im Bereich Analytics in deinem Dashboard zugreifen.

Übersicht über den MyKinsta-Analytics-Bereich

Die Analytics-Seite ist in mehrere Registerkarten unterteilt, die sich jeweils auf einen bestimmten Aspekt der Aktivitäten auf deiner Website konzentrieren:

Planauslastung: Zeigt den Ressourcenverbrauch deines Plans an, sowohl kumuliert als auch aufgeschlüsselt nach einzelnen Websites.
Top-Anfragen: Ermöglicht es dir, die wichtigsten Anfragen an deine Website zu identifizieren, aufgeschlüsselt nach Bandbreite und Ansichten.
Cache: Hier findest du eine Aufschlüsselung der Cache-Nutzung, einschließlich der Cache-Aufschlüsselung, der Server-Cache-Komponenten und der Server-Cache-Umgehungen.
CDN & Edge: Bietet Daten zum CDN-Bandbreitenverbrauch, zur Edge-Cache-Bandbreite und Listen der wichtigsten Dateien, die aus dem CDN-Cache ausgeliefert werden.
Streuung: Zeigt den prozentualen Anteil der Besuche von Desktop, Tablet und Handy.
Leistung: Enthält verschiedene Leistungskennzahlen wie die durchschnittliche PHP-MySQL-Antwortzeit, den PHP-Durchsatz, das PHP-Thread-Limit und mehr.
Antwort: Liefert Statistiken zu Antwortcodes, einschließlich einer detaillierten Aufschlüsselung der Fehlercodes.
Geo & IP: Zeigt Listen der Top-Länder, Top-Städte und Top-Client-IPs an, von denen die Anfragen an deine Website stammen.

Du kannst dieselben Analysen auch auf Website-Ebene abrufen, indem du zu Websites > Websitename > Analytics navigierst.

Kinsta Analytics bietet einen beeindruckenden Datensatz. Wenn du durch dein MyKinsta-Dashboard navigierst, bekommst du ein klares Bild vom Ressourcenverbrauch, der Effizienz und der Leistung deiner Website. Du wirst genau wissen, woher die meisten Anfragen kommen und welche die meisten Ressourcen verbrauchen.

In Kombination mit unserem Kinsta APM-Tool kannst du mit Kinsta Analytics die Leistung deiner WordPress-Websites optimieren.

Was nicht jeder weiß, ist, dass die Daten von Kinsta Analytics auch über die Kinsta API zugänglich sind. Damit kannst du programmatisch Daten abrufen und Hosting-Metriken erstellen, die du dann zur Erstellung automatisierter Berichte für deine Kunden verwenden kannst.

Schauen wir uns die Kinsta-API-Endpunkte an.

Der Analytics-Endpunkt der Kinsta-API

Mit dem Analytics-Endpunkt der Kinsta-API kannst du Rohdaten über die Ressourcennutzung und den Zustand deiner Website abrufen.

Besucherzahlen, Server-Bandbreitennutzung und CDN-Bandbreitennutzung: Diese Kennzahlen geben Aufschluss über die Ressourcennutzung im Verhältnis zu deinem Hosting-Plan während des aktuellen Abrechnungszeitraums.
Besuche: Zeigt die Gesamtzahl der Besuche in einer bestimmten Umgebung innerhalb eines bestimmten Zeitraums an.
Speicherplatz: Zeigt den gesamten Speicherplatz an, den eine bestimmte Umgebung in einem bestimmten Zeitraum verbraucht hat.
Server-Bandbreite: Gibt die Bandbreite an, die von einer bestimmten Umgebung in einem bestimmten Zeitraum verbraucht wurde.
CDN-Bandbreite: Zeigt die CDN-Bandbreite an, die eine bestimmte Umgebung in einem bestimmten Zeitraum verbraucht hat.
Top-Länder: Gibt eine Liste der wichtigsten Länder an, aus denen die Anfragen an die Website innerhalb eines bestimmten Zeitraums stammen.
Top-Städte: Gibt eine Liste der wichtigsten Städte an, aus denen in einem bestimmten Zeitraum Anfragen an die Website gestellt wurden.
Top Client IPs: Enthält eine Liste der wichtigsten Client-IP-Adressen, von denen in einem bestimmten Zeitraum Zugriffe auf die Website ausgingen.
Besuchsstreuung: Sie liefert Daten über die Verteilung der Besuche auf Desktop-, Tablet- und Mobilgeräte in einem bestimmten Zeitraum.
Aufschlüsselung der Antwortcodes: Liefert eine Aufschlüsselung der HTTP-Statuscodes, die vom Server innerhalb eines bestimmten Zeitraums zurückgegeben wurden.

Im Folgenden findest du einige Beispiele für die Nutzung des Analyse-Endpunkts.

Besuche

Die folgende Anfrage liefert die Gesamtzahl der Besuche auf deiner Website und die Anzahl der eindeutigen IP-Adressen, die in den letzten 30 Tagen auf die Website zugegriffen haben:

https://api.kinsta.com/v2/sites/environments/{KINSTA_ENV_ID}/analytics/visits?time_span=30_days&company_id={KINSTA_COMPANY_ID}

Die Antwort wird wie folgt aufgebaut sein:

{
	"analytics": {
		"analytics_response": {
			"key": "uniqueip",
			"data": [
				{
					"name": "uniqueip",
					"total": 1000,
					"dataset": [
						{
							"key": "2025-10-28T00:00:00.000Z",
							"value": "1000"
						},
						{
							"key": "2025-10-28T00:00:00.000Z",
							"value": "900"
						},
						{
							"key": "2025-10-28T00:00:00.000Z",
							"value": "820"
						},
						...
					]
				}
			]
		}
	}
}

Bandbreite

Das folgende Beispiel zeigt, wie du die Kinsta-API abfragst, um die Bandbreitennutzung des Servers in den letzten 30 Tagen zu ermitteln:

https://api.kinsta.com/v2/sites/environments/{KINSTA_ENV_ID}/analytics/bandwidth?time_span=30_days&company_id={KINSTA_COMPANY_ID}

Die Antwort des Kinsta-Servers liefert die tägliche Bandbreitennutzung für die letzten 30 Tage:

{
	"analytics": {
		"analytics_response": {
			"key": "bandwidth",
			"data": [
				{
					"name": "bandwidth",
					"total": 1000,
					"dataset": [
						{
							"key": "2026-03-11T00:00:00.000Z",
							"value": "37347250"
						},
						{
							"key": "2026-03-12T00:00:00.000Z",
							"value": "9276458"
						},
						...
					]
				}
			]
		}
	}
}

CDN-Bandbreite

In diesem anderen Beispiel fragen wir die Kinsta-API ab, um die CDN-Bandbreitennutzung der letzten 7 Tage herauszufinden:

https://api.kinsta.com/v2/sites/environments/{KINSTA_ENV_ID}/analytics/cdn-bandwidth?time_span=7_days&company_id={KINSTA_COMPANY_ID}

Der Server liefert die folgenden Daten:

{
	"analytics": {
		"analytics_response": {
			"key": "cdn-bandwidth",
			"data": [
				{
					"name": "cdn-bandwidth",
					"total": 1000,
					"dataset": [
						{
							"key": "2026-04-02T00:00:00.000Z",
							"value": "753447"
						},
						{
							"key": "2026-04-03T00:00:00.000Z",
							"value": "16911"
						},
						...
					]
				}
			]
		}
	}
}

Du kannst es selbst ausprobieren, indem du deinen Kinsta-API-Schlüssel (Inhaber-Token), die Umgebungs-ID und die Unternehmens-ID in den API-Spielplatz eingibst.

Jetzt, wo du weißt, wie du auf die Analysedaten deiner Website auf Kinsta zugreifen kannst, kannst du sie nutzen, um deinen Betrieb zu automatisieren. Dazu gehört auch das Automatisieren des Berichtswesens.

In den folgenden Abschnitten zeigen wir dir, wie du das Berichtswesen deiner Agentur mithilfe der Kinsta-API automatisieren kannst. Wir werden ein Python-Skript erstellen und GitHub Actions nutzen, um die Erstellung und Ausführung zu automatisieren. Damit werden die von der API zurückgegebenen Rohdaten in Tabellen und Diagramme umgewandelt und Google AI abgefragt, um einen endgültigen Bericht zu erstellen.

Es ist Zeit anzupacken.

Baue ein automatisiertes Meldesystem mit der Kinsta API und Google AI

Unser Ziel ist es, einen automatisierten Bericht zu erstellen, der in bestimmten Abständen generiert wird. Das System wird die Kinsta-API abfragen, um Daten über Besuche, Server-Bandbreite und CDN-Bandbreite zu erhalten. Diese Daten werden dann verwendet, um Diagramme und Tabellen in einer PDF-Datei zu erstellen. Als Teil dieses Prozesses werden die Daten an die Gemini API gesendet, um eine Analyse der extrahierten Daten zu erstellen, die dann in den Bericht aufgenommen wird.

Vorschau des automatisierten Berichts, der mit GitHub Actions und der Kinsta API erstellt wird

Einrichten des Projekts auf GitHub

Auf der GitHub-Startseite klickst du auf die grüne Schaltfläche Neu, um ein neues Projekt zu erstellen. Sobald du ein leeres Projekt hast, gehst du zu Einstellungen > Geheimnisse und Variablen > Aktionen und fügst die im folgenden Bild gezeigten Geheimnisse hinzu.

Geheime Daten in GitHub-Actions-Repositorys

Wenn du deine API-Schlüssel und IDs in GitHub Secrets speicherst, sind sie für jeden unzugänglich und dein Code bleibt sicher.

GEMINI_API_KEY

Du kannst einen Google AI API-Schlüssel im Google AI Studio Dashboard erstellen. Weitere Informationen findest du in der Google AI-Dokumentation.

KINSTA_API-KEY

Befolge als Nächstes die Anweisungen in unserem Artikel, um einen Kinsta-API-Schlüssel zu generieren.

KINSTA_COMPANY_ID, KINSTA_ENV_ID, KINSTA_SITE_ID

Du findest die Site ID, Environment ID und Company ID unter Websites > Websitename > Info in deinem MyKinsta Dashboard.

Kommen wir nun zu den Projektdateien.

Erforderliche Bibliotheken und GitHub Actions Konfiguration

Erstelle im Stammverzeichnis deines GitHub-Projekts eine Datei namens requirements.txt und füge Folgendes hinzu:

google-genai
requests
matplotlib
fpdf2

Diese Datei listet die Komponenten auf, die für dein Projekt benötigt werden.

google-genai: Dies ist die Bibliothek von Google für die Interaktion mit Gemini-Modellen.
requests: Eine Bibliothek, um HTTP-Anfragen zu stellen. In diesem Projekt wird sie verwendet, um HTTP-Anfragen an die Kinsta-API zu senden.
matplotlib: Eine Python-Bibliothek zur Erstellung von Diagrammen und zur Visualisierung von Daten.
fpdf2: Eine Bibliothek, mit der du PDF-Dateien erstellen kannst.

Als Nächstes erstellst du eine Datei namens .github/workflows/generate_report.yml mit dem folgenden Code:

name: Generate Kinsta Analytics Report

on:
  push:
    branches: [main]
  workflow_dispatch:

jobs:
  build-and-run:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Run Report Script
        env:
          KINSTA_API_KEY: ${{ secrets.KINSTA_API_KEY }}
          KINSTA_ENV_ID: ${{ secrets.KINSTA_ENV_ID }}
          KINSTA_SITE_ID: ${{ secrets.KINSTA_SITE_ID }}
          KINSTA_COMPANY_ID: ${{ secrets.KINSTA_COMPANY_ID }}
          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
        run: python main.py

      - name: Upload Report
        uses: actions/upload-artifact@v4
        with:
          name: Kinsta-Advanced-Report
          path: "*.pdf"

GitHub verwendet diese Datei, um deinen Code automatisch über GitHub Actions auszuführen. Schauen wir uns das mal genauer an:

name: Generate Kinsta Analytics Report

on:
  push:
    branches: [main]
  workflow_dispatch:

name: Der Name deines Projekts, wie er in der Registerkarte Aktionen auf GitHub erscheint.
on: Legt fest, wann der Workflow ausgelöst werden soll.
push: Der Workflow wird jedes Mal ausgeführt, wenn du eine Codeänderung in den Hauptzweig verschiebst.
workflow_dispatch: Ermöglicht es dir, den Workflow manuell auszuführen.

jobs:
  build-and-run:
    runs-on: ubuntu-latest

jobs: Der Start der auszuführenden Aufgaben.
build-and-run: Ein beliebiger Name, der eine bestimmte Abfolge von Aktionen kennzeichnet.
runs-on: Legt das System fest, auf dem der Arbeitsablauf ausgeführt werden soll.
ubuntu-latest: Legt die neueste Version von Ubuntu Linux fest.

steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'

steps: Die Reihenfolge der auszuführenden Operationen.
name: Der Name der Operation, die durchgeführt werden soll
uses: Das vorkonfigurierte GitHub-Modul (Action)

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

python -m pip install --upgrade pip: Aktualisiert pip (den Python-Paketmanager) auf die neueste verfügbare Version.
pip install -r requirements.txt: Liest die Datei requirements.txt und installiert die darin aufgeführten Pakete.

      - name: Run Report Script
        env:
          KINSTA_API_KEY: ${{ secrets.KINSTA_API_KEY }}
          KINSTA_ENV_ID: ${{ secrets.KINSTA_ENV_ID }}
          KINSTA_SITE_ID: ${{ secrets.KINSTA_SITE_ID }}
          KINSTA_COMPANY_ID: ${{ secrets.KINSTA_COMPANY_ID }}
          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
        run: python main.py

env: Ruft die Werte der Umgebungsvariablen von GitHub Secrets ab.
run: python main.py: Startet den Python-Interpreter und führt die Datei main.py aus.

     - name: Upload Report
        uses: actions/upload-artifact@v4
        with:
          name: Kinsta-Advanced-Report
          path: "*.pdf"

uses: actions/upload-artifact@v4: Verwendet die GitHub-Aktion zur Verwaltung von Artefakten, einer Datei oder einem Ordner, die während der Ausführung des Skripts erstellt werden.
with: Legt die Konfigurationsparameter fest.

Die Konfiguration deines Automatisierungsprojekts ist damit abgeschlossen. Jetzt ist es an der Zeit, die Python-Skripte zu erstellen.

Programmatische Abfrage der Kinsta-API

Sobald du die Einrichtung abgeschlossen hast, navigierst du zum Stammverzeichnis deines GitHub-Projekts und erstellst eine neue Datei namens kinsta_utils.py mit dem folgenden Code:

import requests
import os

KINSTA_API_KEY = os.getenv("KINSTA_API_KEY")
KINSTA_SITE_ID = os.getenv("KINSTA_SITE_ID")
KINSTA_ENV_ID = os.getenv("KINSTA_ENV_ID")
KINSTA_COMPANY_ID = os.getenv("KINSTA_COMPANY_ID")
BASE_URL = f"https://api.kinsta.com/v2/sites/environments/{KINSTA_ENV_ID}/analytics"

def get_headers():
    return {"Authorization": f"Bearer {KINSTA_API_KEY}"}

Die ersten beiden Import-Anweisungen laden die Standardbibliothek für HTTP-Anfragen und das Modul für die Interaktion mit dem Betriebssystem (os).
Die nächsten vier Zeilen (os.getenv) rufen deine Anmeldedaten von GitHub Secrets ab.
BASE_URL definiert den Hauptendpunkt der Kinsta-API, den das Skript verwendet.
Die Funktion get_headers generiert den Autorisierungs-Header, der den Kinsta-API-Schlüssel enthält.

Als Nächstes erstellst du eine Hilfsfunktion, die die von der API zurückgegebenen Rohdaten in Megabytes umwandelt.

def format_bytes_to_mb(bytes_value):
    """Converts raw bytes from API to human-readable Megabytes."""

    try:
        # Standard conversion to MB
        # return round(int(bytes_value) / (1024 * 1024), 2)

        # Decimal standard (used in MyKinsta dashboard) 
        return round(int(bytes_value) / 1_000_000, 2)

    except (ValueError, TypeError):
        return 0

Dieser Code bietet zwei Möglichkeiten. Die erste verwendet den binären Standard (1024 x 1024), die zweite den dezimalen Standard. Die Division durch 1_000_000 stellt sicher, dass die Zahl in deinem PDF-Bericht der Zahl entspricht, die deine Kunden in MyKinsta Analytics sehen würden.

Die folgende Funktion fragt die Kinsta-API ab und gibt eine Reihe von Rohdaten zurück:

def fetch_kinsta_metric(endpoint, start_date, end_date):

    url = f"{BASE_URL}/{endpoint}"

    params = {
        "company_id": KINSTA_COMPANY_ID,
        "from": f"{start_date}T00:00:00.000Z",
        "to": f"{end_date}T23:59:59.000Z"
    }

    try:
        response = requests.get(url, headers=get_headers(), params=params)
        if response.status_code == 200:
            data_node = response.json()['analytics']['analytics_response']['data'][0]
            total = data_node.get('total', 0)
            dataset = data_node.get('dataset', [])[:7]
            return total, dataset

    except Exception as e:
        print(f"Error fetching {endpoint}: {e}")

    return 0, []

Die Funktion fetch_kinsta_metric benötigt drei Argumente: endpoint, start_date und end_date. Diese werden verwendet, um die URL der Anfrage zu erstellen. Der Endpunkt kann visits, bandwidth oder cdn-bandwidth sein.
Im Array params werden die Parameter der Anfrage gespeichert.
Die Antwort von Kinsta ist ein verschachteltes JSON-Objekt (data_node), das die aggregierten Werte für den Zeitraum (total) und eine Liste der täglichen Werte (dataset) enthält.

Die letzte Funktion in der Datei kinsta_utils.py ruft den Websitenamen ab.

def fetch_site_name():
    url = f"https://api.kinsta.com/v2/sites/{KINSTA_SITE_ID}"
    
    try:
        response = requests.get(url, headers=get_headers())
        if response.status_code == 200:
            data = response.json()
            site_data = data.get('site', {})
            
            site_label = site_data.get('display_name', 'Unknown Site')
            
            env_label = "Unknown Env"
            envs = site_data.get('environments', [])
            for env in envs:
                if env.get('id') == KINSTA_ENV_ID:
                    env_label = env.get('display_name')
                    break
            
            return f"{site_label} ({env_label})"
        else:
            print(f"Kinsta API Error: {response.status_code} - {response.text}")
    except Exception as e:
        print(f"Error fetching site name: {e}")
        
    return "Unknown Site"

Dieser Code sollte selbsterklärend sein. In der API-Referenz findest du weitere Informationen über den Sites-Endpunkt.

Jetzt müssen wir nur noch den Workflow einrichten.

Automatisiere den Arbeitsablauf mit Python und Gemini

Die letzte Datei, die du erstellen musst, ist die Engine für deine Anwendung. Erstelle im Hauptverzeichnis deines GitHub-Projekts eine Datei main.py. Füge zu Beginn den folgenden Code ein:

import os
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from google.genai import Client
from fpdf import FPDF, XPos, YPos
from datetime import datetime, timedelta
from kinsta_utils import fetch_kinsta_metric, format_bytes_to_mb, fetch_site_name

REPORT_LANG = "en" 
MODEL_ID = "gemini-2.5-flash" 
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
client = Client(api_key=GEMINI_API_KEY)

today = datetime.now()
curr_end_dt = today - timedelta(days=1)
curr_start_dt = today - timedelta(days=7)
prev_end_dt = today - timedelta(days=8)
prev_start_dt = today - timedelta(days=14)

CURR_RANGE = f"{curr_start_dt.strftime('%b %d')} - {curr_end_dt.strftime('%b %d')}"
PREV_RANGE = f"{prev_start_dt.strftime('%b %d')} - {prev_end_dt.strftime('%b %d')}"

DATES = [
    prev_start_dt.strftime("%Y-%m-%d"), 
    prev_end_dt.strftime("%Y-%m-%d"), 
    curr_start_dt.strftime("%Y-%m-%d"), 
    curr_end_dt.strftime("%Y-%m-%d")
]

CURR_DAYS_LABELS = [(curr_start_dt + timedelta(days=i)).strftime("%d %a") for i in range(7)]
PREV_DAYS_LABELS = [(prev_start_dt + timedelta(days=i)).strftime("%d %a") for i in range(7)]
X_AXIS_LABELS = [(curr_start_dt + timedelta(days=i)).strftime("%d") for i in range(7)]

So ist das Skript aufgebaut:

Die Import-Anweisungen laden die notwendigen Bibliotheken, und matplotlib.use('Agg') weist Python an, die Diagramme zu erstellen und im Speicher zu halten.
Der folgende Block legt die Sprache (en) und das Modell (gemini-2.5-flash) fest und initialisiert dann den Google-Client.
Als Nächstes werden Zeitfenster definiert, um die Werte der letzten sieben Tage mit denen der vorherigen sieben Tage zu vergleichen.
Schließlich werden die Beschriftungen für Tabellen und Diagramme festgelegt.

Im nächsten Schritt wird eine KinstaReport-Klasse definiert, die mit Hilfe der FPDF-Bibliothek Berichtsseiten erstellt:

class KinstaReport(FPDF):
    def __init__(self, site_name="Unknown Site"):
        super().__init__()
        self.site_name = site_name

    def header(self):
        self.set_font("Helvetica", "B", 8)
        self.set_text_color(150)
        # Site name
        self.cell(100, 10, f"Site: {self.site_name}", align="L")
        # Date generated
        self.cell(0, 10, f"Kinsta Analytics Report | Generated: {datetime.now().strftime('%Y-%m-%d')}", 
                  align="R", new_x=XPos.LMARGIN, new_y=YPos.NEXT)

    def add_metric_page(self, title, chart_path, prev_vals, curr_vals, unit=""):
        self.add_page()
        # Page title
        self.set_font("Helvetica", "B", 24)
        self.set_text_color(83, 51, 237)
        self.cell(0, 15, title, align="C", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        
        # Subtitle
        self.set_font("Helvetica", "I", 10)
        self.set_text_color(120)
        self.cell(0, 5, f"Comparison: {CURR_RANGE} vs {PREV_RANGE}", align="C", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        
        self.image(chart_path, x=10, y=42, w=190)
        
        # Data tables
        self.set_y(150)
        self.set_font("Helvetica", "B", 10)
        self.set_fill_color(245, 245, 255)
        self.set_text_color(83, 51, 237)
        
        # Table header
        col1, col2 = 35, 60
        self.cell(col1, 10, " Day (Prev)", border=1, align='C', fill=True, new_x=XPos.RIGHT, new_y=YPos.TOP)
        self.cell(col2, 10, f"Value {unit}", border=1, align='C', fill=True, new_x=XPos.RIGHT, new_y=YPos.TOP)
        self.cell(col1, 10, " Day (Curr)", border=1, align='C', fill=True, new_x=XPos.RIGHT, new_y=YPos.TOP)
        self.cell(col2, 10, f"Value {unit}", border=1, align='C', fill=True, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        
        self.set_font("Helvetica", "", 10)
        self.set_text_color(50)
        for i in range(7):
            # Zebra striping
            fill = (i % 2 == 0)
            if fill: self.set_fill_color(250, 250, 250)
            else: self.set_fill_color(255, 255, 255)
            
            self.cell(col1, 9, f" {PREV_DAYS_LABELS[i]}", border=1, align='C', fill=fill, new_x=XPos.RIGHT, new_y=YPos.TOP)
            self.cell(col2, 9, f" {prev_vals[i]}", border=1, align='C', fill=fill, new_x=XPos.RIGHT, new_y=YPos.TOP)
            self.cell(col1, 9, f" {CURR_DAYS_LABELS[i]}", border=1, align='C', fill=fill, new_x=XPos.RIGHT, new_y=YPos.TOP)
            self.cell(col2, 9, f" {curr_vals[i]}", border=1, align='C', fill=fill, new_x=XPos.LMARGIN, new_y=YPos.NEXT)

Wir werden diesen Code nicht zu sehr ins Detail gehen. Weitere Informationen über die FPDF-Bibliothek findest du in den Online-Ressourcen:

Als nächstes definierst du eine Funktion generated_chart. Diese Funktion wandelt die von Kinsta erhaltenen Rohdaten in Diagramme um.

def generate_chart(labels, curr, prev, title, ylabel, filename, is_bar=False):
    plt.figure(figsize=(10, 5), dpi=100)
    ax = plt.gca()
    
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.spines['left'].set_color('#dddddd')
    ax.spines['bottom'].set_color('#dddddd')

    if is_bar:
        # Bar Chart for bandwidth
        bars = plt.bar(labels, curr, color='#00c4b4', alpha=0.6, label='Current Period', width=0.6)
        # Add labels above the bars
        for bar in bars:
            height = bar.get_height()
            plt.text(bar.get_x() + bar.get_width()/2., height + 0.02, f'{height}', ha='center', va='bottom', fontsize=8, color='#00a194')
    else:
        # Line chart for visits
        plt.plot(labels, curr, color='#5333ed', marker='o', markersize=6, linewidth=3, label='Current', zorder=3)
        plt.plot(labels, prev, color='#a1a1a1', linestyle='--', marker='x', markersize=5, linewidth=1.5, label='Previous', alpha=0.6)
        
        plt.fill_between(labels, curr, color='#5333ed', alpha=0.1)
    
    plt.title(title, fontsize=14, pad=20, color='#333333', fontweight='bold')
    plt.ylabel(ylabel, color='#666666')
    plt.xlabel("Day of Month", color='#666666')
    plt.legend(frameon=False, loc='upper right')
    plt.grid(axis='y', linestyle='--', alpha=0.3)
    plt.tight_layout()
    plt.savefig(filename)
    plt.close()

Diese Funktion verwendet die Matplotlib-Bibliothek, um die aus Kinsta extrahierten Daten in Diagramme umzuwandeln, die in den PDF-Bericht eingefügt werden können. Weitere Informationen zur Verwendung der Matplotlib-Bibliothek findest du in der Online-Dokumentation:

Zum Schluss fügst du die Funktion hinzu, die alle Teile, die wir bisher beschrieben haben, kombiniert.

def main():
    site_display_name = fetch_site_name()

    metrics = {
        "visits": {"title": "Site Visits", "unit": ""},
        "bandwidth": {"title": "Server Bandwidth", "unit": "(MB)"},
        "cdn-bandwidth": {"title": "CDN Bandwidth", "unit": "(MB)"}
    }
    
    report_data = {}
    for key in metrics:
        _, data_curr = fetch_kinsta_metric(key, DATES[2], DATES[3])
        _, data_prev = fetch_kinsta_metric(key, DATES[0], DATES[1])
        
        curr_vals = []
        prev_vals = []
        for i in range(7):
            c = float(data_curr[i]['value']) if i < len(data_curr) else 0
            p = float(data_prev[i]['value']) if i < len(data_prev) else 0
            
            if "bandwidth" in key:
                curr_vals.append(format_bytes_to_mb(c))
                prev_vals.append(format_bytes_to_mb(p))
            else:
                curr_vals.append(int(c))
                prev_vals.append(int(p))
                
        report_data[key] = {"curr": curr_vals, "prev": prev_vals}

    pdf = KinstaReport(site_name=site_display_name)
    
    for key, info in metrics.items():
        chart_file = f"{key}_chart.png"
        generate_chart(X_AXIS_LABELS, report_data[key]["curr"], report_data[key]["prev"], 
                       f"{info['title']} Trends", "Units", chart_file, is_bar=("bandwidth" in key))
        pdf.add_metric_page(info["title"], chart_file, report_data[key]["prev"], report_data[key]["curr"], info["unit"])

    # Executive Summary
    pdf.add_page()
    pdf.set_font("Helvetica", "B", 20)
    pdf.set_text_color(83, 51, 237)
    pdf.cell(0, 15, "Executive Summary", align="C", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
    
    curr_visits = sum(report_data['visits']['curr'])
    prev_visits = sum(report_data['visits']['prev'])
    curr_bw = sum(report_data['bandwidth']['curr'])
    prev_bw = sum(report_data['bandwidth']['prev'])

    try:
        summary_prompt = (
            f"Analyze Kinsta performance for site {site_display_name}. "
            f"Current Period ({CURR_RANGE}): {curr_visits} visits, {curr_bw:.2f}MB server bandwidth. "
            f"Previous Period ({PREV_RANGE}): {prev_visits} visits, {prev_bw:.2f}MB server bandwidth. "
            f"Compare these periods and identify trends. Language: {REPORT_LANG}. Max 4 sentences."
        )
        response = client.models.generate_content(model=MODEL_ID, contents=summary_prompt)
        summary = response.text
    except Exception as e:
        summary = f"Analytical insights unavailable. Error: {str(e)}"

    pdf.set_y(40)
    pdf.set_font("Helvetica", "", 12)
    pdf.set_text_color(0)
    pdf.multi_cell(0, 8, summary)
    
    report_filename = f"Kinsta_Report_{datetime.now().strftime('%Y-%m-%d')}.pdf"
    pdf.output(report_filename)
    print(f"Report generated: {report_filename}")

if __name__ == "__main__":
    main()

Das macht dieser Code:

Die for-Schleife iteriert durch das metrics-Array und fragt die Kinsta-API zweimal ab: einmal für die aktuelle Woche und einmal für die vorherige Woche.
Wenn sich die Daten auf die Bandbreite beziehen, wandelt die Funktion format_bytes_to_mb() die Rohdaten in MB um.
Die Funktion report_data() speichert die abgerufenen Daten.
KinstaReport erstellt dann für jede Website eine PDF-Datei.
Die nächste for-Schleife erzeugt PNG-Bilder für die Diagramme und erstellt für jede Kennzahl eine neue Seite.
Der nächste Abschnitt erstellt die Zusammenfassung, berechnet die Gesamtzahl der Besuche und die Gesamt-Megabytes für den Zeitraum und sendet eine dynamische Eingabeaufforderung an Gemini 2.5 Flash. Schließlich wird die Antwort verwendet, um die letzte Seite des PDF-Dokuments zu vervollständigen.
Das Skript speichert das Dokument unter einem Dateinamen, der das aktuelle Datum enthält.
* Die letzte Bedingung stellt sicher, dass der Prozess nur läuft, wenn das Skript als Hauptprogramm ausgeführt wird.

Jetzt ist es an der Zeit, deine Anwendung zu erstellen und auszuführen.

Abrufen des Artefakts

Du kannst deine Anwendung jetzt ausführen. Klicke auf deiner GitHub-Projektseite auf die Registerkarte Aktionen. Suche im Menü auf der linken Seite nach dem Namen deiner Aktion (in unserem Beispiel ist das der Name Generate Kinsta Analytics Report, wie in deiner Datei generate_report.yml angegeben).

Die Registerkarte Aktionen zeigt eine Liste von Workflows

Als Nächstes klickst du auf das Menü Workflow ausführen auf der rechten Seite und dann auf die grüne Schaltfläche Workflow ausführen (derzeit ist nur der Hauptzweig verfügbar).

Auf der nächsten Seite wird der aktuelle Workflow angezeigt. Klicke darauf, um die Liste der laufenden Vorgänge zu sehen.

Der Abschnitt Berichtsskript ausführen enthält eine Liste der durchgeführten Vorgänge, während der Abschnitt Bericht hochladen die URL für den Download des Artefakts enthält. Klicke auf diesen Link, um deinen Bericht im PDF-Format herunterzuladen.

Im Abschnitt Bericht hochladen findest du den Link zum PDF-Bericht

Denselben Link findest du auch im Abschnitt Artefakte, unten auf der Seite Zusammenfassung des Workflows.

Aktionen „Skript ausführen“ und „Bericht hochladen“

Die Bilder unten zeigen den vollständigen Bericht, einschließlich der von Google AI erstellten Zusammenfassung.

Seiten mit Berichten zu Website-Besuchen und Serverbandbreite

Seiten zum Bericht über CDN-Bandbreite und zur Zusammenfassung

Die nächsten Schritte: Wie man die Skalierbarkeit verbessert und die Auslieferung automatisiert

Dies ist nur ein Vorgeschmack darauf, was die Kinsta-API in Kombination mit fortschrittlichen Automatisierungstools wie GitHub Actions leisten kann. Die KI-Integration geht noch einen Schritt weiter und verwandelt rohe Zahlen in tiefgehende Berichte, die du mit deinen Kunden teilen kannst.

Du kannst deine Berichte auf verschiedene Arten weiter verbessern:

Du kannst deine Anwendung konfigurieren, indem du eine Zeile in die YAML-Datei einfügst (schedule: '0 9 * * 1'), um den Bericht jeden Montagmorgen um 9:00 Uhr zu erstellen.
Du könntest eine Bibliothek wie smtplib oder einen Dienst wie SendGrid integrieren, um den Bericht direkt an deinen Kunden zu senden.
Wenn du eine Agentur mit Dutzenden oder sogar Hunderten von Websites bist, könntest du eine Schleife implementieren, die über eine Liste von Website-IDs iteriert, um alle Berichte in einem einzigen Durchlauf zu erstellen.
Du kannst den Inhalt deines Berichts noch weiter anreichern, indem du die Kinsta-API nutzt, um geografische Daten, HTTP-Code-Aufschlüsselungen, Server-Logs und andere Daten, die du einbeziehen möchtest, abzurufen. Durch die Analyse dieser Daten kann die KI Angriffsversuche (4xx-Codes) oder Verkehrsspitzen aus unerwarteten Regionen erkennen.
Du kannst deine Eingabeaufforderung feinabstimmen, um detailliertere und umfassendere KI-Antworten zu erhalten.
Du kannst die PDF-Vorlage mit den Logos deiner Agentur und deines Kunden anpassen.

Die automatisierte Berichterstattung entlastet dein Team, und die Konsistenz und Präzision, die sie bietet, stärkt das Vertrauen und die Loyalität deiner Kunden.

Du möchtest sofort mit der Automatisierung deiner Kundenberichte beginnen? Melde dich für den Plan an, der am besten zu deinen Bedürfnissen passt, und beginne noch heute mit der Kinsta-API zu arbeiten.

Carlo Daniele Kinsta

Carlo ist ein leidenschaftlicher Liebhaber von Webdesign und Frontend-Entwicklung. Er beschäftigt sich seit über 10 Jahren mit WordPress, auch in Zusammenarbeit mit italienischen und europäischen Universitäten und Bildungseinrichtungen. Er hat Dutzende von Artikeln und Leitfäden über WordPress geschrieben, die sowohl auf italienischen und internationalen Websites als auch in gedruckten Magazinen veröffentlicht wurden. Du kannst Carlo auf X und LinkedIn finden.

Verwalte WordPress-Admin-Benutzer, die sich automatisch anmelden, mit der Kinsta-API

Adapting Social sorgt für 767 % mehr Website-Traffic und spart 250 Stunden

Entdecken

Werkzeuge & Einblicke

Neueste Artikel

Automatisiere Kundenberichte mit Kinsta API und Google AI

Automatisiere Kundenberichte mit Kinsta API und Google AI

Zugriff auf Kinsta Analytics über MyKinsta und Kinsta API

Der Analytics-Endpunkt der Kinsta-API

Besuche

Bandbreite

CDN-Bandbreite

Baue ein automatisiertes Meldesystem mit der Kinsta API und Google AI

Einrichten des Projekts auf GitHub

GEMINI_API_KEY

KINSTA_API-KEY

KINSTA_COMPANY_ID, KINSTA_ENV_ID, KINSTA_SITE_ID

Erforderliche Bibliotheken und GitHub Actions Konfiguration

Programmatische Abfrage der Kinsta-API

Automatisiere den Arbeitsablauf mit Python und Gemini

Abrufen des Artefakts

Die nächsten Schritte: Wie man die Skalierbarkeit verbessert und die Auslieferung automatisiert

Verwalte WordPress-Admin-Benutzer, die sich automatisch anmelden, mit der Kinsta-API

Adapting Social sorgt für 767 % mehr Website-Traffic und spart 250 Stunden

Automatisiere Kundenberichte mit Kinsta API und Google AI

Automatisiere Kundenberichte mit Kinsta API und Google AI

Zugriff auf Kinsta Analytics über MyKinsta und Kinsta API

Der Analytics-Endpunkt der Kinsta-API

Besuche

Bandbreite

CDN-Bandbreite

Baue ein automatisiertes Meldesystem mit der Kinsta API und Google AI

Einrichten des Projekts auf GitHub

GEMINI_API_KEY

KINSTA_API-KEY

KINSTA_COMPANY_ID, KINSTA_ENV_ID, KINSTA_SITE_ID

Erforderliche Bibliotheken und GitHub Actions Konfiguration

Programmatische Abfrage der Kinsta-API

Automatisiere den Arbeitsablauf mit Python und Gemini

Abrufen des Artefakts

Die nächsten Schritte: Wie man die Skalierbarkeit verbessert und die Auslieferung automatisiert

Verwandte Artikel und Themen

Erweiterte WordPress-Automatisierungsworkflows für Agenturen

Leistungsstarkes Hosting für WordPress