© kzenon, 123RF.com

Gutgehende Onlineshops sind selten und das Ergebnis langer Arbeit. Wer gerade erst beginnt Waren zu verticken, tut gut daran, bei einem großen Shoppingportal unterzuschlüpfen. Über APIs lassen sich eigene Warenwirtschafts- oder Buchhaltungsprogramme anbinden.

Die meisten neuen Webshops kommen, wenn überhaupt, nur holpernd in Gang. Selbst eine Suchmaschinenoptimierung der eigenen Website garantiert noch keine hohe Klick- und Kaufrate, ganz zu schweigen von der fehlenden Reputation neuer Shops. Hinzu kommen die Einstandskosten für das Aufsetzen und Anpassen der Onlineshop-Software, für Werbung sowie der Aufwand für Kauf- und Zahlungsabwicklung.

Als Lösung sehen viele aufstrebende Verkäufer große florierende E-Commerce-Plattformen an. Insbesondere Ebay und Amazon sind attraktiv, bei denen unzählige Verbraucher ihre Shoppingtouren beginnen. Die Firmen haben schon längst ihre Aktivitäten über Auktionen und Buchhandel hinaus ausgeweitet, und sie bieten ihre E-Commerce-Infrastruktur auch unabhängigen Händlern an.

Die Waren der kooperierenden Händler erscheinen automatisch in den Trefferlisten der Verbraucher, und auch die Kaufabwicklung – Warenkorb füllen, Versand- und Zahlungsmethoden wählen, “Jetzt kaufen!” – läuft außerhalb des eigenen Shops. Services wie Zahlungsabwicklung oder Versand, hier gibt es Unterschiede in Umfang und Detail, sind ebenfalls möglich. Das alles ist nicht kostenlos, sowohl Ebay als auch Amazon verdienen an jedem verkauften Artikel mit.

Kleinstanbieter managen ihre Waren und Geschäftsvorgänge per Webinterface von Hand. Aber schon bei wenigen Transaktionen pro Tag ist eine manuelle Pflege der Vorgänge ebenso mühsam wie fehleranfällig. Hier kommt Fremdsoftware ins Spiel, die auf die E-Commerce-Infrastruktur des Anbieters zugreift, allerdings nicht über die Webseiten, sondern über Standardschnittstellen.

Jenseits von Angebot und Verkauf existieren noch andere Anwendungsfälle, die der Händler besser über eigene Programme abgewickelt. Dazu zählen das Einblenden von Suchergebnissen auf der eigenen Website oder die Marktforschung. Der Bedarf an Schnittstellen ist also vorhanden und sowohl Ebay als auch Amazon bieten hier umfassende Lösungen an. Als willkommener Nebeneffekt drängen beide Internetkonzerne Software zurück, die ihre Websites maschinell bedienen. Diese im frühen Web verbreitete Technik ist einfach zu fehleranfällig, da vom konkreten Webdesign abhängig.

Ebay

Den Einstiegspunkt in die maschinellen Schnittstellen bei Ebay eröffnet [1]. Hier findet der Entwickler Guides, Tutorials, die APIs, Developer-Kits, eine Knowledgebase und vieles mehr. Die Ebay-APIs sind sehr umfangreich, Tabelle 1 gibt einen Überblick. Alleine die Dokumentation des Trading-API umfasst 1380 PDF-Seiten. Die APIs sind auch nicht überschneidungsfrei, Suchfunktionen zum Beispiel gibt es in mehr als einer Kategorie. Eine der Ursachen: Die Schnittstellen spiegeln die historische Entwicklung sowie regionale Besonderheiten wider.

Ebay stellt neben der Produktionsumgebung auch eine so genannte Sandbox bereit. Programme, die nur Suchfunktionen nutzen, können Entwickler gefahrlos in ihrer Produktionsumgebung testen, für alles Invasive ist die Sandbox gedacht. Ebay beschränkt die Anzahl der API-Aufrufe pro Benutzer auf 5000 pro Tag. Wer seine Anwendung dem kostenlosen Kompatibilitäts-Check unterzieht, kann dieses Limit auf eineinhalb Millionen Aufrufe pro Tag erhöhen.

