Verkaufsfördernde Maßnahmen

Amazon per API auf die eigene Webseite bringen
Kommentare

Werbung ist bekanntlich das unangefochtene Mittel zur Refinanzierung der eigenen Webseite. Wer dennoch auf plumpe, undifferenzierte Bannerprogramme verzichten will und eine Ahnung bezüglich der Interessen oder Bedürfnisse seiner Leser zu haben meint, kann aus Amazons Warenbestand per API ein passendes und hoffentlich verkaufsträchtiges Angebot zusammenschustern.

Amazon vergütet den Verkauf eigener Produkte mit einer Provision, sofern der Kunde seine Shoppingtour auf einer Partnerseite begonnen hat. In den Worten des Onlinemarketings gesprochen, handelt es sich hier also um eine Pay-per-Sale-Lösung, und kein Pay-per-View oder Pay-per-Click. Zugegebenermaßen reicht es, wenn der Kunde in spe seinen Weg über einen präparierten Textlink oder ein wie auch immer gearteten Banner zum Onlinehändler findet. Beides sind Werbeformen, die Amazon anbietet, die allerdings nichts mit den Begehrlichkeiten Ihres Webseitenbesuchers zu tun haben müssen. Um an die Provision des hoffentlich stattfindenden Einkaufs zu kommen, erstellen Sie im einfachsten Fall einen Link wie HIER KLICKEN, UM ZU AMAZON ZU GELANGEN! und hinterlegen ihn mit Ihrem eigenen Partnercode, der Sie bei Amazon eindeutig identifiziert. Die Wahrscheinlichkeit, dass ein Besucher diesem Aufruf folgt, ist aber eher gering – diverse Webmaster wissen ein Lied davon zu singen, wie wenig Erlös Werbung auf der eigenen Seite einbringt, wenn Sie den Leser nicht interessiert. Auffälliger ist da schon das ein oder andere Werbebanner – Amazon hat zig fertige Grafiken in den unterschiedlichsten Größen auf Lager. Grafiken und Textlinks lassen sich leicht in die eigene Webseite einbauen, ohne dass die eigene Internetpräsenz sofort in einen Webshop verwandelt wird. Wer auf Content-Management-Systeme setzt, verfügt nicht selten zum einen über reservierte Stellen für Werbung im eigenen Layout als auch über das dazugehörige Verwaltungsmenü im CMS-Backend. Für Webmaster allerdings, die einen kompletten Webshop mithilfe des weltgrößten Onlinehändlers aufsetzen wollen, taugt das in den wenigsten Fällen. Zu groß ist der anhaltende manuelle Pflegeaufwand und zu gering das Maß an Flexibilität. Amazons Antwort darauf sind die so genannten aStores – vorgefertigte Shoplösungen, die sich in die eigene Webseite einbinden lassen. Per Wizard lassen sich die Seitenstruktur, die feilgebotenen Produkte und das farbliche Layout zusammenstellen. Der „fertige“ Shop wird dann per Forwarding-Link für den eigenen URL oder als iframe in die eigene Seite integriert. Bei aller Liebe zum Detail, auch nach der Konfiguration im Wizard erinnert das Look and Feel noch sehr an die Herkunft.

Amazons verlängerter Arm

Der Königsweg für den programmierwilligen Webmaster ist das Product Advertising API. Amazon öffnet damit Tür und Tor für seine Werbepartner, überlässt ihm gleichzeitig einen beträchtlichen Anteil der produktspezifischen Daten, weiß dem Missbrauch mit der großen Datenschaufel aber auch durch geeignete Mittel Grenzen zu setzen. Nahezu alles, was Sie bei Amazon auf den Produktdetailseiten sehen, können Sie über das API auch in Ihre eigene Webseite integrieren. Die Aufteilung ist klar: Der Reseller kümmert sich um die Darstellung und Vermarktung, sorgt auf diese Weise für volle Warenkörbe und verführt den potenziellen Kunden letztlich, zum Kauf auf http://www.amazon.de zu wechseln. Amazon übernimmt die Abwicklung, Logistik und das gesamte Kundenmanagement. Folgende Liste fasst die Funktionalität des API im Einzelnen zusammen:
  • Produktdetails abfragen, inklusive unterschiedlicher Verkäuferangebote und Kundenrezensionen
  • Details zur Amazon-eigenen Produkthierarchie auslesen
  • Einen Warenkorb erstellen und pflegen
  • Ähnliche Produkte für einen bestimmten Artikel ermitteln
  • Wunschlisten auslesen
