Rapporten voor klanten automatiseren met Kinsta API en Google AI

Voor moderne bureaus is een consistent rapportagesysteem van hoge kwaliteit essentieel om het vertrouwen van klanten te behouden en langdurige loyaliteit op te bouwen. Met een duidelijk, informatief rapport kun je verkooptrends bijhouden, de effectiviteit van campagnes aantonen, het rendement op investering (ROI) berekenen en nog veel meer.

Voor een bureau dat tientallen of zelfs honderden sites beheert, kan het genereren van periodieke rapporten echter een groot knelpunt worden dat de schaalbaarheid van je bedrijfsvoering onder druk zet.

Daarom is het optimaliseren en automatiseren van gegevensophaling zo belangrijk. Het herstelt de efficiëntie en maakt je team vrij om zich te richten op activiteiten met hoge waarde, zoals het ontwikkelen van nieuwe projecten.

In dit artikel leer je hoe je de Kinsta API gebruikt om automatisch je hostinggegevens op te halen en strategische rapporten te genereren met behulp van AI.

Klaar om je rapportagesysteem op te schalen? Lees verder.

Toegang tot Kinsta Analytics via MyKinsta en de Kinsta API

Klanten van Kinsta hebben toegang tot een grote hoeveelheid data via het MyKinsta-hostingdashboard. Je vindt je pakketgegevens in het Analytics-gedeelte van je dashboard.

Overzicht van het Analytics-gedeelte in MyKinsta.

De Analytics-pagina is verdeeld in meerdere tabbladen, elk gericht op een specifiek aspect van de activiteit op je site:

Pakketgebruik: Toont het resourcegebruik van je pakket, zowel cumulatief als uitgesplitst per individuele site.
Belangrijkste verzoeken: Hiermee identificeer je de voornaamste verzoeken aan je site, gecategoriseerd op bandbreedte en weergaven.
Cache: Geeft een uitsplitsing van het cachegebruik, inclusief cache-breakdown, servercache-componenten en servercache-omleidingen.
CDN & edge: Biedt gegevens over CDN-bandbreedteverbruik, edge cache-bandbreedte en een overzicht van de meest opgevraagde bestanden vanuit de CDN-cache.
Spreiding: Toont het aandeel bezoeken vanaf desktop, tablet en mobiel.
Prestaties: Bevat diverse prestatiecijfers, zoals de gemiddelde responstijd van PHP + MySQL, PHP-doorvoer, PHP-threadlimiet en meer.
Respons: Geeft statistieken over responscodes, inclusief een gedetailleerde uitsplitsing van foutcodes.
Geo & IP: Toont lijsten met de belangrijkste landen, steden en client-IP’s waarvan verzoeken naar je site afkomstig zijn.

Je hebt toegang tot dezelfde statistieken op siteniveau via Sites > sitenaam > Analytics.

Site analytics in MyKinsta. — Site-analytics in MyKinsta.

Kinsta Analytics biedt een uitgebreide set aan data. Door simpelweg door je MyKinsta-dashboard te navigeren, krijg je een helder beeld van het resourcegebruik, de efficiëntie en de prestaties van je site. Je ziet precies waar de meeste verzoeken vandaan komen en welke de meeste resources verbruiken.

In combinatie met onze Kinsta APM-tool stelt Kinsta Analytics je in staat om de prestaties van je WordPress sites te optimaliseren.

Wat niet iedereen weet: de gegevens uit Kinsta Analytics zijn ook toegankelijk via de Kinsta API. Daarmee kun je gegevens programmatisch ophalen en hostingstatistieken opbouwen, die je vervolgens gebruikt om geautomatiseerde rapporten te genereren om met je klanten te delen.

Laten we de endpoints van de Kinsta API bekijken.

Het Analytics-endpoint van de Kinsta API

Via het Analytics-endpoint van de Kinsta API heb je toegang tot ruwe gegevens over het resourcegebruik en de gezondheid van je website.