Voraussetzung für die Nutzung von APIs ist die kostenlose Mitgliedschaft im “eBay Developers Program”. Sie zu erwerben dauert nur wenige Minuten: Auf der Startseite des Ebay Developer Network [1] sitzt direkt unter dem Login-Button ein Link zur Registrierung. Obwohl Ebay international agiert, können sich die Webentwickler von Ebay aber offenbar keine Stadt mit Umlauten im Namen vorstellen. Doch unabhängig von dieser kleinen Falle klappt die Registrierung ohne Probleme.

Nachdem der Anwärter User-ID, Passwort und diverse Adressdaten eingegeben hat, schickt ihm Ebay eine E-Mail mit einem Aktivierungslink. Der Klick hierauf befördert ihn zum Ebay-Developer. Über die Verwaltungsoberfläche des eigenen Accounts lässt sich der Entwickler nun einen Zugriffsschlüssel für die Sandbox und die Produktionsumgebung erzeugen. Sinnigerweise hat Ebay entsprechende Links in die Aktivierungsseite eingebaut, mit wenigen Klicks ist auch dies erledigt. Der Entwickler darf loslegen.

Ebay hat eine Web-fähige Beispielanwendung vorbereitet, die per Javascript nach Artikeln sucht (siehe Listing 1 und Abbildung 1). Sie eignet sich weniger als Vorlage denn als einfache Verifikation, ob die Registrierung und Schlüsselgenerierung geklappt haben.

https://www.x.com/content/quick-start-guide] eine Javascript-Beispielapplikation online bereit (siehe Listing 1).” width=”300″ height=”187″ /> Abbildung 1: Ebay stellt unter [https://www.x.com/content/quick-start-guide] eine Javascript-Beispielapplikation online bereit (siehe Listing 1).

01 <html>
02 <head>
03 <title>eBay Search Results</title>
04 <style type="text/css">body { font-family: arial,sans-serif;} </style>
05 </head>
06 <body>
07 <h1>eBay Search Results</h1>
08 <div id="results"></div>
09
10 <script>
11 function _cb_findItemsByKeywords(root)
12 {
13   var items = root.findItemsByKeywordsResponse[0].searchResult[0].item || [];
14   var html = [];
15   html.push('<table width="100%" border="0" cellspacing="0" cellpadding="3"><tbody>');
16
17   for (var i = 0; i < items.length; ++i)
18   {
19     var item     = items[i];
20     var title    = item.title;
21     var pic      = item.galleryURL;
22     var viewitem = item.viewItemURL;
23
24     if (null != title && null != viewitem)
25     {
26       html.push('<tr><td>' + '<img src="' + pic + '" border="0">' + '</td>' +
27         '<td><a href="http://'%20+%20viewitem%20+%20'" target="_blank">' + title + '</a></td></tr>');
28     }
29   }
30   html.push('</tbody></table>');
31   document.getElementById("results").innerHTML = html.join("");
32 }
33 </script>
34
35 <!--
36 Use the value of your appid for the appid parameter below.
37 -->
38 <script src=http://svcs.ebay.com/services/search/FindingService/v1?SECURITY-APPNAME=xxx&OPERATION-NAME=findItemsByKeywords&SERVICE-VERSION=1.0.0&RESPONSE-DATA-FORMAT=JSON&callback=_cb_findItemsByKeywords&REST-PAYLOAD&keywords=TP-Link%203g&paginationInput.entriesPerPage=3>
39 </script>
40 </body>
41 </html>

Mit Webservices programmieren