Um für einen einzelnen Artikel Daten abzurufen oder einen Warenkorb zu verwalten, ist jedes Produkt mit einer Kennnummer, der ASIN (Amazon Standard Identification Number), eindeutig gekennzeichnet. Diese Einteilung ist von Amazon vorgenommen worden, setzt aber bei manchen Produktgruppen wie Büchern auf bekannte Standards auf (der ehemals zehnstelligen ISIN). Eine ASIN ist eine alphanumerische bzw. möglicherweise auch rein numerische Zeichenkette, bestehend aus zehn Zeichen. Jeder Artikel ist bei Amazon über seine ASIN unter der Adressehttp://www.amazon.de/dp/ASIN erreichbar. Was in obiger Liste der Funktionen explizit fehlt, sind Methoden zur Authentifizierung oder Synchronisation des Benutzerstatus (z. B. Import des Warenkorbs von einem vorigen Besuch im weltgrößten Onlineversandhaus). Für die Partnerseite ist der Amazon-Account eines Besuchers tabu, der Einkäufer bleibt somit anonym – so anonym wie man heutzutage im Internet bleiben kann. Sagen wir stattdessen besser: Die Identität des Anwenders wird von Amazon nicht über das Product Advertising API an die Partnerseite weitergereicht. Das bedeutet, Benutzername und Passwort werden erst nach dem Wechsel zu Amazon angegeben; seine Anonymität aufzugeben, ist erst bei Kaufabwicklung notwendig. Ein Sicherheitsrisiko für Nutzerdaten auf Partnerseiten wird dadurch vermieden.

Anmeldung beim Amazon-Partnerprogramm

Vor dem Einstreichen von Provisionen steht die Anmeldung beim Amazon-Partnerprogramm. Vor dem Einstreichen von Provisionen steht die Anmeldung beim Amazon-Partnerprogramm. Diese erfolgt über einen Link aus dem eigenen Nutzerprofil und steht jedem offen, der bislang ein Amazon-Käuferkonto besitzt. Den direkten Zugang zum Partnerprogramm erhalten Sie hier. Durch Anmeldung am Partnerprogramm bekommen Sie eine Associate ID der Form ihrname-21, die Sie an Links von Ihrer Seite zu Amazon anhängen, damit Ihnen eine künftige Verkaufsprovision korrekt zugeordnet werden kann. Bevor Sie mit dem Werben starten können, steht Ihnen aber noch die Registrierung und Beschreibung Ihrer Domains im Partnernet bevor. Um Zugriff auf das Product Advertising API zu bekommen, benötigen Sie darüber hinausgehend noch einen Account bei den Amazon Web Services . Die Anmeldung erfolgt wiederum mit Ihrem üblichen Amazon-Nutzernamen/-Passwort und versorgt Sie mit ein paar von öffentlichen bzw. privaten Zugangsschlüsseln, die bei jedem API-Request anzufügen sind.

Wenn man hineinruft, dann schallt es heraus …

