Im ersten Teil einer Artikelreihe zum Thema Steuerung von eBay mit VBA zeigen wir, wie man einen Entwickler-Account anlegt, eine neue Anwendung bei eBay erstellt, grundlegende Zugriffsdaten holt und die für die Authentifizierung im Kontext eines bestimmten Benutzerkontos notwendigen Informationen holt – hier speziell das Authentifizierungstoken. Damit schaffen wir die Basis, um per VBA auf die Rest API von eBay zuzugreifen. In weiteren Artikeln beschreiben wir den Zugriff und wie wir verschiedene Operationen wie das Anlegen von Angeboten realisieren können.<\/b><\/p>\n
Um eBay mit VBA zu steuern, brauchen wir als Erstes ein Konto im ebay developers program<\/b>. Um dorthin zu gelangen, reicht eine Websuche nach den Begriffen ebay developer<\/b>.<\/p>\n
Für die Registrierung werden die folgenden Informationen benötigt, die wir in ein Formular wie in Bild 1 eintragen: Benutzername, Kennwort, E-Mail-Adresse und Telefonnummer. Nachdem wir diese eingetragen und die Schaltfläche Join <\/b>betätigt haben, landen wir auf der nächsten Seite im Registrierungsprozess.<\/p>\n
![\"Registrieren](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_001.png\")
<\/p>\n
Bild 1: Registrieren für das Developer-Program von eBay<\/span><\/b><\/p>\n Hier erhalten wir den Hinweis, dass eBay uns eine E-Mail zugesendet hat. Diese enthält einen Bestätigungslink, mit dem wir den Vorgang fortsetzen können.<\/p>\n Nachdem wir diesen betätigt haben, landen wir auf der Willkommen-Seite des Entwicklerprogramms und können uns dort mit unseren Daten anmelden (siehe Bild 2).<\/p>\n Bild 2: Anmelden beim Developer-Program von eBay<\/span><\/b><\/p>\n Die Freude währt in der Regel nur kurz, denn gegebenenfalls bekommen wir hier die Meldung, dass die Registrierung nun überprüft wird und in ca. 24 Stunden freigeschaltet wird.<\/p>\n Einen Tag später können wir uns dann ohne Probleme beim eBay-Entwicklerprogramm anmelden.<\/p>\n eBay macht es uns dann erst einmal einfach: Da wir das Entwickler-Konto gerade eröffnet haben und folglich noch keine Anwendungen hinzugefügt haben, ohne eine Anwendung aber der Developer-Account keinen Sinn macht, landen wir direkt auf der Seite zum Erstellen einer Anwendung.<\/p>\n Dies beginnt mit der Eingabe eines Anwendungstitels, der vor allem eine Bedingung erfüllen muss: eBay darf nicht im Namen vorkommen (siehe Bild 3).<\/p>\n Bild 3: Erstellen einer ersten Anwendung<\/span><\/b><\/p>\n Wir entscheiden uns für amvBay<\/b> und noch während wir diesen Namen eingeben, erscheinen bereits verschiedene Links für weitere Möglichkeiten (siehe Bild 4). Diese sind aufgeteilt in Sandbox und Production. Was bedeutet das?<\/p>\n Bild 4: Noch während der Eingabe des Namens erscheinen die Optionen zum Erstellen von Keysets.<\/span><\/b><\/p>\n Beide Settings sind gleich aufgebaut, für beide benötigen wir entsprechenden Daten für den Zugriff. Diese heißen in diesem Fall Keysets<\/b>.<\/p>\n Wir können hier Keysets erstellen oder weitere Keysets anfragen. Was hat es damit auf sich? Wir klicken also erst einmal auf den Link Create a keyset <\/b>unter Sandbox.<\/p>\n Daraufhin erscheint der Bereich Confirm the Primary Contact<\/b>, wo wir weitere Daten wie Name, E-Mail und Telefonnummer eingeben beziehungsweise bestätigen (siehe Bild 5).<\/p>\n Bild 5: Eingabe weiterer Daten<\/span><\/b><\/p>\n Ein Klick auf Continue to Create Keys <\/b>lässt uns wieder zur aufrufenden Seite zurückkehren, wo wir nun allerdings einige neue Informationen vorfinden (siehe Bild 6).<\/p>\n Bild 6: Unser Keyset<\/span><\/b><\/p>\n Dabei handelt es sich um unser Keyset, mit dem wir nun fortfahren können:<\/p>\n Diese Informationen können wir nun bereits in einem VBA-Modul sichern, am einfachsten in Konstanten. Das sieht wie folgt aus:<\/p>\n Damit haben wir allerdings noch nicht alles, was wir benötigen. Das Wichtigste ist das Authentifizierungstoken. Hier ist eine kurze Erklärung nötig:<\/p>\n Wir erstellen hier eine Anwendung, für die eigentlich zwei Konten erforderlich sind: das Entwicklerkonto, das wir soeben erstellt haben, sowie das eigentliche eBay-Konto.<\/p>\n Um eBay komplett fernsteuern zu können, müssen wir uns ein Authentifizierungstoken für unsere Anwendung im Kontext des eigentlichen Benutzers holen.<\/p>\n Damit können wir dann die Anwendung im Kontext des jeweiligen Benutzers verwenden.<\/p>\n Wir gehen an dieser Stelle davon aus, dass wir eine Anwendung für den Zugriff auf eBay erstellen, um diese beispielsweise in die Warenwirtschaft eines Kunden zu implementieren, damit dieser seine Produkte automatisiert bei eBay einstellen kann.<\/p>\n Nur wollen wir nun zunächst nicht im Kontext des echten Benutzers auf eBay zugreifen, sondern erst einmal die Sandbox nutzen. Da die Sandbox praktisch ein eigenes eBay zum Testen ist, können wir logischerweise dort auch nicht mit unserem normalen eBay-Konto arbeiten, sondern müssen uns ein neues Konto anlegen.<\/p>\n Dazu klicken wir erst einmal unter unserer App ID <\/b>(Client ID<\/b>) auf den Link Register a new Sandbox user<\/b> (siehe Bild 7).<\/p>\n Bild 7: Aufruf der Registrierung eines Sandbox-Benutzers<\/span><\/b><\/p>\n Das Anlegen des neuen Sandbox-Benutzers führen wir in dem Formular aus Bild 8 durch. Nach dem Registrieren können wir uns an der Sandbox anmelden.<\/p>\n Bild 8: Eingabe der Daten für einen Sandbox-Benutzer<\/span><\/b><\/p>\n Hier finden wir allerdings zunächst keine Angebote vor.<\/p>\n Nun wollen wir das Token holen, indem wir uns über unsere eBay-Anwendung mit den Daten unseres soeben erstellen Sandbox-Benutzers bei der Sandbox anmelden.<\/p>\n Dazu klicken wir im vorherigen Dialog auf Sign in to Sandbox<\/b> (siehe Bild 9).<\/p>\n Bild 9: Anmeldung an der Sandbox<\/span><\/b><\/p>\n Damit erscheint nochmals ein Bereich, in dem wir unsere Adresse und weitere Daten eingeben müssen (siehe Bild 10).<\/p>\n Bild 10: Eingabe unserer Adressdaten für die Token-Generierung<\/span><\/b><\/p>\n Nun erscheint der Anmeldedialog von der eBay-Sandbox, wo wir uns nun mit den Daten unseres Sandbox-Benutzers anmelden (nicht mit dem Developer-Account!).<\/p>\n Schließlich erhalten wir eine Meldung, die uns als Sandbox-Benutzer darüber aufklärt, dass wir der App die Berechtigungen geben, unser Konto für verschiedene Aktionen auf der Sandbox von eBay zu nutzen. Im Anschluss erhielten wir jedoch eine Fehlermeldung (siehe Bild 11).<\/p>\n Bild 11: Fehlermeldung beim Versuch, das Token zu holen<\/span><\/b><\/p>\n Bei unseren Recherchen zu diesem Artikel waren wir in der Folge nicht in der Lage, ein Authentifizierungstoken für die Sandbox zu holen, also haben wir es mit der Production<\/b>-Version probiert.<\/p>\n Hier erschien beim Versuch, ein Keyset zu holen, zunächst die Meldung aus Bild 12.<\/p>\n Bild 12: Das Keyset ist aktuell deaktiviert.<\/span><\/b><\/p>\n Daraufhin haben wir uns, um weiterarbeiten zu können, für die Beantragung einer Ausnahme beworben (siehe Bild 13). Dazu haben wir unter Event Notification Delivery Method <\/b>die Option Marketplace Account Deletion <\/b>gewählt und Exempted from Marketplace Account Deletion <\/b>aktiviert. Nach dem Absenden mit Submit <\/b>wurde dies umgehend akzeptiert.<\/p>\n Bild 13: Optionen für eine Ausnahme<\/span><\/b><\/p>\n Danach haben wir im oberen Bereich der Webseite den Link Get OAuth Application Token <\/b>vorgefunden (siehe Bild 14).<\/p>\n Bild 14: Link zum Holen des Authentifizierungstokens<\/span><\/b><\/p>\n Danach mussten wir uns erneut authentifizieren, um das Token zu holen. Dazu haben wir diesmal nicht den Sandbox-Benutzer verwendet, den wir zuvor angelegt haben, sondern einen echten eBay-Benutzeraccount.<\/p>\n Nach der Authentifizierung und der Zustimmung, dass unsere eBay-Anwendung amvBay<\/b> im Kontext unseres Benutzers auf eBay zugreifen darf, landen wir wieder auf der Token-Seite. Hier können wir nun erneut auf Get OAuth Application Token <\/b>klicken und erhalten endlich das Token (siehe Bild 15), das wir in die Zwischenablage kopieren und in einer weiteren Konstanten in unserem VBA-Projekt speichern:<\/p>\n Bild 15: Das ersehnte OAuth Application Token<\/span><\/b><\/p>\n Das Token ist zeitlich begrenzt gültig, in diesem Fall 18 Monate. Du solltest dies, wenn Du eine eBay-Anwendung für einen Kunden programmierst, auf jeden Fall im Blick behalten und gegebenenfalls rechtzeitig für eine Aktualisierung des Tokens über den hier vorgestellten Weg sorgen.<\/p>\n Das Benutzertoken können wir nutzen, um benutzerspezifische Aufrufe der Rest API zu authentifizieren. Es gibt jedoch auch einige Rest API-Befehle, die allgemein verfügbar sind und nicht im Kontext eines speziellen Benutzers stehen.<\/p>\n In diesem Fall können wir das Benutzertoken nicht verwenden, sondern wir benötigen ein Anwendungstoken. Das holen wir uns auf der gleichen Seite, auf der wir auch die Erstellung des Benutzertokens initiiert haben. Hier klicken wir nun im oberen Bereich auf Get OAuth Application Token <\/b>(siehe Bild 16).<\/p>\n Bild 16: Ermitteln des Anwendungstokens<\/span><\/b><\/p>\n Nun öffnet sich ein Dialog namens OAuth Application Token<\/b>, dessen Inhalt wir über die Schaltfläche Copy Token <\/b>in die Zwischenablage kopieren können (siehe Bild 17).<\/p>\n Bild 17: Kopieren des Anwendungstokens<\/span><\/b><\/p>\n Auch dieses Token wollen wir in einer Konstanten speichern, diesmal unter dem Namen cStrAppToken<\/b>.<\/p>\n Das ist etwas komplizierter, denn eine Zeile zur Definition einer Konstanten kann nur 1.023 Zeichen aufnehmen, das Token hat allerdings eine Länge von über 1.900 Zeichen.<\/p>\n Am einfachsten kopierst Du es zunächst in eine Textdatei, schneidest dort die ersten 950 Zeichen aus und fügst sie der ersten Zeile der folgenden Anweisung hinzu. Den Rest trägst Du dann in die zweite Zeile ein, die Du mit dem Unterstrich und dem Und-Zeichen verbindest:<\/p>\n Ein großer Nachteil, wenn wir die Daten so über die Benutzeroberfläche holen, ist die geringe Haltbarkeit:<\/p>\n Was bedeutet das für uns? Nach aktuellem Stand müssten wir alle zwei Stunden oder, wenn wir beispielsweise einmal am Tag auf eBay-Daten zugreifen wollen, immer neue Daten holen.<\/p>\n Da es auf Dauer viel Aufwand ist, sich immer in der Benutzeroberfläche der Entwicklerplattform von eBay einzuloggen, wollen wir diese Vorgänge möglichst per VBA steuern.<\/p>\n Die beiden Token haben unterschiedliche Ziele:<\/p>\n Mit dem Anwendungstoken können wir die folgenden Bereiche abfragen:<\/p>\n Das Benutzertoken benötigen wir für die folgenden Aktionen:<\/p>\n Das Anwendungstoken können wir uns ohne irgendeine Interaktion mit der Benutzeroberfläche von eBay per VBA holen. Dazu benötigen wir die folgenden drei Informationen:<\/p>\n Diese drei Informationen übergeben wir an die Funktion GetEbayAppToken<\/b> aus Listing 1. Diese deklariert einige Variablen, für die wir auch noch Verweise zum VBA-Projekt hinzufügen müssen. Außerdem verwenden wir hier Funktionen, die wir direkt per VBA-Modul zum VBA-Projekt hinzufügen können. Zusammengefasst benötigen wir:<\/p>\n Listing 1: Funktion, um das Anwendungstoken zu holen<\/span><\/b><\/p>\n Die Funktion stellt die Zeichenfolge für die Authentifizierung aus dem Wort Basic <\/b>und dem Base64-verschlüsselten Wert aus ClientID <\/b>und ClientSecret <\/b>zusammen – getrennt durch einen Doppelpunkt.<\/p>\n Damit fügen wir in der Variablen strTokenURL <\/b>die URL für den Abruf des Tokens zusammen.<\/p>\n Nun erstellen wir in objXMLHTTP <\/b>ein MSXML2.XMLHTTP<\/b>-Objekt, dem wir mit der Open<\/b>-Methode die Methode POST<\/b>, die URL <\/b>und den Wert False <\/b>für den Parameter varAsync <\/b>übergeben.<\/p>\n Wir stellen den Autorisierung-Header auf unseren Wert aus strAuthheader <\/b>ein. Dann senden wir die Zeichenkette aus strPostData <\/b>an die Rest-API und übernehmen die Antwort aus der Eigenschaft responseText <\/b>in die Variable strPostData<\/b>.<\/p>\n Die Antwort verarbeiten wir mit der Funktion ParseJson<\/b> aus dem Modul mdlJSON<\/b>. Diese erstellt aus dem zurückgelieferten JSON-Dokument ein Objektmodell, bestehend aus Dictionary<\/b>– und Collections<\/b>-Objekten.<\/p>\n Damit wir sehen, welche Elemente hier zurückgeliefert werden, rufen wir die Methode GetJSONDOM <\/b>für die Antwort auf und erhalten ein Ergebnis wie in Bild 19.<\/p>\n Bild 18: Per VBA geholtes Anwendungstoken<\/span><\/b><\/p>\n Die dort jeweils am Zeilenbeginn angegebenen Ausdrücke wie objJSON.Item(“access_token”) <\/b>können wir nutzen, um die in diesen Elementen enthaltenen Daten zu extrahieren. In diesem Fall greifen wir so auf das Element access_token <\/b>zu und geben dieses als Funktionswert zurück.<\/p>\n Die Funktion rufen wir wie folgt aus:<\/p>\n Was können wir jetzt mit dem Ergebnis dieser Funktion anstellen? Aktuell noch nichts. Allerdings wollen wir im Artikel eBay per VBA steuern: Rest-API-Zugriff <\/b>(www.vbentwickler.de\/461<\/b>) auf die Angebote bei eBay zugreifen und dazu benötigen wir das hier ermittelte Anwendungstoken.<\/p>\n Um das Benutzertoken per VBA zu holen, benötigen wir noch eine weitere Einstellung in der Benutzeroberfläche der Entwickler-Plattform von eBay. Das erledigen wir auf der gleichen Seite, auf der wir auch die Tokens geholt haben.<\/p>\n Hier scrollen wir etwas weiter nach unten zum Bereich Get a Token from eBay via Your Application<\/b>. Unter Your eBay Sign-in-Settings <\/b>klicken wir auf Add eBay Redirect URL <\/b>(siehe Bild 18).<\/p>\n Bild 19: Redirect URL festlegen<\/span><\/b><\/p>\n Wir landen in einem erweiterten Formular. Hier findest Du oben unter RuName<\/b> eine Zeichenkette, die wir benötigen und in die Zwischenablage kopieren (siehe Bild 20). Von dort fügen wir sie einer neuen Konstanten namens cStrRuName <\/b>hinzu:<\/p>\n Bild 20: RuName ist das, was wir suchen<\/span><\/b><\/p>\n Diese setzen wir in eine URL wie die folgende ein:<\/p>\n Danach kümmern wir uns in dieser Reihenfolge um die folgenden Schritte:<\/p>\n Der erste Schritt ist etwas hakelig, aber wenn wir das Refresh Token haben, können wir für eine Weile im Kontext des Benutzers auf eBay zugreifen, ohne uns erneut über die Benutzeroberfläche anmelden zu müssen.<\/p>\n Dazu können wir ein paar Prozeduren nutzen, mit denen wir automatisch zu der Seite gelangen, auf der wir uns im Kontext eines Benutzers anmelden können. Hier bekommen wir allerdings erst einmal den Autorisierungscode.<\/p>\n Die erste heißt StartLogin<\/b>. Sie stellt mit einer Hilfsfunktion die URL zusammen, unter der wir den Schlüssel erhalten (siehe Listing 2).<\/p>\n Listing 2: Funktion, um den Authentifizierungscode zu holen<\/span><\/b><\/p>\n Die Hilfsfunktion heißt GetEbayLoginUrl<\/b> und sieht wie in Listing 3 aus. Sie fügt unsere Parameter zu der benötigten URL zusammen.<\/p>\n Listing 3: Funktion zum Zusammenstellen der URL<\/span><\/b><\/p>\n Die Prozedur StarteLogin<\/b> ruft dann mit FollowHyperlink <\/b>den Browser auf und übergibt die zusammengestellte URL.<\/p>\n Hier finden wir nun einen Anmeldedialog für eBay vor (siehe Bild 21).<\/p>\n Bild 21: Anmelden im Kontext eines Benutzers<\/span><\/b><\/p>\n Nachdem wir uns hier angemeldet haben, können wir oben in der URL den Code ermitteln (siehe Bild 22).<\/p>\n Bild 22: Auslesen des Codes<\/span><\/b><\/p>\n Dieser sieht beispielsweise wie folgt aus:<\/p>\n Der entscheidende Teil ist der Text hinter code=<\/b> und vor &expires_in=299<\/b>. Hier sehen wir die typischen Elemente einer URL-codierten Zeichenkette. Diese speichern wir kodiert ab und dekodieren sie später, wenn wir sie benötigen. Die notwendige Konstante definieren wir nun wie folgt:<\/p>\n In der Antwort wird durch den Wert 299 <\/b>für den Parameter expires_in <\/b>deutlich: Wir haben nur knapp fünf Minuten, um diesen Code zu nutzen, also kannst Du die Konstante zwar bereits anlegen.<\/p>\n Aber nutzen können wir diese erst in den nachfolgend beschriebenen Prozeduren zum Ermitteln von Benutzertoken und Refreshtoken. Gegebenenfalls musst Du den Code also erneut holen.<\/p>\n Wir haben oben nur den Scope https:\/\/api.ebay.com\/oauth\/api_scope <\/b>angegeben. Es kann später sein, dass Du mehr Berechtigungen für weitere API-Funktionen benötigst.<\/p>\n Die notwendigen URLs findest Du, wenn Du auf der Seite mit den Application Keys <\/b>unten auf OAuth Scopes <\/b>klickst. Dies öffnet ein Popup mit den Scopes wie in Bild 23.<\/p>\n Bild 23: Scopes der eBay-API<\/span><\/b><\/p>\n Die URLs in der Spalte Scopes <\/b>kannst Du für den Parameter Scope <\/b>in der Funktion GetEbayLoginUrl <\/b>anhängen.<\/p>\n Wenn Du mehrere Scopes verwendest, musst Du diese durch ein als %20 <\/b>kodiertes Leerzeichen voneinander trennen.<\/p>\n Wenn Du neue Scopes hinzufügen musst, weil die aktuellen Scopes für einen bestimmten API-Aufruf nicht ausreichen, musst Du den oben vorgestellten Vorgang wiederholen, also:<\/p>\n Damit geht es in die Zielgerade. Wir haben alle Zutaten zusammen, um das Benutzertoken zu holen, mit dem wir im Kontext eines Benutzers auf die Daten von eBay zugreifen können.<\/p>\n Dieser ist zeitlich allerdings auch stark limitiert (auf 7.200 Sekunden, also zwei Stunden), sodass wir diesen gelegentlich erneuern müssen. Aber kein Problem: Dafür erhalten wir mit der nachfolgend beschriebenen Funktion auch gleich ein Refreshtoken, mit dem wir das Benutzertoken aktualisieren können – ohne nochmals die vorherige Prozedur über den Webbrowser zu durchlaufen. Das Refreshtoken hält 47.304.000 Sekunden, also eineinhalb Jahre.<\/p>\n Schauen wir uns die Funktion GetEbayUserToken<\/b> aus Listing 4 an. Sie erwartet als Parameter die ClientID, das Client Secret, den Authcode und die RedirectURI. Außerdem hat sie einen Rückgabeparameter, der die Antwort von eBay zurückliefert.<\/p>\n Listing 4: Funktion zum Holen des Benutzer- und Refresh-Tokens<\/span><\/b><\/p>\n Damit klar wird, welche Informationen hier gefragt sind, schauen wir uns ein Beispiel für den Aufruf an. Die folgende Prozedur deklariert die Variable strResponse <\/b>für den Rückgabewert, die Variable objJSON<\/b> zum Auswerten des zurückgelieferten JSON-Dokuments sowie zwei Variablen für das Benutzertoken und das Refreshtoken.<\/p>\n Damit rufen wir die Funktion GetEbayUserToken <\/b>auf und übergeben die Werte aus den Konstanten cStrAppID<\/b>, cStrCertID<\/b>, cStrCode <\/b>und cStrRuName<\/b>.<\/p>\n Hier hat eBay über die Jahre ein wenig Inkonsistenz geschaffen, da die notwendigen Parameter anders heißen als die, die wir aus der Benutzeroberfläche entnehmen können – die AppID entspricht beispielsweise der Client ID, die CertID dem Client Secret und RuName ist die Bezeichnung in der Benutzeroberfläche für die RedirectURI (ist aber gar keine URI).<\/p>\n Wir behalten aber als Konstantennamen die Bezeichnungen aus der Benutzeroberfläche bei und verwenden in der Funktion GetEbayUserToken<\/b> die Parameter, wie sie an dieser Stelle benannt werden.<\/p>\n Die Prozedur zum Aufruf übergibt also alle notwendigen Daten und erhält eine Response im JSON-Format zurück. Diese wandeln wir mit ParseJSON <\/b>in ein Objektmodell aus Dictionary<\/b>– und Collection<\/b>-Elementen um.<\/p>\n Wie wir auf dieses Objektmodell zugreifen können, zeigt uns wieder der Aufruf von GetJSONDOM <\/b>– dies gibt alle Ausdrücke für den Zugriff aus sowie die enthaltenen Werte.<\/p>\n Wir verwenden die am Ende verwendeten Ausdrücke für access_token <\/b>und refresh_token <\/b>und weisen deren Inhalte den Variablen strUserToken <\/b>und strRefreshToken <\/b>zu, die wir anschließend in den Benutzerbereich für VBA-Einstellungen in der Registry speichern:<\/p>\n![\"Anmelden](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_003.png\")
<\/p>\nErstellen einer neuen Anwendung<\/h2>\n
![\"Erstellen](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_004.png\")
<\/p>\n![\"Noch](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_005.png\")
<\/p>\n\n
![\"Eingabe](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_006.png\")
<\/p>\n![\"Unser](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_007.png\")
<\/p>\n\n
Const cStrAppID As String<\/span> = \"AndrMinh-amvBay-xxx-xxxxxxxxx-3e3a632f\"\r\nConst cStrDevID As String<\/span> = \"e7df1909-ee64-xxxxxxxx-32138d2b1899\"\r\nConst cStrCertID As String<\/span> = \"SBX-4b5baea0d7a2-xxxx-xxxx-8644-6824\"<\/pre>\nToken holen<\/h2>\n
![\"Aufruf](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_008.png\")
<\/p>\nNeuen Sandbox-Benutzer anlegen<\/h2>\n
![\"Eingabe](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_009.png\")
<\/p>\nToken für diesen Benutzer holen<\/h2>\n
![\"Anmeldung](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_010.png\")
<\/p>\n![\"Eingabe](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_011.png\")
<\/p>\n![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_016.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_013.png\")
<\/p>\n![\"Optionen](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_014.png\")
<\/p>\n![\"Link](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_015.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_017.png\")
<\/p>\nConst cStrUserToken As String<\/span> = \"v^1.1#i^1#p^1#I^3#r^...\"<\/pre>\nAnwendungstoken holen<\/h2>\n
![\"Ermitteln](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_018.png\")
<\/p>\n![\"Kopieren](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_019.png\")
<\/p>\nConst cStrAppToken As String<\/span> = \"v^1.1#i^1#r^0#p^1#...\" _\r\n & \"EAGuOQLyjgblGU8zkk+nJIBIAGIx8Vg4P9TJre...==\"<\/pre>\nNachteil: Gültigkeitsdauer dieser Daten<\/h2>\n
\n
Wann brauche ich welches Token?<\/h2>\n
\n
Anwendungsbereiche für das Anwendungstoken<\/h2>\n
\n
Anwendungsbereiche für das Benutzertoken<\/h2>\n
\n
Anwendungstoken per VBA holen<\/h2>\n
\n
Public <\/span>Const cStrAPIScope As String<\/span> = \"https:\/\/api.ebay.com\/oauth\/api_scope\"<\/pre>\nFunction <\/span>GetEbayAppToken(strClientId As String<\/span>, strClientSecret As String<\/span>, strScope As String<\/span>) As String<\/span>\r\n Dim <\/span>objXMLHTTP As <\/span>MSXML2.XMLHTTP60\r\n Dim <\/span>strTokenURL As String<\/span>\r\n Dim <\/span>strAuthHeader As String<\/span>\r\n Dim <\/span>strPostData As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>objJSON As Object<\/span>\r\n strAuthHeader = \"Basic \" & Base64Encode(strClientId & \":\" & strClientSecret)\r\n strTokenURL = \"https:\/\/api.ebay.com\/identity\/v1\/oauth2\/token\"\r\n strPostData = \"grant_type=client_credentials&scope=\" & strScope\r\n Set<\/span> objXMLHTTP = CreateObject(\"MSXML2.XMLHTTP\")\r\n With<\/span> objXMLHTTP\r\n .Open \"POST\", strTokenURL, False<\/span>\r\n .setRequestHeader \"Content-Type\", \"application\/x-www-form-urlencoded\"\r\n .setRequestHeader \"Authorization\", strAuthHeader\r\n .send strPostData\r\n strResponse = .responseText\r\n End With<\/span>\r\n Set<\/span> objJSON = ParseJson(strResponse)\r\n Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n GetEbayAppToken = objJSON.Item(\"access_token\")\r\nEnd Function<\/span><\/pre>\n\n
![\"Per](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_022.png\")
<\/p>\nPublic Sub <\/span>Test_GetEbayAppToken()\r\n Debug.Print<\/span> GetEbayAppToken(cStrAppID, _\r\n cStrCertID, cStrAPIScope)\r\nEnd Sub<\/span><\/pre>\nBenutzertoken per VBA holen<\/h2>\n
![\"Redirect](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_020.png\")
<\/p>\n![\"RuName](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_021.png\")
<\/p>\nPublic <\/span>Const cStrRuName As String<\/span> = _\r\n \"Andr__Minhorst-AndrMinh-amvBay-fxndr\"<\/pre>\nhttps:\/\/auth.ebay.com\/oauth2\/authorize?client_id=DEINE_CLIENT_ID&response_type=code&redirect_uri=DEIN_REGISTRIERTER_RUNAME_WERT&scope=https:\/\/api.ebay.com\/oauth\/api_scope<\/pre>\n
\n
Public Sub <\/span>StarteLogin()\r\n Dim <\/span>strLoginURL As String<\/span>\r\n strLoginURL = GetEbayLoginUrl(cStrAppID, cStrRuName, \"https:\/\/api.ebay.com\/oauth\/api_scope\")\r\n FollowHyperlink strLoginURL\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>GetEbayLoginUrl(strClientId As String<\/span>, strRuName As String<\/span>, strScopes As String<\/span>) As String<\/span>\r\n Dim <\/span>url As String<\/span>\r\n ''alles außer Punkte wird urlencodiert\r\n url = \"https:\/\/auth.ebay.com\/oauth2\/authorize?\" & _\r\n \"client_id=\" & URLEncodeEBay(strClientId) & _\r\n \"&response_type=code\" & _\r\n \"&redirect_uri=\" & URLEncodeEBay(strRuName) & _\r\n \"&scope=\" & URLEncodeEBay(strScopes)\r\n GetEbayLoginUrl = url\r\nEnd Function<\/span><\/pre>\n![\"Anmelden](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_023.png\")
<\/p>\n![\"Auslesen](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_024.png\")
<\/p>\nhttps:\/\/auth2.ebay.com\/oauth2\/ThirdPartyAuthSucessFailure?isAuthSuccessful=true&code=v%5E1.1%23i%5E1%23r%5E1%23I%5E3%23f%5E0%23p%5E3%23t%5EUl41Xzk6RTJBQjYyNEY4M0I5QTcyMTczQjlDMDA2MzFDMUU2MzFfMF8xI0VeMjYw&expires_in=299<\/pre>\n
Public <\/span>Const cStrCode As String<\/span> = \"v%5E1.1%23i%5E1%23r%5E1%23I%5E3%23f%5E0%23p%5E3%23t%5EUl41Xzk6RTJBQjYyNEY4M0I5QTcyMTczQjlDMDA2MzFDMUU2MzFfMF8xI0VeMjYw\"<\/pre>\nScopes anpassen oder erweitern<\/h2>\n
![\"Scopes](\"..\/fileadmin\/_temp_\/2025_01\/pic_460_026.png\")
<\/p>\n\n
Prozedur zum Holen von Benutzertoken und Refreshtoken<\/h2>\n
Public Function <\/span>GetEbayUserToken(strClientID As String<\/span>, strClientSecret As String<\/span>, strAuthCode As String<\/span>, _\r\n strRedirectURI As String<\/span>, strResponse As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>strTokenURL As String<\/span>\r\n Dim <\/span>strPostData As String<\/span>\r\n Dim <\/span>strCredentials As String<\/span>\r\n Dim <\/span>objHttp As <\/span>MSXML2.XMLHTTP60\r\n \r\n strTokenURL = \"https:\/\/api.ebay.com\/identity\/v1\/oauth2\/token\"\r\n \r\n strCredentials = Base64Encode(strClientID & \":\" & strClientSecret)\r\n strPostData = \"grant_type=authorization_code\" & _\r\n \"&code=\" & strAuthCode & _\r\n \"&redirect_uri=\" & URLDecode(strRedirectURI)\r\n \r\n Set<\/span> objHttp = New<\/span> MSXML2.XMLHTTP60\r\n With<\/span> objHttp\r\n .Open \"POST\", strTokenURL, False<\/span>\r\n .setRequestHeader \"Content-Type\", \"application\/x-www-form-urlencoded\"\r\n .setRequestHeader \"Authorization\", \"Basic \" & strCredentials\r\n .send strPostData\r\n \r\n If <\/span>.status = 200 Then<\/span>\r\n strResponse = .responseText\r\n GetEbayUserToken = True<\/span>\r\n Debug.Print<\/span> \"Token erhalten: \" & strResponse\r\n Else<\/span>\r\n Debug.Print<\/span> \"Fehler: \" & .status & \" - \" & .responseText\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Function<\/span><\/pre>\n