Die Anmeldung ist schnell erledigt, nach der Angabe von Name, E-Mail und Kennwort brauchen wir nur noch den Bestätigungslink in der danach zugesendeten E-Mail zu betätigen (siehe Bild 1).<\/p>\n
![\"Erstellen](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_002.png\")
<\/p>\n
Bild 1: Erstellen eines Make.com-Kontos<\/span><\/b><\/p>\n Automationen bestehen immer aus mindestens einem Trigger und einer Aktion. Der Trigger ist ein Element, das die Automation auslöst.<\/p>\n Meistens stammt der Trigger aus einer der Web-Anwendungen, die wir automatisieren wollen. Beispiele:<\/p>\n In unserem Fall wollen wir den Trigger per VBA auslösen. Dafür findet sich logischerweise kein vorbereiteter Trigger, denn wir können VBA nicht so von Make.com aus referenzieren, dass wir dort auf ein Ereignis lauschen könnten, wie wir es mit einer Ereignisprozedur innerhalb eines VBA-Klassenmoduls tun.<\/p>\n Stattdessen nutzen wir einen speziellen Trigger namens Webhook. Das funktioniert so:<\/p>\n Make.com <\/b>stellt uns eine bestimmten URL zur Verfügung, die wir per VBA aufrufen. Die URL ist einzigartig und nur uns bekannt, nachdem wir den Webhook-Trigger angelegt haben.<\/p>\n Diese URL rufen wir per VBA mit Unterstützung der Methoden der XMLHTTP60<\/b>-Klasse auf.<\/p>\n Mit dieser können wir alle notwendigen Informationen übergeben und auch das Ergebnis verarbeiten.<\/p>\n Im Gegensatz zu Zapier bietet Make.com <\/b>auch eine Aktion an, mit der wir das Ergebnis der Automationen an die Instanz zurückgeben können, die den Webhook aufgerufen hat. Neben den vielen anderen Aktionen, die wir durchführen können, finden wir also auch eine namens Webhook response<\/b>. Diese soll im folgenden grundlegenden Beispiel auch die einzige Aktion sein, die wir in unserem Basisworkflow nutzen wollen.<\/p>\n Was unter Zapier Zap <\/b>genannt wird, heißt unter Make.com Scenario<\/b>. Von der Startseite können wir entweder direkt auf Create a new scenario <\/b>klicken oder wir klicken links auf Scenarios<\/b>, um die Übersicht aller bisher erstellten Automationen einzusehen (siehe Bild 2). Auch dort finden wir wieder die Schaltfläche Create a new scenario<\/b>.<\/p>\n Bild 2: Anlegen eines neuen Scenarios<\/span><\/b><\/p>\n Damit landen wir im Scenario-Designer. Hier sehen wir ein großes Plus-Icon und ein Menü mit der Übersicht der verfügbaren Trigger (siehe Bild 3).<\/p>\n Bild 3: Ein noch leeres neues Scenario<\/span><\/b><\/p>\n Es lohnt sich, einmal durch die Liste zu scrollen und sich anzuschauen, durch welche Anwendungen eine solche Automation gestartet werden kann.<\/p>\n Klicken wir auf einen der Einträge, erscheint eine weitere Liste mit allen Ereignissen, die durch diese Anwendungen ausgelöst werden können. Im Falle von Google Sheets<\/b> sind das beispielsweise neu hinzugefügte Zeilen oder geänderte Zeilen (siehe Bild 4).<\/p>\n Bild 4: Betrachten der verschiedenen Trigger einer Anwendung<\/span><\/b><\/p>\n Wir wollen jedoch keine externe Anwendung als Trigger nutzen, sondern den Trigger per VBA von unserem VBA-Projekt aus auslösen.<\/p>\n Dazu kehren wir zur Hauptliste der Anwendungen zurück, die Trigger auslösen können, und klicken hier auf den Eintrag Webhook<\/b>.<\/p>\n Dies liefert die drei Elemente aus Bild 5, wobei die ersten beiden Trigger sind und die dritte eine Aktion. Die beiden Trigger funktionieren wie folgt:<\/p>\n Bild 5: Hinzufügen eines Triggers namens Custom webhook<\/span><\/b><\/p>\n Die Aktion Webhook response <\/b>stellt die entscheidende Besonderheit von Make.com <\/b>gegenüber Zapier dar: Darin finden wir eine Möglichkeit, das Ergebnis einer durch einen Webhook aufgerufenen Automation auch wieder an die aufrufende Instanz zurückzugeben.<\/p>\n Um den Trigger anzulegen, klicken wir auf Custom webhook<\/b>.<\/p>\n Dies öffnet ein Popup, indem wir einen bestehenden Webhook auswählen oder einen neuen anlegen können (siehe Bild 6).<\/p>\n Bild 6: Anlegen und Konfigurieren des Webhooks<\/span><\/b><\/p>\n Wir benötigen hier einen neuen Hook und klicken auf die Schaltfläche Add<\/b>.<\/p>\n Nun erscheint der Dialog Create a webhook<\/b>, in dem wir den Namen für unseren Webhook eintragen – in diesem Fall Beispielwebhook<\/b> (siehe Bild 7).<\/p>\n Bild 7: Einstellen des Namens für den Webhook<\/span><\/b><\/p>\n Danach enthält der Webhook weitere Informationen, zum Beispiel eine URL (siehe Bild 8). Diese kopieren wir mit einem Klick auf Copy address to clipboard <\/b>in die Zwischenablage.<\/p>\n Bild 8: Details des Webhooks<\/span><\/b><\/p>\n An der Schaltfläche Stop <\/b>erkennen wir, dass der Webhook bereits aktiv ist und auf Aufrufe wartet.<\/p>\n Damit können wir den Webhook nun bereits testen – ohne größeren Aufwand wie beispielsweise eine VBA-Prozedur. Wir fügen die Adresse einfach in einen Browser ein und rufen diese auf. Das Ergebnis ist der Text Accepted<\/b> (siehe Bild 9). Das sieht sehr gut aus – der Aufruf funktioniert.<\/p>\n Bild 9: Aufruf des Webhooks über den Webbrowser<\/span><\/b><\/p>\n Damit wollen wir den Webhook nun speichern und klicken dazu auf die Schaltfläche Save<\/b>.<\/p>\n Damit kommen wir zum zweiten Schritt unseres Beispiels. Hier wollen wir nun die Antwort Accepted <\/b>durch eine benutzerdefinierte Antwort ersetzen. Dazu fügen wir eine Aktion hinzu, indem wir auf die kleine Plus<\/b>-Schaltfläche rechts von unserem Trigger klicken.<\/p>\n Dies öffnet die gleiche Auswahl wie zuvor (siehe Bild 10). Klicken wir hier erneut auf Webhooks<\/b>, finden wir lediglich noch den Eintrag Webhook response <\/b>vor. Logisch, denn wir können an dieser Stelle keinen weiteren Trigger hinzufügen – wir benötigen eine Aktion. Also wählen wir Webhook response <\/b>aus.<\/p>\n Bild 10: Hinzufügen einer Aktion zum Workflow<\/span><\/b><\/p>\n Dies fügt das Element Webhook response <\/b>hinzu und zeigt gleich seine Eigenschaften an (siehe Bild 11).<\/p>\n Bild 11: Die neue Aktion im Scenario<\/span><\/b><\/p>\n Wenn wir das Feld Body <\/b>anklicken, erscheint ein weiteres Popup.<\/p>\n Hier sehen wir zum Beispiel die Variable executionId<\/b>, welche eine ID für die aktuelle Ausführung der Automation enthält (siehe Bild 12).<\/p>\n Bild 12: Verfügbare Elemente für die Antwort<\/span><\/b><\/p>\n Wir tragen testweise einfach einmal den Text Benutzerdefinierte Antwort<\/b>, gefolgt von der Variablen executeId <\/b>in das Feld Body <\/b>ein. executeId <\/b>ziehen wir dazu per Drag and Drop aus der Liste in das Feld Body<\/b>, sodass wir das Ergebnis aus Bild 13 erhalten.<\/p>\n Bild 13: Hinzufüge nder executionId<\/span><\/b><\/p>\n Mit einem Klick auf die Schaltfläche Save <\/b>speichern wir das neue Element.<\/p>\n Nun lauscht der Webhook allerdings nicht mehr auf unsere Anfragen, sodass wir im Browser zunächst diese Antwort erhalten:<\/p>\n Deshalb klicken wir nun auf die Schaltfläche Run once<\/b> (siehe Bild 14). Die Schaltfläche wandelt sich in eine Stop<\/b>-Schaltfläche um und die Automation lauscht wieder auf Aufrufe.<\/p>\n Bild 14: Starten der Automation<\/span><\/b><\/p>\n Rufen wir die URL des Webhooks nun erneut im Browser auf, erhalten wir das Ergebnis aus Bild 15. Die Rückgabe einer individuell in der Automation festgelegten Antwort funktioniert also.<\/p>\n Bild 15: Erfolgreicher Test der Automation<\/span><\/b><\/p>\n Damit haben wir das Grundgerüst geschaffen. Wir werden uns nun ansehen, wie wir die Automation per VBA starten können. Das Ziel ist es, die Automation zu starten und das Ergebnis, dass wir nun im Browser erhalten haben, per VBA auszulesen und zu verarbeiten.<\/p>\n Um die Automation per VBA zu starten und das Ergebnis zu erhalten, benötigen wir ein VBA-Projekt, für das wir in diesem Fall eine Microsoft Access-Datenbank nutzen. Wir könnten die nachfolgend beschriebenen Techniken jedoch auch im VBA-Projekt von Excel, Word, Outlook et cetera nutzen.<\/p>\n Dem VBA-Projekt fügen wir zwei Verweise hinzu (siehe Bild 16):<\/p>\n Bild 16: Verweise für unser VBA-Projekt<\/span><\/b><\/p>\n Danach fügen wir ein neues, leeres Modul hinzu und geben dort den Code aus Listing 1 ein. In dieser Prozedur tragen wir die URL des Webhooks für die Variable strWebhookURL <\/b>ein. Außerdem verwenden wir eine Variable namens strJSON <\/b>mit einer leeren Zeichenkette. Diese dient erst einmal der Vorbereitung – wir werden diese in einem weiteren Beispiel noch füllen. Danach erstellen wir ein neues Objekt des Typs MSXML2.XMLHTTP60<\/b>.<\/p>\n Listing 1: Testaufruf des Webhooks<\/span><\/b><\/p>\n Für dieses führen wir die Methode Open <\/b>aus und übergeben als Parameter die Werte GET <\/b>als Methode, die URL sowie den Wert False<\/b>, um anzugeben, dass wir auf das Ergebnis des Aufrufs warten wollen.<\/p>\n Anderenfalls können wir das Ergebnis nicht verarbeiten.<\/p>\n Außerdem übergeben wir noch einen Header, mit dem wir als Format der zu sendenden Daten als application\/json <\/b>angeben.<\/p>\n Schließlich führen wir den Aufruf mit der send<\/b>-Methode aus und übergeben dabei die in diesem Beispiel noch leere Zeichenkette aus strJSON<\/b>.<\/p>\n Liefert der Aufruf den Wert 200 <\/b>für die Eigenschaft status <\/b>zurück, war der Aufruf erfolgreich und wir geben den Wert der Eigenschaft responseText <\/b>in einer Meldung aus.<\/p>\n Im Fehlerfall, also wenn status <\/b>einen anderen Wert liefert, geben wir die Werte der Eigenschaften status <\/b>und statusText <\/b>aus.<\/p>\n Dies können wir simulieren, indem wir beispielsweise der URL ein Zeichen hinzufügen, sodass diese nicht mehr vorhanden ist und erhalten als Status den Wert 404<\/b>.<\/p>\n Führen wir die Prozedur nun ohne Weiteres aus, erhalten wir als Ergebnis im Meldungsfenster allerdings den Text Accepted <\/b>– also nicht den erwarteten Text.<\/p>\n Das liegt daran, dass wir die Automation erst wieder aktivieren müssen, indem wir erneut auf Run once <\/b>klicken und im nachfolgend erscheinenden Popup den Button Wait for new data <\/b>betätigen (siehe Bild 17).<\/p>\n Bild 17: Erneutes Aktivieren der Automation<\/span><\/b><\/p>\n Damit erhalten wir nun auch das erwartete Ergebnis (siehe Bild 18).<\/p>\n Bild 18: Ergebnis des erneuten Aufrufs<\/span><\/b><\/p>\n Dies ist eine wichtige Beobachtung: Die Automation liefert also im Erfolgsfall immer den Wert 200<\/b>, auch wenn die Automation gerade nicht läuft. Das wollen wir im Code noch differenzieren, indem wir für die echte Antwort einen anderen Statuscode definieren.<\/p>\n Dazu klicken wir in Make.com <\/b>erneut auf die Aktion und geben für Status <\/b>den Wert 201 <\/b>ein (siehe Bild 19).<\/p>\n Bild 19: Definieren eines eigenen Statuswertes<\/span><\/b><\/p>\n Entsprechend passen wir auch die Bedingung an, mit der wir den Status untersuchen. Wir wandeln diese in ein Select Case<\/b>-Statement um und fügen sowohl für 201<\/b> als auch für 200 <\/b>eigene Case<\/b>-Zweige hinzu:<\/p>\n Um die Automation dauerhaft zu aktivieren, aktivieren wir unten die Option Immediately as data arrives<\/b>.<\/p>\n Dies öffnet ein Popup, in dem wir auswählen können, wie regelmäßig abgefragt werden soll, ob neue Aufrufe der URL eingegangen sind.<\/p>\n Welchen Wert wir wählen, hängt vom Anwendungszweck ab.<\/p>\n Wenn wir durch unseren Aufruf einfach nur eine Aktion triggern wollen, die irgendwann in nächster Zeit ausgeführt werden soll, können wir einen der Werte At regular intervals<\/b>, Every day<\/b>, Days of week<\/b>, Days of month <\/b>oder Specified days <\/b>einstellen.<\/p>\n Wenn wir jedoch einen Aufruf durchführen, der eine Aktion ausführt, von der wir Rückgabewerte erwarten, sollten wir hier Immediately <\/b>einstellen. Nur so lauscht die Automation ständig auf eingehende Aufrufe der URL (siehe Bild 20).<\/p>\n Bild 20: Dauerhaftes Aktivieren der Automation<\/span><\/b><\/p>\n Danach rufen wir zwei Mal unsere VBA-Prozedur auf und erhalten jeweils die Meldung mit dem Status 201 und unterschiedlichen Werten für den Rückgabewert.<\/p>\n Die Automation ist also nun ständig bereits für Aufrufe.<\/p>\n Weiter oben haben wir bereits über die Variable strJSON <\/b>gesprochen, die aktuell noch mit einer leeren Zeichenkette gefüllt übergeben wird. Je nachdem, welche Aufgaben wir zwischen unseren Trigger und die Response-Aktion schieben, benötigen wir dazu weitere Daten.<\/p>\n Ein Beispiel dazu stellen wir im Artikel Google Mail mit Make.com und VBA statt Outlook <\/b>(www.vbentwickler.de\/464<\/b>) vor, wo wir zeigen, wie wir über VBA und Make.com <\/b>E-Mails über Google Mail verschicken können. Hier müssen wir beispielsweise Daten wie Empfänger, Betreff, Inhalt, Anlagen et cetera übergeben.<\/p>\n Genau zu diesem Zweck können wir die Variable strJSON <\/b>nutzen. <\/p>\n JSON ist ein ein strukturiertes Format wie XML, das allerdings anders formatiert wird.<\/p>\n Am einfachsten ist der Einsatz von Name-Wert-Paaren. Diese können wir beispielsweise wie folgt in der Variablen strJSON <\/b>festlegen und übergeben:<\/p>\n Mit dieser neuen Version der Zuweisung führen wir die Prozedur nun erneut aus. Das Ergebnis sollte wie zuvor mit Status 201 <\/b>erfolgreich sein.<\/p>\n Nun wollen wir uns ansehen, ob die Daten erfolgreich übergeben wurden und was wir damit machen können.<\/p>\n Dazu klicken wir zunächst oben links auf den Pfeil neben Integration Webhooks <\/b>(siehe Bild 21). Integration Webhooks <\/b>ist übrigens der Name unserer Automation, den wir in diesem Zuge gleich einmal auf Beispiel Webhook <\/b>ändern. Anschließend klicken wir diesen einfach an und tragen den gewünschten Namen ein.<\/p>\n Bild 21: Zurück zur Übersicht<\/span><\/b><\/p>\n Damit landen wir auf der Übersicht aus Bild 22. Nach einem Abgleich, ob die Zeit mit unserer letzten Ausführung übereinstimmt, klicken wir den entsprechenden Eintrag an.<\/p>\n Bild 22: Anklicken eines History-Eintrags<\/span><\/b><\/p>\n Dies zeigt wieder den Aufbau des Scenarios an. Wenn wir nun auf die Lupe des Triggers klicken, blendet Make.com <\/b>ein Popup ein, dass Informationen über die gelieferten Daten enthält (siehe Bild 23).<\/p>\n Bild 23: Hier sehen wir die Eingangsparameter und ihre Werte.<\/span><\/b><\/p>\n Alle dort angezeigten Informationen können wir in den folgenden Schritten weiterverarbeiten. In diesem Fall liegt uns nur der zweite Schritt vor, der die Response für den Aufruf liefern soll.<\/p>\n Hier wollen wir nun die beiden übergebenen Informationen zusammenfügen und an den Aufruf zurückgeben.<\/p>\n Das ist zugegebenermaßen nicht besonders einfallsreich und wir könnten noch einige Schritte dazwischenschieben – beispielsweise indem wir einen neuen Kunden in einem CRM anlegen und für diesen den übergebenen Vornamen und Nachnamen eintragen. Mit dem Response<\/b>-Element könnten wir die ID des neu angelegten Kunden im CRM zurückliefern.<\/p>\n Dies würde jedoch hier den Rahmen sprengen, also wollen wir die einfache Lösung als Beispiel verwenden.<\/p>\n Um das Response<\/b>-Element anzupassen, klicken wir oben auf Diagram<\/b>, dann auf das Scenario und schließlich nochmal auf das anzupassende Element.<\/p>\n Dies blendet wieder die Eigenschaften des Elements ein. Hier klicken wir in das Textfeld Body<\/b> und das nun erscheinende Popup zeigt nun direkt die übergebenen Parameter aus dem Trigger-Element an (siehe Bild 24).<\/p>\n Bild 24: Eingangsparameter nutzen<\/span><\/b><\/p>\n In unserem Fall hatten wir zuvor einmal ein JSON mit anderen Bezeichnern gesendet, nämlich name <\/b>und project<\/b>.<\/p>\n Wie sich hier zeigt, merkt sich Make.com <\/b>die Bezeichner an einer bestimmten Stelle, nämlich wenn zum ersten Mal ein JSON-Dokument mitgesendet wird. <\/p>\n Wenn wir später ein JSON-Dokument mit anderen Elementen senden, werden dennoch die zuerst gespeicherten Parameter angezeigt.<\/p>\n Wir können dies jedoch zurücksetzen. Dazu klicken wir auf das erste Webhook-Element und finden im Popup nun den Button Redetermine data structure <\/b>vor (siehe Bild 25).<\/p>\n Bild 25: Zurücksetzen der erwarteten Datenstruktur<\/span><\/b><\/p>\n Diesen klicken wir nun an und sehen nun die Ansicht aus Bild 26. Der Webhook wartet nun auf einen Aufruf mit der neuen Datenstruktur.<\/p>\n Bild 26: Der Webhook wartet auf einen Aufruf mit der neuen Datenstruktur.<\/span><\/b><\/p>\n Also starten wir unsere VBA-Prozedur mit dem Aufruf mit der neuen JSON-Struktur erneut und erhalten als Ergebnis den Status 200<\/b>. Das ist korrekt, denn dieser Aufruf dient nur der Übergabe der neuen Parameterbezeichnungen. In Make.com sehen wir nun, dass die neue Datenstruktur erfolgreich erkannt wurde (siehe Bild 27).<\/p>\n Bild 27: Bestätigung der neuen Datenstruktur<\/span><\/b><\/p>\n Mit einem Klick auf Save <\/b>speichern wir den aktuellen Zustand.<\/p>\n Danach sollten die alten Elemente verschwunden sein. Falls das nicht der Fall ist, können entweder damit leben oder wir erstellen das Scenario einmal komplett neu.<\/p>\n Das Neuerstellen ist mitunter aufwendig, wenn wir bereits mehrere Aktionen definiert haben.<\/p>\n Deshalb können wir folgende Technik nutzen:<\/p>\n Bild 28: Exportieren eines Blueprints<\/span><\/b><\/p>\n Klicken wir nun auf das Element für die Response, finden wir endlich die aktualisierte Liste nur mit den neuen Parametern vor (siehe Bild 29).<\/p>\n Bild 29: Die neue Version zeigt nun nur noch die gewünschten Parameter an.<\/span><\/b><\/p>\n Hier stellen wir nun einen Body zusammen, der uns die übersendeten Werte für firstName <\/b>und lastName <\/b>zurückliefert.<\/p>\n Das Ergebnis nach einem erneuten Aufruf unserer VBA-Prozedur sehen wir in Bild 30.<\/p>\n Bild 30: Meldung über den erfolgreichen Versand einer E-Mail mit Rückgabewert<\/span><\/b><\/p>\n Früher oder später werden wir komplexere Antworten zurückgeben, die wir in der aufrufenden Prozedur per VBA auswerten müssen.<\/p>\n Hier bietet es sich an, die Antworten gleich auch im JSON-Format zurückzuliefern.<\/p>\n In unserem Beispiel gestalten wir den Body des Response-Elements nun wie in Bild 31.<\/p>\n Bild 31: Zusammenstellen der Antwort im JSON-Format<\/span><\/b><\/p>\n Die Meldung sieht nach dem Speichern des Scenarios und dem erneuten Ausführen der VBA-Prozedur nun wie in Bild 32 aus.<\/p>\n Bild 32: Antwort im JSON-Format<\/span><\/b><\/p>\n Das Ergebnis würden wir im Produktiveinsatz entsprechend auswerten. Dazu bieten sich die Tools an, die wir in den Artikeln Mit JSON arbeiten <\/b>(www.vbentwickler.de\/361<\/b>) und JSON-Dokumente per Objektmodell zusammenstellen <\/b>(www.vbentwickler.de\/412<\/b>) vorgestellt haben.<\/p>\n Für die Auswertung einer solche Antwort passen wir den Code ein wenig an (siehe neue Version in Listing 2). Wir fügen folgende Variablen hinzu:<\/p>\n Listing 2: Aufruf des Webhooks mit Auswertung der JSON-Antwort<\/span><\/b><\/p>\n Mit der send<\/b>-Methode geben wir unser JSON-Dokument mit den zu verarbeitenden Daten an den Webhook weiter. Wenn der Aufruf erfolgreich ist (status <\/b>liefert den Wert 201<\/b>), speichern wir den Inhalt der Eigenschaft responseText <\/b>in der Variablen strResponse<\/b>.<\/p>\n Danach nutzen wir zuerst die Funktion GetJSONDOM<\/b>, um die Anweisungen im Direktbereich auszugeben, die für das Abrufen der entsprechenden Werte aus dem in objJSON <\/b>gespeicherten Objekt erforderlich sind.<\/p>\n Damit erhalten wir in diesem Fall:<\/p>\n Die vorn angeführten Ausdrücke können wir dann im Code nutzen, um die entsprechenden Werte aus dem JSON-Dokument auszulesen. Dies erledigen wir dann in den folgenden beiden Zeilen.<\/p>\n Dieser Artikel zeigt, wie wir eine einfache Automation durch ein Scenario in Make.com <\/b>abbilden. Dieses ermöglicht es uns nicht nur, verschiedene Tools zu automatisieren, sondern liefert auch ein Ergebnis zurück.<\/p>\n Dabei haben wir uns zunächst auf das Grundgerüst konzentriert. Zwischen dem Trigger und der Aktion, welche die Response zurückliefert, können wir noch beliebig viele weiterer Aktionen einfügen, die gegebenenfalls auch verschachtelt oder in Schleifen durchgeführt werden können.<\/p>\n Ein Beispiel dafür liefern wir mit dem Artikel Google Mail mit Make.com und VBA statt Outlook <\/b>(www.vbentwickler.de\/464<\/b>). Hier fügen wir zwischen die bereits vorgestellten Elemente weitere Aktionen ein, mit denen wir eine vollständige E-Mail über Google Mail versenden können.<\/p>\n Dabei wollen wir nicht nur die Standardelemente wie Betreff und Inhalt nutzen, sondern auch noch Extras wie Anlagen einfügen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n AutomationMitMake.accdb<\/p>\nAutomationen starten per Webhook<\/h2>\n
\n
Ergebnis verarbeiten<\/h2>\n
Ein Scenario erstellen<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_003.png\")
<\/p>\nTrigger zum Scenario hinzufügen<\/h2>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_004.png\")
<\/p>\n![\"Betrachten](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_005.png\")
<\/p>\nWebhook als Trigger verwenden<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_006.png\")
<\/p>\n\n
Trigger anlegen<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_007.png\")
<\/p>\n![\"Einstellen](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_008.png\")
<\/p>\n![\"Details](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_009.png\")
<\/p>\nErster Test des Webhooks<\/h2>\n
![\"Aufruf](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_024.png\")
<\/p>\nAntwort benutzerdefiniert gestalten<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_010.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_011.png\")
<\/p>\n![\"Verfügbare](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_012.png\")
<\/p>\n![\"Hinzufüge](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_013.png\")
<\/p>\nThere is no scenario listening for this webhook.<\/pre>\n
![\"Starten](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_014.png\")
<\/p>\n![\"Erfolgreicher](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_015.png\")
<\/p>\nNächste Schritte<\/h2>\n
Make.com-Automation per VBA aufrufen<\/h2>\n
![\"Verweise](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_001.png\")
<\/p>\n\n
Public Sub <\/span>Make_Template()\r\n Dim <\/span>strWebhookURL As String<\/span>\r\n Dim <\/span>objXMLHTTP As <\/span>MSXML2.XMLHTTP60\r\n Dim <\/span>strJSON As String<\/span>\r\n strWebhookURL = \"https:\/\/hook.eu2.make.com\/8kyskzlhvzgb9a6ltf4ccrg7fh9hxz3e\"\r\n strJSON = \"\"\r\n Set<\/span> objXMLHTTP = New<\/span> MSXML2.XMLHTTP60\r\n objXMLHTTP.Open \"POST\", strWebhookURL, False<\/span>\r\n objXMLHTTP.setRequestHeader \"Content-Type\", \"application\/json\"\r\n \r\n objXMLHTTP.send strJSON\r\n If <\/span>objXMLHTTP.status = 200 Then<\/span>\r\n MsgBox<\/span> \"Erfolgreich gesendet: \" & vbCrLf<\/span> & vbCrLf<\/span> & objXMLHTTP.responseText\r\n Else<\/span>\r\n MsgBox<\/span> \"Fehler beim Senden: \" & objXMLHTTP.status & \" - \" & objXMLHTTP.statusText\r\n End If \r\nEnd Sub<\/span><\/pre>\n![\"Erneutes](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_016.png\")
<\/p>\n![\"Ergebnis](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_017.png\")
<\/p>\nStatuscode anpassen<\/h2>\n
![\"Definieren](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_018.png\")
<\/p>\nSelect Case objXMLHTTP.status\r\n Case <\/span>201\r\n MsgBox<\/span> \"Erfolgreich gesendet: \" & vbCrLf<\/span> _\r\n & vbCrLf<\/span> & objXMLHTTP.responseText\r\n Case <\/span>200\r\n MsgBox<\/span> \"Erfolgreich gesendet, aber Automation \" _\r\n & \"nicht aktiv.\"\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler beim Senden: \" _\r\n & objXMLHTTP.status & \" - \" _\r\n & objXMLHTTP.statusText\r\nEnd Select<\/span><\/pre>\nMake.com-Automation dauerhaft aktivieren<\/h2>\n
![\"Dauerhaftes](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_019.png\")
<\/p>\nAufruf erneut ausprobieren<\/h2>\n
Weitere Informationen übergeben<\/h2>\n
strJSON = \"{\"\"firstName\"\":\"\"André\"\",\"\"lastName\"\":\"\"Minhorst\"\"}\"<\/pre>\nEinblick in die Historie der Aufrufe<\/h2>\n
![\"Zurück](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_020.png\")
<\/p>\n![\"Anklicken](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_021.png\")
<\/p>\n![\"Hier](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_022.png\")
<\/p>\nEingangsparameter weiterverarbeiten<\/h2>\n
![\"Eingangsparameter](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_023.png\")
<\/p>\nFalls nicht die erwarteten Parameter erscheinen<\/h2>\n
![\"Zurücksetzen](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_026.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_027.png\")
<\/p>\n![\"Bestätigung](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_028.png\")
<\/p>\n\n
![\"Exportieren](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_033.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_029.png\")
<\/p>\n![\"Meldung](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_030.png\")
<\/p>\nResponse im JSON-Format zurückliefern<\/h2>\n
![\"Zusammenstellen](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_031.png\")
<\/p>\n![\"Antwort](\"..\/fileadmin\/_temp_\/2025_02\/pic_463_032.png\")
<\/p>\nAuswerten der JSON-Antwort<\/h2>\n
Public Sub <\/span>Make_MitJSONResponse()\r\n Dim <\/span>strWebhookURL As String<\/span>\r\n Dim <\/span>objXMLHTTP As <\/span>MSXML2.XMLHTTP60\r\n Dim <\/span>strJSON As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>objJSON As Object<\/span>\r\n strWebhookURL = \"https:\/\/hook.eu2.make.com\/8kyskzlhvzgb9a6ltf4ccrg7fh9hxz3e\"\r\n strJSON = \"{\"\"firstName\"\":\"\"André\"\",\"\"lastName\"\":\"\"Minhorst\"\"}\"\r\n Set<\/span> objXMLHTTP = New<\/span> MSXML2.XMLHTTP60\r\n objXMLHTTP.Open \"POST\", strWebhookURL, False<\/span>\r\n objXMLHTTP.setRequestHeader \"Content-Type\", \"application\/json\"\r\n \r\n objXMLHTTP.send strJSON\r\n Select Case objXMLHTTP.status\r\n Case <\/span>201\r\n strResponse = objXMLHTTP.responseText\r\n Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n Set<\/span> objJSON = ParseJson(strResponse)\r\n Debug.Print<\/span> \"ExecutionID: \" & objJSON.Item(\"executionId\")\r\n Debug.Print<\/span> \"Customer: \" & objJSON.Item(\"customer\")\r\n Case <\/span>200\r\n MsgBox<\/span> \"Erfolgreich gesendet, aber Automation nicht aktiv.\"\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler beim Senden: \" & objXMLHTTP.status & \" - \" & objXMLHTTP.statusText\r\n End Select<\/span>\r\n \r\nEnd Sub<\/span><\/pre>\n\n
objJSON.Item(\"executionId\"):a3af7fa2962b4c5abd28f574daa4ab\r\nobjJSON.Item(\"customer\"):André Minhorst<\/pre>\n
Zusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n