Ebay setzt bei seinen Schnittstellen im Großen und Ganzen auf klassische Webservices, also auf Soap (XML Remote Procedure Calls). Der Vorteil: Aus der Schnittstellenbeschreibung WSDL erzeugen Generatoren Clientcode für fast jede Programmiersprache. Letztlich schickt der Client ein XML-Dokument an den Ebay-Server und erhält von dort ein XML-Dokument zurück. Der generierte Clientcode kümmert sich um das Ein- und Auspacken dieser Dokumente.

Wer schon mit WSDL-Generatoren gearbeitet hat, kennt die damit einhergehenden Probleme. Meist muss ein Entwickler um den generierten Code einen Wrapper schreiben, der die Objekte und APIs auf das für die Programmiersprache übliche Objektmodell abstrahiert. Für Java und Dotnet hat sich Ebay diese Mühe gemacht und stellt entsprechende SDKs bereit [2]. Sie decken aber nur ein Subset der APIs ab, nämlich das wichtige Trading-API sowie das Finding-API.

Die SDKs zu verwenden erweist sich für geübte Programmierer nicht als Hürdenlauf. In Listing 2 ist ein Java-Beispiel abgedruckt, das fast das Gleiche tut wie das Ebay-eigene Beispiel aus Listing 1. Einzige Voraussetzung für das Kompilieren und Ausführen ist, dass die Jars aus dem Finding Kit [3] im Classpath sind. Abbildung 2 zeigt das Ergebnis.

Listing 2.” width=”300″ height=”175″ /> Abbildung 2: Das Suchergebnis des Java-Programms aus Listing 2.

Im Programm konfiguriert der Entwickler in den Zeilen 21 bis 23 den Client, er setzt die zugeteilte Application-ID in Zeile 24 (im Beispielprogramm ist dies der erste Aufrufparameter) und verweist per Global-ID auf die Ebay-Site, die er abfragen möchte. Eine Liste der IDs gibt es auf den Developer-Seiten oder der Entwickler fragt sie per API ab.

Die eigentliche Abfrage erfolgt über die Klasse »FindItemsByKeywords« (Zeilen 30 bis 32). Den Suchbegriff übergibt der Anwender im Beispiel als zweites Programmargument. Die Zeilen 34 bis 36 sorgen dafür, dass pro Abfrage nicht alle Treffer, sondern nur »ENTRIES_PER_PAGE« zurückkommen. Die Gesamtzahl der Treffer sowie die notwendigen Abfragen für alle Treffer liest das Programm nach der ersten Serverantwort in den Zeilen 46 bis 50. Um das Beispiel kurz zu halten, fehlt im Listing 2 letztlich die Iteration über alle notwendigen Requests. Dafür wären weitere Requests notwendig, die im »PaginationInput« -Objekt jeweils die angeforderte Seite setzen müsste.

