Erste Schritte mit Code

Übersicht

Erfahre mehr über Code und wie du benutzerdefinierte Funktionen erstellst, die direkt von Klaviyo ausgeführt werden.

Code erfordert eine individuelle Entwicklung, und das Support-Team von Klaviyo kann keine praktische Unterstützung leisten. Wenn du keine Entwickler*innen in deinem Team hast und dir nicht zutraust, selbst Code zu schreiben, wende dich für Unterstützung am besten an einen Klaviyo Partner.

Bevor du anfängst

Was ist Code?

Mit Code kannst du benutzerdefinierte Funktionen als Reaktion auf in Klaviyo erfasste Ereignisse ausführen. Du kannst deine eigenen Javascript- oder Python-Funktionen im Code-Editor schreiben, und sie werden dann direkt auf der Plattform ausgeführt.

Mit Code kannst du Daten an deine externen Systeme senden, ohne einen öffentlichen HTTP-Endpunkt für den Empfang von Webhooks einrichten zu müssen. Zudem kannst du benutzerdefinierte Funktionen programmieren, die durch bestimmte Ereignisse ausgelöst werden. Dabei kannst du auch auf viele beliebte vorgefertigte Module zugreifen, die dir die Erstellung individueller Lösungen erleichtern.

Themen

Mit Code kannst du benutzerdefinierte Funktionen als Reaktion auf jedes Ereignis ausführen, das über die Get Events API abgefragt werden kann.

Dazu gehören:

• E-Mail-Ereignisse (z. B. Auf E-Mail geklickt, E-Mail als Spam markiert )
• SMS-Ereignisse (z. B. Gesendete SMS, Empfangene SMS)
• Ereignisse für Push-Benachrichtigungen (z. B. Push empfangen, Push zurückgewiesen)
• Ereignisse aus Integrationen (d. h. Ereignisse aus von Klaviyo erstellten First-Party-Integrationen)
• API-Ereignisse (d. h. Ereignisse, die über Klaviyo APIs synchronisiert werden)

Schnittstelle für Code

Um auf Code zuzugreifen, navigiere zum Tab Code unter Advanced Klaviyo Data Platform > Datenmanagement > Code.

Um eine benutzerdefinierte Funktion zu erstellen, wähle die Schaltfläche Funktion erstellen aus:

Du wirst zur Seite Recipes weitergeleitet, wo du entweder eine vorgefertigte Lösung auswählen kannst, die du ausführen möchtest, oder eine leere Python- oder Node.js-Funktion.

Wenn du ein bestehendes Rezept auswählst, siehst du den Code-Editor mit dem Code für die Lösung sowie eine Beschreibung der Funktionalität.

Wenn du eine leere Funktion auswählst, um deine eigenen benutzerdefinierten Lösungen zu erstellen, wird das Modal Details angezeigt, in dem du Folgendes tun kannst:

• Funktion benennen
  Ein Name, um deine Funktion zu identifizieren.
• Wähle ein Thema für deine Funktion aus
  Das Ereignis, das die Ausführung deines Codes auslöst.
• Wähle eine Runtime aus
  Die Runtime-Umgebung, in der der Code ausgeführt wird (z. B. Python oder Node.js).

Nachdem du die erforderlichen Auswahlen getroffen und die Schaltfläche Create function ausgewählt hast, gelangst du zu einer Oberfläche mit den folgenden Tabs:

• Editor
• Testausgabe
• Protokolle

Berechtigungen erteilen

Wenn du zum ersten Mal eine Funktion über Code erstellst, wirst du aufgefordert, die Code-OAuth-Anwendung zu authentifizieren. Dies ist erforderlich, damit deine Code-Funktionen auf Daten in deinem Klaviyo-Konto zugreifen können.

Nachdem du den Zugriff gewährt hast, wirst du zum Code-Editor weitergeleitet.

Editor

Auf der Seite Editor in Code siehst du die Seite in 3 Tabs als Split:

• Code
  Der Tab „Code“ enthält einen Editor, in dem du Python- oder Javascript-Funktionen schreiben kannst.
• Module
  Module sind Pakete von Drittanbietern, die deine Funktionen um zusätzliche Funktionen erweitern.
• Umgebungsvariablen
  Umgebungsvariablen sind die Schlüssel-Wert-Paare, auf die deine Funktion bei der Ausführung zugreift.

Code

Im Tab Code siehst du einen Editor, den du verwenden kannst, um Python- oder Javascript-Funktionen zu schreiben, die als Reaktion auf das ausgewählte Thema ausgeführt werden.

Parameter der Handler-Funktion

Damit Klaviyo den Code ausführen kann, den du schreibst, muss er in eine Funktion namens „handler“ eingebettet sein, die 2 Parameter akzeptiert:

• Ereignis
  Besteht aus den Ereignisdaten, die dem auslösenden Ereignis im JSON:API-Format zugeordnet sind. Wenn der Trigger nicht ereignisbasiert ist (z. B. Zur Liste hinzugefügt), lautet der Wert dieses Parameters je nach Sprache None oder Null.
• Kontext
  Enthält zusätzliche Metadaten zur Funktionsausführung, einschließlich des Profils, das mit der Funktionsauslösung verknüpft ist. Du kannst über context.profile in Javascript oder context["profile"] in Python auf das Profilobjekt zugreifen.

Unten findest du Beispiele für die Ereignis- und Kontextparameter, die an die Handler-Funktion übergeben werden.

Beispielformat für Ereignisse

{
    {
  "data": {
    "type": "event",
    "id": "7S2q9haejYG",
    "attributes": {
      "timestamp": 1694435729,
      "event_properties": {
        "MfaEnabled": false,
        "IpAddress": "000.00.0.0",
        "UserAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
        "UserRole": "Owner",
        "SessionId": "34sh0a9nh8ngnk2nfacjxmt592yx40ib",
        "LoginType": "Username_password",
        "current_company_id": "XXXXX",
        "$event_id": "1694435729"
      },
      "datetime": "2023-09-11 12:35:29+00:00",
      "uuid": "b0b8fe80-509f-11ee-8001-278cc529fcd3"
    },
    "relationships": {
      "profile": {
        "data": {
          "type": "profile",
          "id": "123456"
        },
        "links": {
          "self": "https://a.klaviyo.com/api/events/7S2q9haejYG/relationships/profile/",
          "related": "https://a.klaviyo.com/api/events/7S2q9haejYG/profile/"
        }
      },
      "metric": {
        "data": {
          "type": "metric",
          "id": "4Tdup6"
        },
        "links": {
          "self": "https://a.klaviyo.com/api/events/7S2q9haejYG/relationships/metric/",
          "related": "https://a.klaviyo.com/api/events/7S2q9haejYG/metric/"
        }
      }
    },
    "links": {
      "self": "https://a.klaviyo.com/api/events/7S2q9haejYG/"
    }
  }
}

Beispiel-Kontextformat

{
    "company_id": "XXXXX",
    "trigger": {"type": "event", "uid": "123456"},
    "function_id": "123456",
}

Module

Im Tab Module kannst du aus den beliebtesten vorgefertigten Modulen auswählen (d. h. Pakete von Drittanbieter*innen, die deinen Funktionen zusätzliche Funktionen hinzufügen).

Um ein externes Modul hinzuzufügen, das du in deinem Code verwenden möchtest, wähle die Schaltfläche Modul hinzufügen aus:

In dem angezeigten Modal kannst du nach dem Modul suchen und es auswählen, das du hinzufügen möchtest:

Sobald das Modul hinzugefügt wurde, kannst du es mit dem Code verwenden, den du in Klaviyo schreibst.

from klaviyo_api import KlaviyoAPIimport osdef handler(event, context):  klaviyo = KlaviyoAPI(api_key=os.getenv("KLAVIYO_API_KEY"))  print(klaviyo.Metrics.get_metrics())

import klaviyodef handler(event, context):  print(klaviyo.Metrics.get_metrics())

import { Metrics } from 'klaviyo';export default async (event, context) => {  console.log(await Metrics.getMetrics())}

Umgebungsvariablen

Über den Tab Umgebungsvariablen kannst du Schlüssel-Wert-Paare festlegen, auf die dein Code in Klaviyo beim Ausführen verweisen kann. Diese können verwendet werden, um Informationen wie Zugangsdaten und geheime Schlüssel zu speichern, damit deine Funktionen beim Ausführen darauf zugreifen können.

Um eine Umgebungsvariable hinzuzufügen, wähle die Schaltfläche Variable hinzufügen:

Im angezeigten Modal kannst du ein Schlüssel-Wert-Paar für deine Umgebungsvariable festlegen.

Nach dem Erstellen werden die Umgebungsvariablen auf der Seite aufgeführt und können in deinem Code verwendet werden.

Testausgabe

Auf dem Tab Testausgabe in Code kannst du deinen Code mit aktuellen Ereignissen testen, um zu bestätigen, dass sich die Ausgabe wie erwartet verhält.

So testest du deine Funktion:

1. Wähle die Schaltfläche Test ausführen aus:
   

2. Wähle im angezeigten Modal ein Event aus, mit dem getestet werden soll. Es kann aus den 10 neuesten in Klaviyo erfassten Events ausgewählt werden.
   

3. Nachdem du ein Ereignis zum Testen ausgewählt hast, wird die Testausgabe angezeigt:

Protokolle

Der Tab Logs zeigt den Zustand deiner laufenden Code-Funktionen. Du siehst:

• Status
  Der Fortschritt der Ausführung einer Funktion.
• Antwortzeit
  Die Zeit, die dein Code benötigt, um als Reaktion auf ein Ereignis ausgeführt zu werden.
• Datum
  Ein Zeitstempel für den Zeitpunkt, an dem die Funktion ausgeführt wurde.

Ratenlimits

Der Klaviyo-Code hat die folgenden Rate-Limits:

• Funktions-Timeout
  Funktionen in Code können bis zu 15 Sekunden lang ausgeführt werden, bevor ein Timeout erfolgt.
• Funktionsratenlimit
  Funktionen in Code erlauben bis zu 25 gleichzeitige Ausführungen pro Funktion.

Code bereitstellen

Um den Code bereitzustellen, den du im Editor schreibst, stell im Status-Dropdown auf Live um.

Sobald es live ist, wird der von dir geschriebene Code jedes Mal ausgeführt, wenn das Topic-Event in Klaviyo erfasst wird.

Beispiellösung

Unten ist ein Beispiel für eine benutzerdefinierte Lösung, die mit Code implementiert wird.

Im Beispiel werden Ereignisdaten als Profileigenschaften festgelegt, damit sie in zielgerichteten E-Mails und in der Segmentierung verwendet werden können. Das benutzerdefinierte Event Booked shoot wird in Klaviyo erfasst, wenn Kund*innen ein Shooting bei der Marke buchen, und Daten zur Buchungsstadt und zur zugehörigen URL werden als Profileigenschaften im jeweiligen Profil festgelegt.

Außerdem wird eine Eigenschaft namens Recent bookings erstellt, die Daten aus den 5 neuesten Booked shoot -Ereignissen speichert, damit diese in einer E-Mail-Vorlage in einer Schleife durchlaufen und abgerufen werden können.

Code

Der Python-Code für diese Lösung wird im Code-Editor geschrieben und direkt von Klaviyo ausgeführt.

Beispielcode

Module

In diesem Beispiel wird das integrierte Klaviyo -Modul verwendet. Das Klaviyo -Modul setzt voraus, dass das Klaviyo-API -Modul zur Funktion hinzugefügt wird. Nach dem Hinzufügen übernimmt das Klaviyo -Modul die Authentifizierung für dich, sodass kein API-Schlüssel erforderlich ist.

Umgebungsvariablen

Umgebungsvariablen können verwendet werden, um Informationen wie Zugangsdaten und geheime Schlüssel zu speichern, damit deine Funktionen beim Ausführen darauf zugreifen können. Für dieses Beispiel wird das folgende Schlüssel-Wert-Paar festgelegt:

• MAX_PROPERTIES_TO_STORE
  Eine Umgebungsvariable, die verwendet wird, um die maximale Anzahl von Eigenschaften zu definieren, die für die Beispielfunktion gespeichert werden.

Testen

Beim Erstellen der Funktion zum Festlegen von Ereignisdaten als Profileigenschaften wird der Tab Test output verwendet, um die erwartete Ausgabe zu überprüfen.

Protokolle

Sobald die Funktion erstellt und getestet wurde, zeigt der Tab Logs den Integritätsstatus der Funktion an, während sie als Reaktion auf Booked shoot -Events ausgeführt wird.

Ergebnis

Wenn diese Code-Funktion eingerichtet ist, werden die Ereignisdaten, sobald Kund*innen sich für Shootings anmelden und das benutzerdefinierte Ereignis Booked shoot auslösen, im Kund*innenprofil gespeichert, damit sie für Segmentierung und gezielte Kampagnen verwendet werden können.

Rezepte implementieren 

Mit Rezepten in Code kannst du vorgefertigte Lösungen implementieren, ohne dass eine individuelle Entwicklung erforderlich ist.

So implementierst du ein Recipe in deinem Klaviyo-Konto:

1. Wähle auf der Seite „Code“ die Schaltfläche Funktion erstellen aus.
2. Wähle das Rezept aus, das du in deinem Konto implementieren möchtest. Du wirst zum Editor weitergeleitet, in dem du den Code für das ausgewählte Recipe sowie eine Beschreibung dessen sehen kannst, was die Funktion macht.
3. Klicke auf die Schaltfläche Auswählen, um fortzufahren.
   

4. Wähle einen Namen für die Funktion und den Trigger aus, der ihre Ausführung veranlassen wird. Die Laufzeit wird automatisch basierend auf dem Code für das Recipe festgelegt.
5. Wähle die Schaltfläche Funktion erstellen aus.
6. Sobald die Funktion erstellt wurde, lege die entsprechenden Umgebungsvariablen fest, damit die Funktion die Daten hat, die sie zum Ausführen benötigt.
7. Das Rezept kann jetzt getestet und auf Live gesetzt werden.