Für alle vorgenannten Funktionalitäten bietet die Product Advertising API Operationen an. Sie werden jeweils über REST-Aufrufe angetriggert. Die Rückantwort besteht seinerseits aus einem XML String, in dem entweder die Artikelinformationen oder Fehlermeldungen zu finden sind. Für die Implementierung einer PHP-Klasse, mit der sich Amazons API anbinden lässt, bedeutet, sie muss über grundlegende Methoden verfügen, die den REST String zusammensetzen, verschicken und die Antwortdaten in ein verwertbares Format bringen. In unserem Fall wird das SimpleXML sein. Listing 1 stellt den ersten Teil einer API-Implementierung dar, die diese maßgebenden Methoden enthält und die durch die Methoden der weiteren Listings ergänzt wird. Die ersten drei privaten Klassenobjekte sind in der eigenen Instanz durch diejenigen Werte des eigenen Accounts zu ersetzen. Alternativ lassen sie sich auch in einer Konstruktormethode setzen, die hier der Einfachheit halber fehlt. Das Attribut $base_url hingegen ist nur dann anzupassen, wenn nicht die deutsche Amazon-Seite Ziel Ihrer Aufrufe ist. Bis auf die Top-Level-Domain sind die URLs für länderspezifische API-Aufrufe aber gleich. Als Letztes dient das Attribut $request zum Zwischenspeichern eines REST Strings, bevor er gesendet wird. Diese Parkmöglichkeit ist hauptsächlich in der Testphase der Klasse notwendig, wenn der REST String noch einmal angezeigt oder geloggt werden muss. Die Methode checkASIN() hat primär nichts mit den API-Aufrufen zu tun, sondern stellt mit einem Syntaxcheck in den folgenden Methoden lediglich sicher, dass wir keine ungültigen ASINs an Amazon übermitteln. Weil wir die grundlegenden Methoden buildRequest() undsendRequest() nur indirekt über die noch zu ergänzenden Methoden für die API-Operationen aufrufen, sind auch sie als private eingestuft. Listing 1
class Amazon{

private $associate_tag = 'deinname-21';
private $aws_access_key_id = 'RANDOMACCESSKEY';
private $aws_secret_access_key = 'RANDOMSECRETACCESSKEY';
private $base_url = 'http: //ecs.amazonaws.de/onca/xml?Service=AWSECommerceService&AWSAccessKeyId=%s&';
private $request = '';

private static function checkAsin($asin){
return (bool) preg_match("/[A-Zd]{10}/",$asin);
}

private function buildRequest($url_params){

//Sort the URL parameters
if(empty($url_params) || !is_array($url_params)) return false;

//reset parameters
$this->request = '';
$url_parts = array();
foreach(array_keys($url_params) as $key) $url_parts[] = $key."=".$url_params[$key];
sort($url_parts);

//Build and encode the request URL
$this->base_url = sprintf($this->base_url, $this->locale, $this->aws_access_key_id);
$url = $this->base_url . implode('&',$url_parts);
$host = parse_url($this->base_url . implode('&',$url_parts),PHP_URL_HOST);

//Add Timestamp
$timestamp = gmstrftime('%Y-%m-%dT%H:%M:%S.000Z');
$url = $url. '&Timestamp=' . $timestamp;
$paramstart = strpos($url,'?');
$workurl = substr($url,$paramstart+1);
$workurl = str_replace(",","%2C",$workurl);
$workurl = str_replace(":","%3A",$workurl);
$params = explode("&",$workurl);
sort($params);

//Add Signature
$signstr = "GETn" . $host . "n/onca/xmln" . implode("&",$params);
$signstr = base64_encode(hash_hmac('sha256', $signstr, $this->aws_secret_access_key, true));
$signstr = urlencode($signstr);
$signedurl = $url . "&Signature=" . $signstr;
$this->request = $signedurl;
return true;
}

private function sendRequest(){
//Send REST
if($this->request === '') return false;
$c = curl_init($this->request);
curl_setopt($c, CURLOPT_HEADER, false);
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($c);
curl_close($c);

//Return XML
return simplexml_load_string($response);
}
}