Bezoekgebruik, serverbandbreedtegebruik en CDN-bandbreedtegebruik: Deze statistieken volgen je resourcegebruik ten opzichte van je hostingpakket tijdens de huidige factureringsperiode.
Bezoeken: Geeft het totale aantal bezoeken aan een bepaalde omgeving binnen een opgegeven tijdsperiode.
Schijfruimte: Geeft de totale schijfruimte die door een bepaalde omgeving wordt gebruikt gedurende een opgegeven tijdsperiode.
Serverbandbreedte: Geeft de bandbreedte die door een bepaalde omgeving wordt verbruikt gedurende een opgegeven tijdsperiode.
CDN-bandbreedte: Geeft de CDN-bandbreedte die een bepaalde omgeving gedurende een opgegeven tijdsperiode heeft verbruikt.
Belangrijkste landen: Geeft een lijst van de landen waarvan de meeste verzoeken aan de site afkomstig zijn, binnen een opgegeven tijdsperiode.
Belangrijkste steden: Geeft een lijst van de steden waarvan de meeste verzoeken aan de site afkomstig zijn gedurende een opgegeven tijdsperiode.
Belangrijkste client-IP’s: Geeft een lijst van de client-IP-adressen waarvan de meeste verzoeken aan de site afkomstig zijn gedurende een opgegeven tijdsperiode.
Bezoekspreiding: Geeft inzicht in de verdeling van bezoeken over desktop-, tablet- en mobiele apparaten gedurende een opgegeven tijdsperiode.
Response Code Breakdown: Geeft een uitsplitsing van de HTTP-statuscodes die de server heeft geretourneerd binnen een opgegeven tijdsperiode.

Hieronder vind je enkele voorbeelden van het gebruik van het analytics-endpoint.

Bezoeken

Het volgende verzoek geeft het totale aantal bezoeken aan je site en het aantal unieke IP-adressen dat de site de afgelopen 30 dagen heeft bezocht:

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

Het antwoord heeft de volgende structuur:

{
	"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"
						},
						...
					]
				}
			]
		}
	}
}

Bandbreedte

Het volgende voorbeeld laat zien hoe je de Kinsta API bevraagt om het bandbreedtegebruik van de server over de afgelopen 30 dagen op te halen:

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

Het antwoord van de Kinsta-server geeft het dagelijkse bandbreedtegebruik over de afgelopen 30 dagen:

{
	"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-bandbreedte

In dit voorbeeld bevragen we de Kinsta API om het CDN-bandbreedtegebruik over de afgelopen 7 dagen op te halen:

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

De server retourneert de volgende gegevens:

{
	"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"
						},
						...
					]
				}
			]
		}
	}
}

Je kunt dit zelf uitproberen door je Kinsta API-sleutel (bearer token), omgevings-ID en bedrijfs-ID in te voeren in de API playground.

Test de Kinsta API in de API playground.

Nu je weet hoe je toegang krijgt tot de analysegegevens van je site op Kinsta, kun je deze gebruiken om je werkzaamheden te automatiseren, inclusief het rapportagesysteem.

In de volgende secties laten we je zien hoe je het rapportagesysteem van je bureau automatiseert met de Kinsta API. We bouwen een Python-script en gebruiken GitHub Actions om het bouwen en uitvoeren te automatiseren. Het script zet de ruwe API-gegevens om in tabellen en grafieken, en bevraagt Google AI om een eindrapport te genereren.

Tijd om aan de slag te gaan.

Een geautomatiseerd rapportagesysteem bouwen met de Kinsta API en Google AI

Het doel is een geautomatiseerd rapport dat op vaste intervallen wordt gegenereerd. Het systeem bevraagt de Kinsta API om gegevens op te halen over bezoeken, serverbandbreedte en CDN-bandbreedte. Die gegevens worden vervolgens verwerkt tot grafieken en tabellen in een PDF-bestand. Tegelijkertijd worden de gegevens naar de Gemini API gestuurd voor een analyse, die eveneens in het rapport wordt opgenomen.

