![\"Öffnen](\"..\/fileadmin\/_temp_\/2025_04\/pic_482_001.png\")
<\/p>\n<\/p>\n
Bild 1: Öffnen des Builder Hubs<\/span><\/b><\/p>\n Das Datenbanksystem Airtable bietet eine Menge Funktionen an, aber offeriert leider keine direkte Schnittstelle, mit der man direkt etwa von Access auf die enthaltenen Daten zugreifen kann. Es gibt zwar kostenpflichtige ODBC-Schnittstellen von Drittanbietern, aber wir wollen den Zugriff selbst programmieren. Wie für moderne SaaS-Tools üblich, bietet auch Airtable eine Rest-API als Schnittstelle für den Zugriff auf die Daten an. Diese wollen wir im vorliegenden Artikel untersuchen und zeigen, wie wir auf die enthaltenen Daten zugreifen und Informationen aus einer lokalen Datenbank in eine Airtable-Datenbank schreiben können.<\/b><\/p>\n Der erste Schritt für den Zugriff auf eine Rest-API ist immer die Ermittlung des dazu notwendigen API-Schlüssels. Diesen holen wir uns nach dem Anmelden auf airtable.com<\/b>, indem wir zunächst oben rechts auf den Button für unser Konto klicken und aus dem nun erscheinenden Menü den Eintrag Builder Hub <\/b>auswählen (siehe Bild 1).<\/p>\n Bild 1: Öffnen des Builder Hubs<\/span><\/b><\/p>\n Danach landen wir im Builder Hub<\/b>, wo wir über den Menübefehl Persönliche Zugangstoken <\/b>eine Schaltfläche namens Token erstellen <\/b>einblenden können (siehe Bild 2).<\/p>\n Bild 2: Anlegen eines Tokens<\/span><\/b><\/p>\n Neben dem persönlichen Zugangstoken gibt es noch OAuth-Token. Für das Synchronisieren einer Access-Datenbank mit einer Airtable-Datenbank ist das persönliche Zugangstoken die beste Lösung.<\/p>\n Das OAuth-Token benötigen wir nur, wenn wir eine App entwickeln, mit der wir im Namen andere Benutzer auf deren Airtable-Datenbanken zugreifen wollen. <\/p>\n Nach dem Anlegen des persönlichen Tokens legen wir fest, für welche Bereiche dieses Token gelten soll. Diese wählen wir aus, indem wir die Liste der verfügbaren Bereiche mit einem Klick auf Einen Bereich hinzufügen <\/b>öffnen und dort die gewünschten Bereiche hinzufügen (siehe Bild 3).<\/p>\n Bild 3: Hinzufügen von Bereichen<\/span><\/b><\/p>\n Wir wollen ausgiebig experimentieren, also fügen wir die Bereiche aus Bild 4 hinzu.<\/p>\n Bild 4: Alle notwendigen Bereiche<\/span><\/b><\/p>\n Anschließend wollen wir noch festlegen, auf welche Datenbanken in unserer Airtable-Instanz sich die hinzugefügten Berechtigungen auswirken sollen. Das erledigen wir im gleichen Bereich weiter unten, wo wir mit einem Klick auf Alle Ressourcen hinzufügen <\/b>direkt alle Datenbanken gleichzeitig freischalten oder mit Eine Base hinzufügen <\/b>gezielt eine Datenbank für den Zugriff auswählen (siehe Bild 5).<\/p>\n Bild 5: Hinzufügen der Datenbank, auf die wir zugreifen wollen<\/span><\/b><\/p>\n Nun wird das Token erstellt und wir können es aus dem nun erscheinenden Dialog in die Zwischenablage kopieren (siehe Bild 6).<\/p>\n Bild 6: Das fertige Token<\/span><\/b><\/p>\n Achtung: Das Token können wir nur einmalig abrufen. Also fügen wir es direkt als Wert einer Konstanten namens cStrAPIToken<\/b> in ein neues VBA-Modul im VBA-Projekt der Datenbank ein, von der aus wir auf die Airtable-Datenbank zugreifen wollen.<\/p>\n Im gleichen Zuge legen wir auch direkt noch eine weitere Konstante für die Basis-URL für die Rest-API-Zugriffe fest:<\/p>\n Außerdem benötigen wir die ID der Airtable-Datenbank, mit der wir arbeiten wollen. Dazu öffnen wir die folgende URL unter der wir auch noch andere wichtige Informationen finden:<\/p>\n Hier sehen wir alle Datenbanken des aktuellen Kontos (siehe Bild 7). Also klicken wir die gewünschte Datenbank an.<\/p>\n Bild 7: Übersicht der Airtable-Datenbanken<\/span><\/b><\/p>\n Anschließend erscheint eine Ansicht, die unscheinbar in einem Absatz die ID der zu verwendenden Datenbank enthält (siehe Bild 8).<\/p>\n Bild 8: Ermitteln der ID der Datenbank<\/span><\/b><\/p>\n Auch diese kopieren wir zunächst in die Zwischenablage und fügen sie als Wert einer weiteren Konstanten namens cStrBaseID <\/b>ein:<\/p>\n Achtung: <\/b>Wir benötigen die ID ohne den abschließenden Punkt.<\/p>\n Danach schauen wir uns diese Seite genauer an. Links in der Übersichtsleiste sehen wir nämlich die Tabellen unserer Datenbank (siehe Bild 9). Öffnen wir einen dieser Einträge, sehen wir Untereinträge, die nach dem Anklicken weitere Informationen liefern – zum Beispiel, wie man Datensätze der jeweiligen Tabelle ausgibt, einzelne Datensätze ermittelt, diese erstellt, aktualisiert oder löscht.<\/p>\n Bild 9: Beispiele für die verschiedenen Datenbank-Operationen<\/span><\/b><\/p>\n Auf der rechten Seite sehen wir eine Beschreibung und den notwendigen JSON-Code, den wir mit dem jeweiligen Aufruf der Rest-API übergeben müssen.<\/p>\n Mit der Rest-API können wir verschiedene Informationen unserer Airtable-Datenbank abrufen. Bevor wir in das Abfragen, Bearbeiten oder Löschen von Daten aus Airtable-Tabellen einsteigen, ermitteln wir erst einmal die grundlegenden Informationen der in der Datenbank enthaltenen Tabellen.<\/p>\n Dazu verwenden wir die Prozedur GetAirtableTables<\/b> aus Listing 1. Hier erstellen wir ein Objekt des Typs XMLHTTP60<\/b>, mit dem wir auf die Rest-API zugreifen. Wir stellen in strURL <\/b>die Adresse für den Zugriff auf unsere Datenbank zusammen, wobei wir die ID der Datenbank aus der oben definierten Konstanten cStrBaseID <\/b>integrieren. Die URL sieht nun beispielsweise wie folgt aus:<\/p>\n Listing 1: Prozedur zum Auslesen aller Tabellen der Airtable-Datenbank<\/span><\/b><\/p>\n Das API-Token aus cStrAPIToken <\/b>übergeben wie mit dem RequestHeader <\/b>namens Authorization<\/b>. Dann starten wir den Aufruf und erhalten das Ergebnis mit objXMLHTTP.Response <\/b>im JSON-Format.<\/p>\n Dieses verarbeiten wir mit der Funktion ParseJson <\/b>aus dem Modul mdlJSON <\/b>in ein Objekt aus Dictionary<\/b>– und Collection<\/b>-Elementen, auf das wir dann zugreifen können. Damit wir wissen, wie wir auf die enthaltenen Elemente zugreifen können, geben wir diese mit der GetJSONDOM<\/b>-Funktion im Direktbereich aus. Dadurch sehen wir, dass wir auf die Tabellendaten beispielsweise wie folgt zugreifen können:<\/p>\n Daraus können wir eine For…Next<\/b>-Schleife ableiten, um die Werte für die Felder id <\/b>und name <\/b>auszulesen und einzeln im Direktbereich auszugeben. Das Ergebnis sieht wie folgt aus:<\/p>\n Damit haben wir nun auch die ID der Tabelle, mit der wir in den folgenden Abschnitten auf die Tabelle Bestellungen <\/b>zugreifen und diese auslesen, bearbeiten oder um neue Datensätze ergänzen können.<\/p>\n Airtable stellt eine Basis-URL für den Zugriff auf die Tabellendaten einer Airtable-Datenbank zur Verfügung.<\/p>\n Wir erstellen eine Basisfunktion mit verschiedenen Parametern, um alle Operationen abzudecken. Den ersten Teil dieser Funktion finden wir in Listing 2. Hier sehen wir zunächst die Parameter der Funktion:<\/p>\n Listing 2: Funktion zum Erstellen, Aktualisieren, Lesen und Löschen von Datensätzen in Tabellen (Teil 1)<\/span><\/b><\/p>\n Die Funktion stellt im ersten Schritt die URL für den Zugriff auf die Rest-API zusammen. Diese besteht aus der Basis-URL (cStrBaseURL<\/b>), der ID für die zu verwendende Datenbank (cStrBaseID<\/b>), einem Slash und dem Namen der Tabelle oder der ID der Tabelle – hier verwenden wir der Einfachheit halber den Namen.<\/p>\n Die Verwendung der ID hätte den Vorteil, dass wir in der Datenbank auch einmal den Namen der Tabelle ändern könnten und der Code immer noch funktioniert. Die IDs haben wir zuvor mit der Prozedur GetAirtableTables <\/b>ermittelt. Die URL könnte nun wie folgt aussehen:<\/p>\n Wenn wir einen vorhandenen Datensatz bearbeiten oder löschen wollen, können wir den Parameter strID <\/b>verwenden. Damit übergeben wir die ID des zu bearbeitenden Datensatzes.<\/p>\n Diese bekommen wir, indem wir den Datensatz zunächst abfragen. Auch dazu sehen wir uns später ein Beispiel an.<\/p>\n Die ID aus strID <\/b>hängen wir, soweit vorhanden, im nächsten Schritt an die URL an. Die URL zum Bearbeiten oder Löschen eines Datensatzes würde wie folgt aussehen:<\/p>\n Danach folgt die Verarbeitung eventueller Parameter. Wie wir einen solchen Parameter zusammenstellen, beschreiben wir weiter unten. <\/p>\n Da wir auch mehrere Parameter übergeben können, verwenden wir dazu ein ParamArray<\/b>. Wir prüfen im nächsten Schritt mit IsMissung<\/b>, ob varParameters<\/b> Parameter enthält. Ist das der Fall, parsen wir diese in der Funktion ParseParameters<\/b>, die wir im Anschluss beschreiben.<\/p>\n Nun erstellen wir ein Objekt des Typs MSXML2.XMLHTTP<\/b>. Seiner Open<\/b>-Funktion übergeben wir die Methode aus strMethod <\/b>(also GET<\/b>, POST<\/b>, PUT <\/b>oder DELETE<\/b>), die vorher zusammengestellte URL und den Wert False <\/b>für den Parameter varAsync<\/b>, damit der Aufruf asynchron ausgeführt und der Code erst nach dem Beenden des Aufrufs weiterläuft.<\/p>\n Für das XMLHTTP60<\/b>-Objekt legen wir nun mit setRequestHeader <\/b>das Authentifizierungstoken fest sowie den Inhaltstyp, hier application\/json<\/b>.<\/p>\n Schließlich senden wir den Aufruf mit der send<\/b>-Methode ab. Diese erhält den Wert des Parameters strRequest<\/b>. Diesen benötigen wir nur, wenn wir beispielsweise Änderungen an einem Datensatz durchführen oder einen Datensatz hinzufügen wollen. strRequest<\/b> füllen wir dann vor dem Aufruf mit einem JSON-Dokument, das die Werte für den zu ändernden oder anzulegenden Datensatz enthält – mehr dazu in den Beispielen weiter unten.<\/p>\n Die Antwort erhalten wir mit dem responseText<\/b>-Parameter von objXMLHTTP60<\/b>.<\/p>\n Außerdem liefert status<\/b> eine Information darüber, ob der Aufruf erfolgreich war (200<\/b>) oder ob ein Fehler ausgelöst wurde – beispielsweise durch ein ungültiges JSON-Dokument in strRequest<\/b>, eine ungültige URL oder einen anderen Fehler.<\/p>\n Den Wert der Eigenschaft status <\/b>werten wir im zweiten Teil der Funktion aus Listing 3 in einer ersten Select Case<\/b>-Bedingung aus, die zunächst prüft, ob status<\/b> den Wert 200 <\/b>(erfolgreicher Aufruf, Rückgabewert True<\/b>) oder einen anderen Wert enthält (Rückgabewert False<\/b>).<\/p>\n Listing 3: Funktion zum Erstellen, Aktualisieren, Lesen und Löschen von Datensätzen in Tabellen (Teil 2)<\/span><\/b><\/p>\n In diesem Fall folgt eine zweite Select Case<\/b>-Bedingung, in der wir den Fehlercode auswerten und in den Rückgabeparameter strErrorDescription <\/b>eintragen.<\/p>\n Wenn wir eine Liste von Datensätzen ermitteln wollen, übergeben wir für den Parameter strMethod <\/b>den Wert GET<\/b>. Außerdem können wir über varParameters <\/b>mit Name-Wert-Paaren weitere Einstellungen für das Ermitteln der gewünschten Datensätze festlegen. Diese lauten folgendermaßen:<\/p>\n Wenn wir beispielsweise nur den Wert eines Feldes zurückgeben wollen, verwenden wir die folgenden Parameter:<\/p>\n Diese müssen wir noch parsen, was wir in der Funktion ParseParameters <\/b>erledigen (siehe Listing 4). Diese nimmt das ParamArray aus varParameters <\/b>als einfachen Variant<\/b>-Parameter entgegen.<\/p>\n Listing 4: Funktion zum Zusammenstellen und Kodieren der Parameterwerte<\/span><\/b><\/p>\n Sie durchläuft jedes Element aus varParameters <\/b>in einer For Each<\/b>-Schleife. Darin ermitteln wir die Position des Gleichheitszeichens und speichern sie in lngPosEqual<\/b>. Mit der Left<\/b>-Funktion lesen wir den Inhalt des aktuellen Parameters aus varParameter <\/b>aus, der sich vor dem Gleichheitszeichen befindet, und speichern ihn in strParameterName<\/b>. Mit der Mid<\/b>-Funktion holen wir den Wert des Parameters hinter dem Gleichheitszeichen und schreiben ihn in strParameterValue<\/b>.<\/p>\n Lautet der Parametername fields<\/b>, hängen wir mit %5B%5D<\/b> noch den Code für ein öffnendes und ein schließendes Paar eckiger Klammern an ([]<\/b>).<\/p>\n Schließlich stellen wir den Parameter in varParameter <\/b>aus strParameterName <\/b>und dem kodierten Wert aus strParameterValue <\/b>zusammen und hängen ihn an die Liste der Parameter in strParameters <\/b>an.<\/p>\n Nach dem Durchlaufen aller Parameter geben wir strParameters <\/b>als Funktionsergebnis zurück.<\/p>\n Die Rest-API stellt die folgenden Funktionen für den Zugriff auf die Tabellendaten bereit:<\/p>\n Für diese Funktionen sind verschiedene Parameter erforderlich, die wir in den folgenden Abschnitten erläutern.<\/p>\n Damit sind wir nun grundsätzlich gerüstet, die Daten der Tabelle Bestellungen<\/b> aus der Airtable-Datenbank abzurufen.<\/p>\n Dazu benötigen wir nur noch den passenden Aufruf der weitere oben bereits vorgestellten Funktion Airtable_CRUD<\/b>.<\/p>\n Diese rufen wir wie in der folgenden Beispielprozedur auf:<\/p>\n Hier übergeben wir die folgenden Parameterwerte:<\/p>\n<\/p>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2025_04\/pic_482_002.png\")
<\/p>\nPersönlicher Zugangstoken<\/h2>\n
Bereiche für das Token festlegen<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2025_04\/pic_482_003.png\")
<\/p>\n![\"Alle](\"..\/fileadmin\/_temp_\/2025_04\/pic_482_004.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2025_04\/pic_482_006.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2025_04\/pic_482_005.png\")
<\/p>\nPrivate <\/span>Const cStrBaseURL As String<\/span> = \"https:\/\/api.airtable.com\/v0\/\"\r\nPrivate <\/span>Const cStrAPIToken As String<\/span> = \"pat6TTvfq5Uq8avqs.7baxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxc7553910b58\"<\/pre>\nID der Airtable-Datenbank ermitteln<\/h2>\n
https:\/\/airtable.com\/developers\/web\/api\/introduction<\/pre>\n
![\"Übersicht](\"..\/fileadmin\/_temp_\/2025_04\/pic_482_007.png\")
<\/p>\n![\"Ermitteln](\"..\/fileadmin\/_temp_\/2025_04\/pic_482_008.png\")
<\/p>\nPrivate <\/span>Const cStrBaseID As String<\/span> = \"appxxxxxxxxxxxxxxx\" ''Kundenverwaltung<\/pre>\nBeispiele für die verschiedenen Datenbankoperationen<\/h2>\n
![\"Beispiele](\"..\/fileadmin\/_temp_\/2025_04\/pic_482_009.png\")
<\/p>\nListe der Tabellen ermitteln<\/h2>\n
Sub <\/span>GetAirtableTables()\r\n Dim <\/span>objXMLHTTP As <\/span>MSXML2.XMLHTTP60\r\n Dim <\/span>objJSON As Object<\/span>\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n \r\n Set<\/span> objXMLHTTP = New<\/span> MSXML2.XMLHTTP60\r\n strURL = cStrBaseURL & \"meta\/bases\/\" & cStrBaseID & \"\/tables\"\r\n \r\n objXMLHTTP.Open \"GET\", strURL, False<\/span>\r\n objXMLHTTP.setRequestHeader \"Authorization\", \"Bearer \" & cStrAPIToken\r\n objXMLHTTP.send\r\n Debug.Print<\/span> GetJSONDOM(objXMLHTTP.responseText, True<\/span>)\r\n \r\n Set<\/span> objJSON = ParseJson(objXMLHTTP.responseText)\r\n \r\n Debug.Print<\/span> \"TabelleID:\" & vbTab & vbTab & vbTab & vbTab & vbTab & \"Tabellenname:\"\r\n \r\n For i = 1 To objJSON.Item(\"tables\").Count\r\n Debug.Print<\/span> objJSON.Item(\"tables\").Item(i).Item(\"id\"), objJSON.Item(\"tables\").Item(i).Item(\"name\")\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\nhttps:\/\/api.airtable.com\/v0\/\/meta\/bases\/app...RrJh\/tables<\/pre>\n
objJson.Item(\"tables\").Item(1).Item(\"id\"): tblMUktvNEo0FPRYb\r\nobjJson.Item(\"tables\").Item(1).Item(\"name\"): Bestellungen<\/pre>\n
TabelleID: Tabellenname:\r\ntblMUktvNEo0FPRYb Bestellungen<\/pre>\n
Grundlegender Aufbau eines Aufrufs der Rest-API für den Tabellenzugriff<\/h2>\n
Public Function <\/span>Airtable_CRUD(strTable As String<\/span>, strMethod As String<\/span>, strRequest As String<\/span>, _\r\n Optional<\/span> strId As String<\/span>, Optional<\/span> strResponse As String<\/span>, Optional<\/span> intErrorNumber As Integer<\/span>, _\r\n Optional<\/span> strErrorDescription As String<\/span> , ParamArray varParameters() As Variant<\/span>) As Boolean<\/span>\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>objRequest As <\/span>MSXML2.XMLHTTP60\r\n strURL = \"https:\/\/api.airtable.com\/v0\/\" & cStrBaseID & \"\/\" & strTable\r\n \r\n If <\/span>Not<\/span> Len<\/span>(strId) = 0 Then<\/span>\r\n strURL = strURL & \"\/\" & strId\r\n End If<\/span>\r\n If <\/span>Not<\/span> IsMissing(varParameters) Then<\/span>\r\n strURL = strURL & \"?\" & ParseParameters(varParameters)\r\n End If<\/span>\r\n Set<\/span> objRequest = New<\/span> MSXML2.XMLHTTP60\r\n With<\/span> objRequest\r\n .Open strMethod, strURL, False<\/span>\r\n .setRequestHeader \"Authorization\", \"Bearer \" & cStrAPIToken\r\n .setRequestHeader \"Content-Type\", \"application\/json\"\r\n .send strRequest\r\n End With<\/span>\r\n strResponse = objRequest.responseText\r\n intErrorNumber = objRequest.status\r\n ...<\/pre>\n\n
https:\/\/api.airtable.com\/v0\/app...RrJh\/Bestellungen<\/pre>\n
https:\/\/api.airtable.com\/v0\/app...RrJh\/Bestellungen\/recElpIemkgW9bBQC<\/pre>\n
....\r\n Select Case objRequest.status\r\n Case <\/span>200\r\n Airtable_CRUD = True<\/span>\r\n Case Else<\/span>\r\n Select Case objRequest.status\r\n Case <\/span>400\r\n strErrorDescription = \"Bad Request. The request encoding is invalid; the request can''t be \" _\r\n & \"parsed as a valid JSON.\"\r\n Case <\/span>401\r\n strErrorDescription = \"Unauthorized. Accessing a protected resource without authorization \" _\r\n & \"or with invalid credentials.\"\r\n Case <\/span>402\r\n strErrorDescription = \"Payment Required. The account associated with the API key making \" _\r\n & \"requests hits a quota that can be increased by upgrading the Airtable account plan.\"\r\n Case <\/span>403\r\n strErrorDescription = \"Forbidden. Accessing a protected resource with API credentials that \" _\r\n & \"don''t have access to that resource.\"\r\n Case <\/span>404\r\n strErrorDescription = \"Not<\/span> Found. Route or resource is not found. This error is returned \" _\r\n & \"when the request hits an undefined route, or if the resource doesn''t exist (e.g. has \" _\r\n & \"been deleted).\"\r\n Case <\/span>413\r\n strErrorDescription = \"Request Entity Too LargeThe request exceeded the maximum allowed \" _\r\n & \"payload size. You shouldn''t encounter this under normal use.\"\r\n Case <\/span>422\r\n strErrorDescription = \"Invalid Request. The request data is invalid. This includes most of \" _\r\n & \"the base-specific validations. You will receive a detailed error message and code \" _\r\n & \"pointing to the exact issue.\"\r\n Case <\/span>429\r\n strErrorDescription = \"Too Many Requests. The API is limited to 5 requests per second per \" _\r\n & \"base. You will receive a 429 status code and a message ''Rate limit exceeded. Please \" _\r\n & \"try again later'' and will need to wait 30 seconds before subsequent requests will \" _\r\n & \"succeed. To learn more about rate limits, please visit our Rate Limits guide.\"\r\n Case <\/span>500\r\n strErrorDescription = \"Internal Server ErrorThe server encountered an unexpected condition.\"\r\n Case <\/span>502\r\n strErrorDescription = \"Bad GatewayAirtable ''s servers are restarting or an unexpected outage is \" _\r\n & \"in progress. You should generally not receive this error, and requests are safe to retry.\"\r\n Case <\/span>503\r\n strErrorDescription = \"Service UnavailableThe server could not process your request in time. \" _\r\n & \"The server could be temporarily unavailable, or it could have timed out processing \" _\r\n & \"your request. You should retry the request with backoffs.\"\r\n End Select<\/span>\r\n Airtable_CRUD = False<\/span>\r\n End Select<\/span>\r\n Set<\/span> objRequest = Nothing\r\nEnd Function<\/span><\/pre>\nParameter für das Auflisten von Datensätzen<\/h2>\n
\n
\"sort[0][field]=Firma\", \"sort[0][direction]=asc\"<\/pre>\n
Public Function <\/span>CreateParameters(ByVal varParameters As Variant<\/span>)\r\n Dim <\/span>varParameter As Variant<\/span>\r\n Dim <\/span>lngPosEqual As Long<\/span>\r\n Dim <\/span>strParameterName As String<\/span>\r\n Dim <\/span>strParameterValue As String<\/span>\r\n Dim <\/span>strParameters As String<\/span>\r\n For Each varParameter In varParameters\r\n lngPosEqual = InStr<\/span>(1, varParameter, \"=\")\r\n strParameterName = Left<\/span>(varParameter, lngPosEqual - 1)\r\n strParameterValue = Mid<\/span>(varParameter, lngPosEqual + 1)\r\n strParameterName = Replace<\/span>(strParameterName, \"fields\", \"fields%5B%5D\")\r\n varParameter = strParameterName & \"=\" & URLEncode_UTF8(strParameterValue)\r\n strParameters = strParameters & \"&\" & varParameter\r\n Next<\/span> varParameter\r\n CreateParameters = strParameters\r\nEnd Function<\/span><\/pre>\nFunktionen der Rest-API für Tabellen und Tabellendaten<\/h2>\n
\n
Daten der Tabelle Bestellungen abrufen<\/h2>\n
Public Sub <\/span>Test_Airtable_ListRecords()\r\n Dim <\/span>strRequest As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>intErrorNumber As Integer<\/span>\r\n Dim <\/span>strErrorDescription As String<\/span>\r\n Dim <\/span>strID As String<\/span>\r\n \r\n If Airtable_CRUD(\"Bestellungen\", \"GET\", strRequest, _\r\n strID, strResponse, intErrorNumber, _\r\n strErrorDescription) = True<\/span> Then\r\n Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n Else<\/span>\r\n MsgBox<\/span> strErrorDescription & vbCrLf<\/span> & vbCrLf<\/span> _\r\n & strResponse, vbCr<\/span>itical, \"Fehler \" _\r\n & intErrorNumber\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n\n