Um einen REST-Aufruf an Amazon zu verschicken, müssen letztlich beide private Methoden aufgerufen werden. Die erste Methode buildRequest() setzt die Aufrufparameter zu einem gültigen REST String zusammen und fügt standardmäßig den von Amazon geforderten aktuellen Zeitstempel und die ebenfalls obligatorische Signatur ein. Erst mit dem Aufruf von sendRequest() werden die Daten wirklich verschickt. Wir bemühen dafür cURL und konvertieren die Rückgabe in ein SimpleXML-Objekt. Wie bereits erwähnt, handelt es sich bei der Antwort in jedem Fall um einen XML String – es sei denn, der Aufruf kommt aufgrund von Netzproblemen gar nicht bei Amazon an. Für die kommenden Methoden, die die API-Operationen verkörpern, verbleibt dann lediglich noch die Konfiguration. Das bedeutet, die Methode stellt aus den Aufrufparametern und den Klassenattributen ein Parameter-Array zusammen, das der Methode buildRequest() übergeben wird. Der Einfachheit halber benennen wir die Methoden in den folgenden Listings 1:1 nach den Operationen der Product Advertising API, größtenteils definieren wir sie zudem als public . Einer der wichtigsten Parameter neben dem Namen der Operation werden die so genannten ResponseGroups sein. Damit gibt man an, welche Informationen in dem XML String enthalten sein sollen, mit dem Amazon auf den Aufruf antwortet. Die Einzelwerte sind in sinnvollen Gruppen zusammengefasst, so bestehen z. B. die Gruppe Cart (für Warenkorbdetails), Images (Artikelfotos unterschiedlicher Größen) oder OfferSummary (aktuelle Angebotsdetails). Hinzu kommen Gruppen, die wiederum andere Gruppen zusammenfassen und ihrem Umfang nach bezeichnende Namen wie Small, Medium und Large tragen.

Ein Katalog zum Blättern

Haben Sie eine Vorstellung davon, wie viele Artikel auf http://www.amazon.de im gesamten Produktkatalog bereitstehen? Eingenommen nicht nur diejenigen Produkte, die von Amazon selbst angeboten werden, sondern auch von tausenden weiteren Onlinehändlern, die die Webseite nur als Verkaufsplattform nutzen. Gemessen an der zehnstelligen ASIN, die aus alphanumerischen und numerischen Zeichen bestehen kann, sind es theoretisch bis zu 3,6 Billiarden. Nun gut, ganz so viele werden es in der Realität nicht sein. Um Ordnung im Produktkatalog zu halten, sind die Artikel in (derzeit 44) disjunkten Suchindizes kategorisiert. Die reichen von den klassischen Geschäftsfeldern Bücher, DVDs und Elektronik über Musik und Musiktitel bis hin zu Gartenzubehör und Nahrungsmittel. Zumal jeder Index immer noch eine beträchtliche Größe annehmen kann (führen Sie sich die Menge aller veröffentlichten Bücher vor Augen), existiert in jedem Index eine weitere mehrstufige Kategorisierung, die sich von Index zu Index unterscheidet. Artikel sind dazu in so genannte BrowseNodes zusammengefasst. Jeder BrowseNode wird durch eine eindeutige Nummer identifiziert. Der Suchindex Bücher umfasst direkt ein gutes Dutzend BrowseNodes für beispielsweise Neuheiten, Gebraucht, Homepage oder Kategorien. Unterhalb von Kategorien steht dann die Einteilung, die man vielleicht schon auf oberster Ebene erwartet hätte: Belletristik, Computer & Internet, Kochen & Genießen und derer mehr. Schon jetzt wird klar, dass es mehrere Wege zu einem Artikel gibt: Ein Buch wie „PHP 5.3 und MySQL 5.5“ findet sich eine Zeitlang zum einen unter Neuheiten und gleichzeitig – und langfristig – unter Computer & Internet. Die BrowseNodes sind entgegen der Indizes nicht disjunkt. Außerdem gibt es bei der Verwendung der BrowseNodes in API-Aufrufen zu bedenken, dass sich die IDs gegebenenfalls mit der Zeit ändern können. Auf oberster Ebene sind die eindeutigen Nummern laut API-Dokumentation als stabil im Sinne von langfristig gleich bleibend anzusehen, je weiter man in der Hierarchie der BrowseNodes jedoch nach unten absteigt, desto instabiler werden sie. Aus diesem Grund enthält unsere Klasse Amazon eine Methode BrowseNodeLookup(), mit der sich die aktuelle Hierarchie nachvollziehen lässt (Listing 2). An dieser Methode ist der idealtypische Aufbau einer public-Methode für die Klasse Amazon sichtbar: Sie besteht nur aus der Validierung der Eingabeparameter, dem Aufbau des Parameter-Arrays ( $url_params ) und dem Aufruf der private-Methoden. Listing 2
public function BrowseNodeLookup($node){

if(empty($node) || ($node !== filter_var($node,FILTER_VALIDATE_INT))) die("$node ist keine Nummer");

$url_params = array(
'Operation'=>'BrowseNodeLookup',
'ResponseGroup'=>'BrowseNodeInfo',
'BrowseNodeId'=>$node
);

return ($this->buildRequest($url_params))? $this->sendRequest():false;

}