Voorbeeld van het geautomatiseerde rapport gegenereerd met GitHub Actions en de Kinsta API.

Het project instellen op GitHub

Klik op de GitHub-startpagina op de groene knop New om een nieuw project aan te maken. Zodra je een leeg project hebt, ga je naar Settings > Secrets and variables > Actions en voeg je de secrets toe die in de onderstaande afbeelding worden getoond.

Door je API-sleutels en ID’s op te slaan in GitHub Secrets zijn ze voor niemand toegankelijk en blijft je code veilig.

GEMINI_API_KEY

Je genereert een Google AI API-sleutel in het Google AI Studio-dashboard. Raadpleeg de Google AI-documentatie voor meer informatie.

KINSTA_API-KEY

Volg de instructies in ons artikel om een Kinsta API-sleutel te genereren.

KINSTA_COMPANY_ID, KINSTA_ENV_ID, KINSTA_SITE_ID

Je vindt de site-ID, omgevings-ID en bedrijfs-ID onder Sites > sitenaam > Info in je MyKinsta-dashboard.

Site Information in MyKinsta. — Site-informatie in MyKinsta.

Laten we verdergaan met de projectbestanden.

Benodigde bibliotheken en GitHub Actions-configuratie

Maak in de hoofdmap van je GitHub-project een bestand met de naam requirements.txt en voeg het volgende toe:

google-genai
requests
matplotlib
fpdf2

Dit bestand bevat de benodigde onderdelen voor je project.

google-genai: De bibliotheek van Google voor interactie met Gemini-modellen.
requests: Een bibliotheek voor het uitvoeren van HTTP-verzoeken. In dit project wordt deze gebruikt om verzoeken naar de Kinsta API te sturen.
matplotlib: Een Python-bibliotheek voor het maken van grafieken en het visualiseren van gegevens.
fpdf2: Een bibliotheek waarmee je PDF-bestanden genereert.

Maak vervolgens een bestand aan met de naam .github/workflows/generate_report.yml met de volgende 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 gebruikt dit bestand om je code automatisch uit te voeren via GitHub Actions. Een korte toelichting:

name: Generate Kinsta Analytics Report

on:
  push:
    branches: [main]
  workflow_dispatch:

name: De naam van je project zoals die verschijnt op het tabblad Actions op GitHub.
on: Bepaalt wanneer de workflow wordt geactiveerd.
push: De workflow wordt uitgevoerd elke keer als je een codewijziging naar de main-branch pusht.
workflow_dispatch: Hiermee kun je de workflow handmatig starten.

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

jobs: Het begin van de uit te voeren taken.
build-and-run: Een willekeurige naam die een specifieke reeks acties identificeert.
runs-on: Geeft aan op welk systeem de workflow moet draaien.
ubuntu-latest: Stelt de nieuwste versie van Ubuntu Linux in.

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

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

steps: De volgorde van uit te voeren bewerkingen.
name: De naam van de bewerking.
uses: De vooraf geconfigureerde GitHub-module (Action).

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

python -m pip install --upgrade pip: Werkt pip (de Python-packagemanager) bij naar de nieuwste versie.
pip install -r requirements.txt: Leest het bestand requirements.txt en installeert de daarin vermelde pakketten.

     - 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: Haalt de waarden van omgevingsvariabelen op uit GitHub Secrets.
run: python main.py: Start de Python-interpreter en voert het bestand main.py uit.

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

uses: actions/upload-artifact@v4: Gebruikt de GitHub Action voor het beheren van artifacts — bestanden of mappen die worden gegenereerd terwijl het script draait.
with: Stelt de configuratieparameters in.

De configuratie van je automatiseringsproject is klaar. Nu is het tijd om de Python-scripts te maken.

De Kinsta API programmatisch bevragen

Zodra de installatie is voltooid, navigeer je naar de hoofdmap van je GitHub-project en maak je een nieuw bestand aan met de naam kinsta_utils.py met de volgende 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}"}