01 import java.util.List;
02
03 import com.ebay.services.client.ClientConfig;
04 import com.ebay.services.client.FindingServiceClientFactory;
05 import com.ebay.services.finding.FindItemsByKeywordsRequest;
06 import com.ebay.services.finding.FindItemsByKeywordsResponse;
07 import com.ebay.services.finding.FindingServicePortType;
08 import com.ebay.services.finding.PaginationInput;
09 import com.ebay.services.finding.PaginationOutput;
10 import com.ebay.services.finding.SearchItem;
11
12 public class SearchEbay {
13
14   public static final int ENTRIES_PER_PAGE = 10;
15
16   public static  void main(String[] args) {
17     try {
18
19       // setup environment -------------------------
20
21       ClientConfig config = new ClientConfig();
22       config.setApplicationId(args[0]);
23       config.setGlobalId("EBAY-DE");
24
25       FindingServicePortType serviceClient =
26         FindingServiceClientFactory.getServiceClient(config);
27
28       // setup request ------------------------------
29
30       FindItemsByKeywordsRequest request =
31         new FindItemsByKeywordsRequest();
32       request.setKeywords(args[1]);
33
34       PaginationInput pi = new PaginationInput();
35       pi.setEntriesPerPage(ENTRIES_PER_PAGE);
36       request.setPaginationInput(pi);
37
38       // execute request ----------------------------
39
40       FindItemsByKeywordsResponse result =
41         serviceClient.findItemsByKeywords(request);
42
43       // handle result ------------------------------
44
45       System.out.println("\nStatus = "+result.getAck());
46       PaginationOutput po = result.getPaginationOutput();
47       System.out.println("Anzahl Treffer gesamt: " +
48         po.getTotalEntries());
49       System.out.println("Notwendige Requests: " +
50         po.getTotalPages());
51
52       System.out.println("Anzahl Treffer in diesem Request: " +
53         result.getSearchResult().getCount() + "\n");
54
55       System.out.println("------ Trefferliste ---------\n");
56
57       List<SearchItem> items = result.getSearchResult().getItem();
58       for(SearchItem item : items) {
59         System.out.println(item.getTitle());
60       }
61
62     } catch (Exception ex) {
63       // handle exception if any
64       ex.printStackTrace();
65     }
66   }
67 }

Amazon

Auch Amazon bietet maschinelle Schnittstellen für die Verkaufsunterstützung an: die “Amazon Marketplace Webservices” (Amazon MWS, [4]). Sie richten sich an (in Amazon-Sprache) “Power-Anbieter” mit einem Verkaufsvolumen von mehr als 40 Artikeln pro Monat. Die Grundgebühr beträgt hierfür pro Monat aktuell 39 Euro. Beauftragt ein Verkäufer einen Entwickler, so wird noch mal der gleiche Betrag fällig, denn jeder Entwickler benötigt ein Verkäuferkonto.

Die Einstiegshürden liegen also hoch, das Angebot richtet sich offensichtlich an große Shops. Trotz der hohen Preise gibt sich Amazon knauserig bei den Transaktionen. Pro API gibt es eine Obergrenze an gleichzeitigen Requests, typischerweise zehn. Ist sie erreicht, beträgt die so genannte Restore Rate ein Request pro Minute. 20 API-Aufrufe dauern also mindestens 10 Minuten. Amazon schützt damit seine Infrastruktur und zwingt den Entwickler zu effizientem Transaktionsmanagement. Wer aber in der eigenen Anwendung zum Beispiel seinen Lagerbestand in Echtzeit überwachen will, kommt damit nicht weit.

Auch Amazon teilt seine Schnittstellen in Kategorien (siehe Tabelle 2). Technisch hat der Konzern seine APIs von Webservices auf proprietäre Schnittstellen umgestellt, je API bietet er passende SDKs an (PHP, C#, Java). Für Anwendungsentwickler bedeutet dies eine Vereinfachung, allerdings schränken die neuen Schnittstellen den Spielraum für die Client-Programmiersprache ein. Amazon stellt auch einen Leitfaden für die Migration von den alten, Soap-basierten APIs bereit.

Fazit

Beide große E-Commerce-Sites unterstützen den Zugriff Dritter auf ihre Datenbestände in umfassender Weise. Ebay hat dabei die Nase vorn, denn die Einstiegshürden liegen niedrig. Ein Betreiber einer Liebhaberseite für Haustiere könnte etwa ohne Probleme bei einer Suchanfrage auf seiner Site zusätzlich zu den lokalen Treffern auch noch aktuell angebotene Produkte auf Ebay einblenden. Ebay profitiert von den erhöhten Umsätzen und beteiligt den Site-Betreiber.

Amazon dagegen beschränkt seine Market-Webservices auf Profi-Seller. Wer nur das Angebot auf Amazon abfragen will, muss sich mit dem Screen-Scraping der normalen Amazon-Website und seinen Nachteilen zufrieden geben. Zum Glück hat Amazon Bücher im Angebot, die diese Technik erläutern.