public function ItemSearch($keywords, $item_page=1, $search_index='All',  $browse_node=null, $response_group = array()){

if($keywords == '') return false;
if($search_index == '') $search_index = 'All';
if(is_array($response_group) && !empty($response_group)){
$response_group = implode(',',$response_group);
} else {
$response_group = 'ItemAttributes,Images,OfferFull,EditorialReview,Reviews,SalesRank,BrowseNodes';
}
if(!is_integer($item_page)) $item_page = 1;

$url_params = array(
'Operation'=>'ItemSearch',
'ItemPage'=>$item_page,
'AssociateTag'=>$this->associate_tag,
'Version'=6gt'2010-09-01',
'ResponseGroup'=>$response_group,
'SearchIndex'=>$search_index,
'Keywords'=>rawurlencode($keywords)
);
if(!is_null($browse_node)) $url_params['BrowseNode']=$browse_node;

return ($this->buildRequest($url_params))? $this->sendRequest():false;
}

Das Kernstück zur Suche im Produktkatalog ist die Funktion ItemSearch. Damit lassen sich für einen gewünschten Begriff häppchenweise Artikeldaten von den Amazon-Servern laden. Häppchenweise deshalb, weil bereits eine Aufteilung in Seiten, mit jeweils zehn Artikeln, in den Suchergebnissen enthalten ist. Aus diesem Grund ist der Operation ItemSearch die gewünschte Seitenzahl stets mitzugeben. Geschieht dies nicht, wird 1 als Standard verwendet. Maximal sind 400 Seiten pro Suche möglich. Übersteigt die Anzahl der Suchergebnisse die damit maximale Menge von 4000 (400 Seiten mit je zehn Ergebnissen), hat man Pech gehabt. Wenig überraschend schlägt Amazon in der Dokumentation vor, eine genauere Suche durchzuführen. So viel zu der eingebauten Begrenzung zum Massendownload von Artikeldaten.
Das Kleingedruckte Wer das Product Advertising API nutzt, akzeptiert selbstverständlich Amazons Nutzerbedingungen. Es empfiehlt sich, diese genau zu lesen, weil die darin explizit genannten Bedingungen Konsequenzen für selbst geschriebene Applikationen haben. Anbei das Wichtigste in Kürze – was nicht vom Lesen der gesamten Nutzerbedingungen entbindet. Das Caching von API-Daten ist generell erlaubt, solange es sich dabei nicht um Artikelbilder handelt. Die Links zu den Bildern dürfen bis zu 24 Stunden lang gespeichert werden. Sämtliche andere Daten, die per Product Advertising API abgerufen werden, sind ebenfalls maximal 24 Stunden nachzuhalten. Die einzige Ausnahme ist die ASIN: Sie darf auf unbestimmte Zeit gecacht werden. Bei Informationen zu Preisen oder zur Verfügbarkeit gilt weiterhin: Werden sie länger als eine Stunde zwischengespeichert, so ist bei der Anzeige auf der eigenen Webseite Datum/Zeitpunkt mitzuliefern, wann diese Daten von Amazon bezogen wurden. Hinzuzufügen ist ein vorformulierter Text aus den Nutzerbedingungen. Davon abgesehen verpflichtet man sich dazu, nicht mehr als einen API Request pro Sekunde an Amazon abzusetzen. Das gilt pro Instanz der eigenen Applikation, haben Sie also mehr als eine Seite, von der Requests abgehen, müssen diese API-Aufrufe nicht synchronisiert und zur Not ausgebremst werden.

Husch ins Körbchen