De eerste twee import statements laden de standaardbibliotheek voor HTTP-verzoeken en de module voor interactie met het besturingssysteem (os).
De volgende vier regels (os.getenv) halen je credentials op uit GitHub Secrets.
BASE_URL definieert het hoofdendpoint van de Kinsta API dat door het script wordt gebruikt.
De functie get_headers genereert de autorisatieheader met daarin de Kinsta API-sleutel.

Maak vervolgens een helperfunctie die de ruwe gegevens van de API omzet naar megabytes.

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

Deze code biedt twee opties. De eerste gebruikt de binaire standaard (1024 x 1024), de tweede de decimale standaard. Delen door 1_000_000 zorgt ervoor dat het getal in je PDF-rapport overeenkomt met wat je klanten zien in MyKinsta Analytics.

De volgende functie bevraagt de Kinsta API en retourneert een set ruwe gegevens:

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, []

De functie fetch_kinsta_metric accepteert drie argumenten: endpoint, start_date en end_date. Deze worden gebruikt om de verzoek-URL samen te stellen. Het endpoint kan visits, bandwidth of cdn-bandwidth zijn.
De array params slaat de verzoekparameters op.
Het antwoord van Kinsta is een genest JSON-object (data_node) dat de geaggregeerde waarden voor de periode (total) en een lijst met dagelijkse waarden (dataset) bevat.

De laatste functie in het bestand kinsta_utils.py haalt de sitenaam op.

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"

Deze code spreekt voor zich. Raadpleeg de API-referentie voor details over het sites endpoint.

Nu hoeven we alleen nog de workflow in te stellen.

De workflow automatiseren met Python en Gemini

Het laatste bestand dat je aanmaakt is de engine van je applicatie. Maak in de hoofdmap van je GitHub-project een bestand main.py aan. Voeg om te beginnen de volgende code toe:

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)]

Dit is hoe het script is opgebouwd:

De import statements laden de benodigde bibliotheken. matplotlib.use('Agg') instrueert Python om de plots in het geheugen te genereren zonder een scherm nodig te hebben.
Het volgende blok stelt de taal (en) en het model (gemini-2.5-flash) in en initialiseert de Google-client.
Vervolgens worden tijdvensters gedefinieerd om de waarden van de afgelopen zeven dagen te vergelijken met die van de zeven dagen daarvoor.
Tot slot worden de labels voor tabellen en grafieken ingesteld.

De volgende stap is het definiëren van een klasse KinstaReport voor het genereren van rapportpagina’s met de FPDF-bibliotheek:

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)

We gaan niet te diep in op deze code. Voor meer informatie over de FPDF-bibliotheek kun je de online documentatie raadplegen:

Definieer vervolgens een functie generate_chart. Deze functie zet de ruwe gegevens van Kinsta om in grafieken.

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()

Deze functie gebruikt de Matplotlib-bibliotheek om de gegevens uit Kinsta om te zetten in grafieken voor het PDF-rapport. Meer informatie over Matplotlib vind je in de online documentatie:

Voeg tot slot de functie toe die alle onderdelen samenvoegt.

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()

Dit doet deze code:

De for loop itereert door de array metrics en bevraagt de Kinsta API twee keer: één keer voor de huidige week en één keer voor de vorige week.
Als de gegevens betrekking hebben op bandbreedte, zet de functie format_bytes_to_mb() de ruwe gegevens om naar MB.
De functie report_data() slaat de opgehaalde gegevens op.
KinstaReport maakt vervolgens een PDF aan voor elke site.
De volgende for loop genereert PNG-afbeeldingen voor de grafieken en maakt een nieuwe pagina aan voor elke metric.
Het volgende deel genereert de samenvatting: het berekent het totale aantal bezoeken en het totale aantal megabytes voor de periode, en stuurt een dynamische prompt naar Gemini 2.5 Flash. Het antwoord wordt gebruikt om de laatste pagina van de PDF te vullen.
Het script slaat het document op met een bestandsnaam die de huidige datum bevat.
De laatste voorwaarde zorgt ervoor dat het proces alleen wordt uitgevoerd als het script als hoofdprogramma wordt gestart.