Genauso einfach wie das Herunterladen von Artikeln über die API, ist es auch, sie in einem Warenkorb zu sammeln. Dazu teilt man Amazon lediglich mit, wie viele Stücke einer ASIN aufzunehmen sind. Der Warenkorb selbst wird über eine Kombination einer Warenkorb-ID (bestehend aus Nummern und Bindestrichen) und einem korrespondierenden Hash-Wert identifiziert. Vor dem Füllen steht aber bekanntlich das Erzeugen eines Warenkorbs. In Listing 3 sind die dazugehörigen Operationen umgesetzt: CartCreate() wird nur indirekt über CartAdd() aufgerufen. Besteht beim Hinzufügen also noch keine Cart-ID, wird erst einmal eine erzeugt. Mit CartModify() lässt sich der Inhalt eines Warenkorbs aktualisieren. Was in Listing 3 nicht vorhanden ist, sind zusätzliche Funktionen wie das Löschen eines Warenkorbs. Übrigens: Um das Löschen kann man, muss man sich aber nicht explizit kümmern. Ein Warenkorb wird bei Amazon sieben Tage lang gespeichert, gemessen am letzten Aufruf. Nach sechs Tagen Stillstand kann man also einen neuen Artikel hinzufügen oder einen bestehenden Löschen und verlängert damit die Lebensdauer des Korbs um weitere sieben Tage. Listing 3
private function CartCreate($asin=null,$quantity=1){

if(!$this->checkAsin($asin)) return false;
$url_params = array(
'Operation'=>'CartCreate',
'AssociateTag'=>$this->associate_tag,
'Item.1.ASIN'=>$asin,
'Item.1.Quantity'=>$quantity
);

return ($this->buildRequest($url_params))?$this->sendRequest():false;
}

public function CartAdd($cid,$chmac,$asin,$quantity=1){

if(!$this->checkAsin($asin)) return false;
$quantity = (int) $quantity;

if($cid === null) {
return $this->CartCreate($asin, $quantity);
}

$url_params = array(
'Operation'=>'CartAdd',
'AssociateTag'=>$this->associate_tag,
'CartId'=>$cid,
'HMAC'=>$chmac,
'Item.1.ASIN'=>$asin,
'Item.1.Quantity'=>$quantity
);

return ($this->buildRequest($url_params))? $this->sendRequest():false;
}

public function CartModify($cid,$chmac,$citem,$quantity=1){

if(!$this->checkAsin($asin)) return false;
$quantity = (int) $quantity;

if($cid === null){
return $this->CartCreate($asin,$quantity);
} else {
$url_params = array(
'Operation'=>'CartModify',
'AssociateTag'=>$this->associate_tag,
'CartId'=>$cid,
'HMAC'=>$chmac,
'Item.1.CartItemId'=>$citem,
'Item.1.Quantity'=>$quantity
);

return ($this->buildRequest($url_params))? $this->sendRequest():false;
}
}

Im zurückgelieferten XML String der Operationen CartCreate() und CartAdd() befindet sich neben den IDs/Hashes übrigens noch die so genannte PurchaseURL , also diejenige Internetadresse, mit der der Webseitenbesucher zu Amazon gelangt und dabei seinen Warenkorb behält (Abb. 1).
Abb. 1: Beim Wechsel zu Amazon bleibt der Warenkorb erhalten

Abb. 1: Beim Wechsel zu Amazon bleibt der Warenkorb erhalten

Der eigene Shop

Mit den Methoden der Listings 1 bis 3 umfasst die Klasse Amazon alle grundlegenden Operationen, um als Backend für einen eigenen Shop zu fungieren. Es würde an ein Wunder grenzen, wenn es nicht bereits einige PHP-Klassen gäbe, die diese API nicht schon angebunden hätten. Im Amazon-Partnernet findet sich bereits eine gute Implementierung in den Beispielcodes. Darüber hinaus gibt es eine Library für das PHP-Framework CodeIgniter . Und zu guter Letzt bietet Amazon ein AWS SDK for PHP, das aus dem Projekt CloudFusion hervorgegangen ist. Der Macher von CloudFusionsteht seit März 2010 bei Amazon unter Vertrag und hat seine Library gleich mitgenommen. Hier ist ein Beispiel für die Verwendung der beschriebenen Listings zu finden: ein fiktiver Shop, der Tablets anbietet. Die Applikation setzt stark auf JavaScript und verwendet die eigene Serverseite nur noch als Proxy zum Aufruf der Product Advertising API und als Cache (Kasten: „Das Kleingedruckte“) sowie zum Logging der Nutzeraktionen.
Abb. 2: Mit Powerpoint skizzieren wir das Layout des späteren Shops