Tijd om je applicatie te bouwen en uit te voeren.

Het artifact ophalen

Je kunt je applicatie nu uitvoeren. Ga naar je GitHub-projectpagina en klik op het tabblad Actions. Zoek de naam van je action in het menu aan de linkerkant (in ons voorbeeld is dat Generate Kinsta Analytics Report, zoals opgegeven in je bestand generate_report.yml).

Het tabblad Actions toont een lijst met workflows.

Klik vervolgens op het menu Run workflow aan de rechterkant en daarna op de groene knop Run workflow (momenteel is alleen de main-branch beschikbaar).

De volgende pagina toont de actieve workflow. Klik erop om de lijst met lopende bewerkingen te bekijken.

De sectie Run Report Script toont een overzicht van de uitgevoerde bewerkingen, terwijl de sectie Upload Report de download-URL voor het artifact geeft. Klik op deze link om je rapport als PDF te downloaden.

De sectie Upload Report geeft de link naar het PDF-rapport.

Dezelfde link vind je ook in de sectie Artifacts, onderaan de Summary pagina van de workflow.

De acties Run Report Script en Upload Report.

De onderstaande afbeeldingen tonen het volledige rapport, inclusief de Executive Summary gegenereerd door Google AI.

Rapportpagina's Sitebezoeken en Serverbandbreedte. — Rapportpagina’s Site Visits en Server Bandwidth.

Rapportpagina's CDN-bandbreedte en Executive Summary. — Rapportpagina’s CDN Bandwidth en Executive Summary.

Volgende stappen: schaalbaarheid verbeteren en levering automatiseren

Dit is slechts een voorproefje van wat de Kinsta API kan doen in combinatie met automatiseringstools zoals GitHub Actions. Met AI-integratie ga je een stap verder: ruwe cijfers worden omgezet in diepgaande rapporten die direct deelbaar zijn met je klanten.

Je kunt je rapportage op verschillende manieren verder uitbreiden:

Voeg een regel toe aan het YAML-bestand (schedule: '0 9 * * 1') om het rapport elke maandagochtend om 9:00 uur automatisch te genereren.
Integreer een bibliotheek zoals smtplib of een service zoals SendGrid om het rapport rechtstreeks naar je klant te sturen.
Beheer je als bureau tientallen of honderden sites, dan kun je een lus implementeren die door een lijst met site-ID’s itereert en alle rapporten in één keer genereert.
Verrijk de inhoud van je rapport door via de Kinsta API ook geografische gegevens, HTTP-code-uitsplitsingen, serverlogs en andere relevante gegevens op te halen. Op basis van die gegevens kan AI aanvalspogingen (4xx-codes) of verkeerspieken uit onverwachte regio’s signaleren.
Verfijn je prompt om meer gedetailleerde en uitgebreide AI-analyses te krijgen.
Pas de PDF-template aan met de logo’s van je bureau en je klant.

Geautomatiseerde rapportage vermindert de werkdruk van je team. De consistentie en nauwkeurigheid die het oplevert, versterken het vertrouwen en de loyaliteit van je klanten.

Klaar om je klantrapportage te automatiseren? Kies het pakket dat het beste bij je past en begin vandaag nog met bouwen met de Kinsta API.

Carlo Daniele Kinsta

Carlo is een gepassioneerd liefhebber van webdesign en front-end development. Hij werkt al meer dan 10 jaar met WordPress, ook in samenwerking met Italiaanse en Europese universiteiten en onderwijsinstellingen. Hij heeft tientallen artikelen en gidsen over WordPress geschreven, gepubliceerd op zowel Italiaanse als internationale websites en in gedrukte tijdschriften. Je kunt Carlo vinden op X en LinkedIn.

Beheer WordPress Admin auto-login gebruikers met de Kinsta API

Wholegrain Digital brengt zijn duurzaamheidsmissie tot leven met krachtige sites op Kinsta

Verken

Tools en inzichten

Nieuwste artikelen