Abb. 2: Mit Powerpoint skizzieren wir das Layout des späteren Shops

Beim Einsatz eines eigenen Shops sollte man sich gleich am Anfang folgende Frage stellen – gerade wenn man ein reines Provisionsgeschäft ohne eigene Produktpalette betreibt: Was sollte den Besucher meiner Webseite dazu verleiten, einen dort beworbenen Artikel an Ort und Stelle zu kaufen? Warum sollte er nicht zu Amazon wechseln und es dort direkt einkaufen? Immerhin wird ihm das Geschäftsmodell sofort präsent sein: Unabhängig von eventuellen Amazon-Logos auf der Shopseite wird man zur Kaufabwicklung an den Onlineprimus verwiesen und benötigt dort zudem noch ein Benutzerkonto – im Shop wiederum keines. Man muss also Kaufanreize schaffen, selbst Funktionalitäten umsetzen und anbieten, die den eigenen Shop von Amazon abheben. Dies kann auf vielfältige Weise geschehen, beispielsweise eine dynamisch nachgeladene Artikelliste und die Möglichkeit, eine Handvoll Artikel auszuwählen und zum direkten Vergleich nebeneinander darzustellen. Weitere Kaufanreize schaffen es, ähnliche Produkte anzupreisen, für die sich ein Kunde zusätzlich interessieren könnte. Das kann zum Beispiel Zubehör für einen Artikel im Warenkorb sein oder aber eine Alternative zum ausgesuchten Produkt. Um Vorschläge zu unterbreiten, muss der potenzielle Kunde aber erst einmal aus der Deckung kommen und zeigen, wo seine Interessen liegen. Das tut er auf unterschiedliche Art und Weise: Entweder gibt er einen Begriff in die Suchleiste ein, oder er sieht sich die Detailseite bestimmter Produkte an. Im einfachsten Fall sammelt er Artikel in seinem Warenkorb. Amazon nutzt diese Informationen sehr offen und exzessiv aus. Wenn Sie online erst einmal einen Korkenzieher gekauft haben, weil der alte auf der letzten Party verschwunden ist, können Sie sich sicher sein, bei den nächsten Besuchen auf http://www.amazon.de diverse Angebote zu Küchenkleingeräten auf der Startseite zu finden. Dahinter verbirgt sich eine klassische Assoziationsanalyse, besser bekannt als Warenkorbanalyse: Basierend auf den vergangenen Einkäufen aller Kunden wird ermittelt, welche Artikel beim Kauf von Produkt xy zusätzlich im Einkaufskorb landeten. Das Product Advertising API bietet diese Funktionalität übrigens bereits über die Funktion SimilarityLookup an (nicht in den obigen Listings enthalten).

Fazit

Ich bin Amazon!“ könnte man denken, wenn man das Product Advertising API erst einmal nutzt und den Funktionsumfang verinnerlicht hat. Vor allen anderen Dingen ermöglicht die Programmierschnittstelle, Amazon-Daten vollständig zu integrieren – zum einen um sie nahtlos ins eigene Layout einzuarbeiten, zum anderen um sie weiter zu verarbeiten und mit eigener Funktionalität auf ihnen aufzubauen. Das ist so weder mit Text-/Bannerlinks noch mit den alternativen aStores machbar. Aus diesem Vorteil ein attraktives Werbeangebot und somit einen Provisionsertrag zu generieren, obliegt allein dem Seitenbetreiber.
Unsere Redaktion empfiehlt:

Relevante Beiträge

Meinungen zu diesem Beitrag

X
- Gib Deinen Standort ein -
- or -