Dynamisches Pricing und algorithmisches Marketing: das komplette technische Playbook
Kurz gesagt
Niveau: Profi
Führ Preise und Werbung als eine nächtliche Schleife. Lies deine Verkäufe, Bestände und Kosten und die öffentlichen Preise der Mitbewerber, schlag je Produkt einen Preis aus Strategie, Bestand und Elastizität vor, begrenze jeden Schritt und protokolliere den Grund. Nutze die Aufschlagsregel nur, wo eine echte Elastizitätsschätzung unter minus eins liegt. Miss Werbung am Profit on Ad Spend, nicht am ROAS, und verteil das Budget nach Marge, Konversion, Bestand und Marktposition. Bepreise Produkte, nie Menschen: keine geschützten Merkmale, keine Daten ohne Einwilligung. Jede Preisermäßigung nennt den niedrigsten Preis der letzten 30 Tage. Nur öffentliche Daten, nie Absprachen.
Die meisten Shops legen einen Preis einmal fest, ein Werbebudget getrennt davon, und drehen einmal im Monat von Hand an beidem. Dieses Playbook baut die Alternative in einem Shop auf Ruby on Rails und Solidus: eine nächtliche Schleife, die jeden Preis aus Kosten, Bestand, Elastizität und öffentlichen Mitbewerberpreisen setzt, innerhalb von Grenzen, die ein Mensch festlegt, und Werbegeld zum Gewinn verschiebt. Mit korrigierten Rechenbeispielen für einen erfundenen Linzer Kochgeschirrshop, dem österreichischen Recht zu Streichpreisen, persönlichen Preisen und algorithmischer Kollusion, und dem Code.
Die meisten Shops legen einen Preis einmal fest und werben dann dagegen an
So laufen Preis und Werbung in den meisten Onlineshops. Jemand legt einen Preis fest, wenn das Produkt online geht. Jemand anderes legt ein Werbebudget fest. Die Kampagnen laufen, ein Dashboard füllt sich, und einmal im Monat dreht jemand von Hand an ein paar Zahlen. Preis, Bestand, Marge und Werbeausgaben entscheiden verschiedene Leute zu verschiedenen Zeiten, und keiner sieht, was die anderen tun.
Die Alternative ist eine Schleife. Jede Nacht liest der Shop seine eigenen Verkäufe, Bestände und Kosten und die öffentlichen Preise der Mitbewerber, auf die er tatsächlich trifft. Er rechnet für jedes Produkt einen Preis aus, innerhalb von Grenzen, die ein Mensch gesetzt hat, schreibt ihn in den Shop und in den Produktfeed und verschiebt das Werbebudget zu den Produkten, die den meisten Gewinn bringen, nicht den meisten Umsatz. Dann misst er, was passiert ist, und fängt von vorn an.
Dieser Artikel ist das Playbook, um diese Schleife in einem Shop auf Ruby on Rails und Solidus zu bauen: die Ökonomie, die Formeln, das Recht, das in Österreich festlegt, was die Schleife darf, und der Code. Es ist eine Neufassung. Die erste Version hatte ein Rechenbeispiel, dessen Zahlen nicht zusammenpassten, eine Preisformel, die bei manchen Produkten bricht, eine Schnittstelle, um einzelnen Kunden unterschiedliche Preise zu zeigen, und kein Wort zum Recht. Alle vier Punkte sind unten korrigiert, und ich sage jeweils, wo.
Damit die Zahlen greifbar sind, nehme ich einen erfundenen Shop. Donauguss verkauft gusseiserne Bräter, Messersets und Pfannen aus einem Lager in Linz, unter donauguss.example. Niemand davon ist echt, alle Zahlen sind ausgedacht.
Warum ein einziger Preis Geld liegen lässt
Verschiedene Kunden zahlen für dasselbe Produkt unterschiedlich viel. Ökonomen nennen es Preisdifferenzierung, wenn man ihnen unterschiedliche Preise berechnet, und teilen sie meist in drei Grade ein. Ersten Grades heißt, jedem Menschen genau das abzuverlangen, was er höchstens zahlen würde. Zweiten Grades heißt, Varianten, Bündel oder Mengenstaffeln anzubieten und die Kunden selbst wählen zu lassen: zwei kaufen und sparen, die Geschenkausgabe oder die schlichte. Dritten Grades heißt, Gruppen, die man von außen erkennt, unterschiedliche Preise zu berechnen, etwa Studierenden, Gewerbekunden oder einem anderen Land.
Die erste Version dieses Artikels sagte, dynamische Preise näherten sich "zunehmend" dem ersten Grad, indem sie Verhaltenssignale jedes einzelnen Kunden lesen. Das habe ich aus der Maschine herausgenommen. Dieses Playbook bepreist Produkte, Ausgaben, Kanäle und Zeitpunkte, nie einzelne Menschen. Die rechtlichen Gründe stehen weiter unten, und es gibt auch einen kaufmännischen: Wer merkt, dass er für denselben Bräter mehr gezahlt hat als seine Nachbarin, kommt nicht wieder.
Rechenbeispiel: zwei Käufergruppen, ein Bräter
Der 24 cm Bräter von Donauguss kostet im Einkauf, mit Verpackung und Versand, 20 €. Angenommen, es gibt zwei Käufergruppen. Vierhundert Menschen würden bis zu 50 € zahlen (sie kaufen ein Geschenk). Sechshundert würden bis zu 35 € zahlen (sie kaufen für die eigene Küche).
Mit einem Preis für alle muss Donauguss sich entscheiden. Bei 50 € kaufen nur die Geschenkkäufer, der Gewinn ist , also 12.000 €. Bei 35 € kaufen alle, der Gewinn ist , also 15.000 €. Bei 40 €, einem Preis, der wie ein vernünftiger Kompromiss aussieht, kaufen nur die Geschenkkäufer, und der Gewinn fällt auf , also 8.000 €.
Die alte Version dieses Beispiels sagte, der Shop verkaufe 1.000 Bräter zu 40 €, und zwei Zeilen später, die 35 € Gruppe kaufe bei 40 € nicht. Beides kann nicht stimmen, also waren auch ihre "5 % mehr Gewinn" falsch.
Jetzt bekommen die Geschenkkäufer eine eigene Ausgabe: derselbe Bräter in einer bedruckten Schachtel mit Rezeptkarte, zu 50 €. Schachtel und Karte kosten 2 €, jede Geschenkausgabe bringt also Euro. Wenn sich die Gruppen sauber aufteilen, ist der Gewinn , also 20.200 €. Das sind rund 35 % mehr als beim besten Einheitspreis.
Die Worte "wenn sich die Gruppen sauber aufteilen" tragen das ganze Beispiel. Manche Geschenkkäufer nehmen den schlichten Bräter und packen ihn selbst ein. Ausgaben, Bündel und Zeitpunkte so zu gestalten, dass sich die Gruppen wirklich trennen, ist der schwierige Teil der Preisdifferenzierung zweiten Grades, und das ist eine Produktentscheidung, bevor es ein Algorithmus ist.
Die Elastizität ist die Zahl, die die Maschine braucht
Die Maschine kann nicht wissen, was jeder einzelne Mensch zahlen würde. Sie kann ungefähr wissen, wie die Verkäufe eines Produkts reagieren, wenn sich der Preis bewegt. Das ist die Preiselastizität der Nachfrage, erklärt in den Grundlagen:
ist die Elastizität, die prozentuale Änderung der verkauften Menge und die prozentuale Änderung des Preises. Eine Elastizität von heißt, eine Preiserhöhung um 10 % kostet rund 20 % der Stückzahl. Eine Elastizität von heißt, dieselbe Erhöhung kostet nur rund 5 %.
Ist die Elastizität rund um den aktuellen Preis ungefähr konstant, gibt es eine einfache Regel für den gewinnmaximalen Preis, die Aufschlagsregel:1
ist der Preis, die Grenzkosten einer weiteren Einheit (Einkaufspreis plus Verpackung, Zahlungsgebühren und der Versand, den du bezuschusst, kein Durchschnitt, in dem die Miete steckt), die Elastizität und der gewinnmaximale Preis. Die linke Seite, , ist die Marge als Anteil am Preis. Die Regel gilt nur, wo die Nachfrage elastisch ist, also bei . Die Herleitung und wie du mit einer Regression aus deinen eigenen Bestellungen schätzt, steht in Nachfrage und Preiselastizität mit Regression modellieren, die Definition im Grundlagen Eintrag zur Elastizität.
Rechenbeispiel: die Aufschlagsregel am Bräter
Mit und ergibt die Regel , also 40 €. Mit , einem deutlich preisempfindlicheren Produkt, ergibt sie , also 26,67 €.
Aus derselben Formel folgen zwei Warnungen, und die erste Version dieses Artikels hat beide übersehen. Mit sagt die Regel , also 60 €. Rutscht die Schätzung von auf , was gut innerhalb der Fehlerspanne der meisten echten Schätzungen liegt, verschiebt sich der "optimale" Preis um die Hälfte. Und mit ergibt die Regel , einen negativen Preis. Das ist kein Rechenfehler. Es heißt, die Nachfrage ist beim heutigen Preis unelastisch, eine Preiserhöhung würde den Gewinn steigern, und die Regel kann nicht sagen, um wie viel, weil ihre Annahme dort nicht gilt. Der alte Code schickte jedes Produkt durch diese Formel, mit einer Standardelastizität von , wenn keine bekannt war. Der neue Code unten nutzt die Regel nur, wenn es eine echte Schätzung unter gibt, bewegt sich schrittweise auf sie zu, statt hinzuspringen, und begrenzt jeden Schritt.
Passives und aktives Marketing im Vergleich
Im passiven Modell zeigt sich eine Änderung erst nach Wochen: Du drehst an etwas, wartest auf Daten, streitest über ihre Bedeutung und drehst an etwas anderem. Im aktiven Modell läuft jede Nacht dieselbe Schleife innerhalb von Grenzen, die ein Mensch gesetzt hat, und ein Mensch liest das Protokoll statt jeden einzelnen Preis.
Nachts ist Absicht. Die alte Version lief jede Stunde. Preise, die sich stündlich bewegen, kannst du einer Kundin kaum erklären, sie laufen dem Preis davon, den Google von deiner Seite gelesen hat, und, wie der Abschnitt zum Recht unten zeigt, sie machen jeden Streichpreis zur Rechenaufgabe.
Preise der Mitbewerber: höflich sammeln, allein nutzen
Ohne zu wissen, was die Shops verlangen, mit denen du wirklich konkurrierst, kannst du nicht vernünftig bepreisen. Eine Preisbeobachtung tut vier Dinge: Sie liest nach Zeitplan die öffentlichen Produktseiten der Mitbewerber, ordnet deren Produkte deinen zu (über die Artikelnummer GTIN, wo beide Seiten sie zeigen, sonst über eine Zuordnung, die ein Mensch geprüft hat), speichert die Historie und meldet deutliche Änderungen.
Wie du sammelst, zählt so viel wie was du sammelst. Nur öffentliche Seiten, keine Logins, ein ehrlicher User Agent mit Kontaktadresse, robots.txt respektiert, ein höfliches Tempo, und wenn eine Seite dich blockiert, hörst du auf. Die rechtlichen Gründe, vom Datenbankrecht bis zu den Ryanair Urteilen, stehen in Preisbeobachtung von Wettbewerbern in der EU: was wirklich legal ist.
Mit den Daten bekommt jedes Produkt eine Strategie. Den günstigsten Mitbewerber um einen festen Betrag unterbieten, bei austauschbarer Ware, wo du einen Kostenvorteil hast. Auf den Marktdurchschnitt gehen, wo der Preis nicht dein Argument ist. Einen festen Aufschlag halten, wo Marke, Service oder Qualität ihn rechtfertigen. Oder je nach Bestand wechseln: unterbieten bei Überbestand, Aufschlag halten bei knappem Bestand, sonst Durchschnitt. Die Strategien stehen im selben Sortiment nebeneinander. Donauguss unterbietet bei einer einfachen Bratpfanne, die jeder Shop führt, geht bei Messersets auf den Durchschnitt und hält bei den eigenen Bräterfarben einen Aufschlag.
Zwei Regeln gelten für jede Strategie. Die Maschine geht nie unter eine Untergrenze aus Kosten plus Mindestmarge, egal was ein Mitbewerber tut. Und Mitbewerberpreise sind ein Eingangswert unter mehreren, kein Befehl. Eine Maschine, die immer nur dem günstigsten Mitbewerber folgt, überlässt ihm die eigene Preisgestaltung, und zwei Maschinen, die einander folgen, können genau in das Muster rutschen, das dem Kartellrecht Sorgen macht. Dazu unten mehr.
Margenbewusste Werbung: Geld dorthin, wo der Gewinn ist
Die meisten Werbekonten werden am Return on Ad Spend (ROAS) gemessen: Umsatz aus den Anzeigen geteilt durch die Kosten der Anzeigen. Umsatz ist das Falsche, um es zu teilen.
Nimm zwei Produkte von Donauguss, beide zu 100 €. Der Messerblock kostet 80 €, seine Bruttomarge ist also 20 %. Das Bräterset kostet 40 €, seine Marge ist 60 %. Konvertieren beide gleich gut zu denselben Klickkosten, ist ihr ROAS identisch, und doch bringt das Bräterset pro Verkauf den dreifachen Rohertrag. Die Kennzahl, die den Unterschied sieht, ist der Profit on Ad Spend (POAS):
ist der Umsatz aus den Anzeigen, der Wareneinsatz dieser Bestellungen, die Werbeausgabe und die Bruttomarge als Anteil am Umsatz, also . Das ist ein Verhältnis zweier Größen über denselben Zeitraum, erklärt unter Verhältnisse und Raten in den Grundlagen. Ein POAS über 1 heißt, der Rohertrag aus den Anzeigen deckt ihre Kosten, vor allen anderen variablen Kosten.
Durchgerechnet: Eine Kampagne mit ROAS 4 auf Produkte mit 20 % Marge hat . Sie verliert 20 Cent Rohertrag auf jeden ausgegebenen Euro, während ihr Dashboard eine gesunde 4 zeigt. Eine Kampagne mit ROAS 2 auf Produkte mit 60 % Marge hat , und sie ist diejenige, die Geld verdient.
Ein Budget nach Punktzahl aufteilen
Die einfachste margenbewusste Aufteilung gibt jedem Produkt eine Punktzahl und teilt das Budget im Verhältnis:
ist der Budgetanteil von Produkt , seine Punktzahl und die Summe aller Punktzahlen. ist die Bruttomarge als Anteil, die Konversionsrate aus Anzeigenklicks der letzten 30 Tage, ein Bestandsfaktor und ein Marktfaktor. Jeder Anteil ist ein einfacher Anteil am Ganzen, wie unter Prozente in den Grundlagen. Als Bestandsfaktor nehme ich zum Start 1,5 bei mehr als acht Wochen Bestand, 1,3 bei vier bis acht Wochen, 1,0 bei zwei bis vier, 0,8 bei ein bis zwei und 0,5 unter einer Woche. Der Marktfaktor ist 1,2, wenn du beim günstigsten Mitbewerber oder darunter liegst, 1,0 nahe am Marktdurchschnitt und 0,7, wenn du der Teuerste bist.
Rechenbeispiel: 3.000 € auf drei Produkte
Donauguss gibt 3.000 € im Monat für Google Shopping aus, verteilt auf drei Produkte. Der Bräter hat 50 % Marge, konvertiert mit 3,0 %, hat sechs Wochen Bestand (Faktor 1,3) und liegt am Marktdurchschnitt (1,0), seine Punktzahl ist also . Das Messerset hat 35 % Marge, konvertiert mit 2,0 %, hat normalen Bestand (1,0) und den niedrigsten Preis am Markt (1,2), also . Die Bratpfanne hat 20 % Marge, konvertiert mit 4,5 %, hat weniger als eine Woche Bestand (0,5) und ist die teuerste am Markt (0,7), also .
Die Punktzahlen ergeben zusammen . Der Bräter bekommt des Budgets, 1.884 €. Das Messerset bekommt , 812 €. Die Pfanne bekommt , 304 €. Die Pfanne konvertiert von allen dreien am besten, und eine Umsatzoptimierung würde sie füttern. Hier bekommt sie am wenigsten, weil sie pro Verkauf wenig bringt, gleich ausverkauft ist und ein Mitbewerber sie unterbietet.
Eine Punktzahl ist ein Startpunkt, kein Optimum. Werbeausgaben haben abnehmende Erträge: Die ersten 300 € für die Pfanne erreichen die eiligsten Suchenden, die nächsten 300 € weniger eilige. Die gewinnmaximale Aufteilung ist die, bei der der letzte Euro auf jedem Produkt denselben zusätzlichen Gewinn bringt, also der Unterschied zwischen Grenz und Durchschnittsertrag. Eine Punktzahl sieht das nicht. Darum nehme ich sie als erste Aufteilung, verschiebe Budget in kleinen Schritten und lasse einem Produkt seinen Anteil nur, wo die zusätzliche Ausgabe weiter Ertrag gebracht hat.
Das Recht legt fest, was die Maschine darf
Das Verbraucherrecht verbietet dynamische Preise nicht. Das EU Recht behandelt Preise, die sich mit der Nachfrage am Markt bewegen, als normal und verlangt zusätzliche Information nur, wenn ein Preis auf Grundlage einer automatisierten Entscheidungsfindung für die einzelne Person personalisiert wird.2 In Österreich greifen vor allem das Bundesgesetz gegen den unlauteren Wettbewerb (UWG), das Preisauszeichnungsgesetz (PrAG) und das Fern und Auswärtsgeschäfte Gesetz (FAGG). Ich bin kein Anwalt, und das ist keine Rechtsberatung. Es ist die Karte, nach der ich baue, und ein Shop mit ungewöhnlichem Modell sollte damit zu einer Anwältin gehen.
Sagen, dass sich Preise bewegen
Irreführend nach § 2 UWG ist eine Geschäftspraktik, die unrichtige Angaben enthält oder sonst geeignet ist, jemanden zu täuschen, unter anderem über den Preis, die Art der Preisberechnung oder das Vorhandensein eines besonderen Preisvorteils, sodass er eine Entscheidung trifft, die er sonst nicht getroffen hätte.3 Auf der Liste der Geschäftspraktiken, die unter allen Umständen als unlauter gelten, steht die unrichtige Angabe, ein Produkt sei nur für einen sehr begrenzten Zeitraum verfügbar, um eine sofortige Entscheidung zu erzwingen.4
Für die Maschine heißt das: eine schlichte Zeile auf der Produktseite oder der Seite zu Versand und Preisen, dass sich Preise mit Nachfrage und Bestand ändern, kein Countdown neben einem Preis, der sich gar nicht gleich ändert, und ein eingefrorener Warenkorb, also wird eine Variante in einer Bestellung, die bei der Zahlung angekommen ist, nicht neu bepreist, bis die Bestellung abgeschlossen oder abgebrochen ist.
Streichpreise und die 30 Tage Regel
Hier hat Österreich eine harte Regel. Wer bei Sachgütern eine Preisermäßigung in Beträgen oder in Prozenten bekannt gibt, muss nach § 9a PrAG auch den vorherigen niedrigsten Preis angeben, der zumindest einmal in den 30 Tagen vor der Ermäßigung im selben Vertriebskanal verlangt wurde. Bei einer schrittweise ansteigenden Ermäßigung ist das der niedrigste Preis vor der ersten Stufe.5 Wer seine Pflichten zur Preisauszeichnung nicht erfüllt, begeht eine Verwaltungsübertretung.6 Die Regel setzt Artikel 6a der Preisangabenrichtlinie um, den die Omnibus Richtlinie eingefügt hat.2 Und der Gerichtshof der EU hat 2024 im Fall Aldi Süd entschieden, dass eine prozentuale Ermäßigung oder ein Werbehinweis auf einen besonders günstigen Preis vom 30 Tage Tiefstpreis aus berechnet werden muss.7
Eine dynamische Preismaschine bewegt Preise per Konstruktion rauf und runter, und genau da greift die Regel. Angenommen, die Maschine hat den Bräter vor zwei Wochen für eine Woche mit hohem Bestand von 40 € auf 36 € gesenkt, und jetzt startest du einen Abverkauf zu 32 €. Der niedrigste Preis der letzten 30 Tage ist 36 €, nicht 40 €, die ehrliche Ermäßigung also 11 %, nicht 20 %. Meine Regel lautet deshalb: Preise, die die Maschine bewegt, erscheinen als normale Preise, nie als Ermäßigung. Ein Streichpreis erscheint nur bei einer bewussten Aktion, und der angegebene vorherige Preis kommt aus dem Preisprotokoll, genau das tut die Methode lowest_before unten.
Persönliche Preise: die Linie, die ich nicht überschreite
Personalisierte Preise heißt, verschiedenen Menschen für dasselbe Produkt verschiedene Preise zu zeigen, je nachdem, was über sie bekannt ist. Im Onlineshop musst du die Kundin nach dem FAGG vor dem Kauf darauf hinweisen, wenn der Preis auf der Grundlage einer automatisierten Entscheidungsfindung personalisiert worden ist.8 Die Datenschutz Grundverordnung (DSGVO) gibt jedem Menschen das Recht, keiner ausschließlich automatisierten Entscheidung unterworfen zu werden, die ihm gegenüber rechtliche Wirkung entfaltet oder ihn ähnlich erheblich beeinträchtigt, mit engen Ausnahmen, und wo eine Ausnahme greift, braucht es mindestens das Eingreifen einer Person, die Möglichkeit, den eigenen Standpunkt darzulegen, und die Anfechtung der Entscheidung.9
Daraus folgen drei Regeln, und über sie verhandle ich in nichts, was ich baue. Erstens nimmt die Maschine nie ein geschütztes Merkmal als Eingangswert, auch keinen Stellvertreter dafür. Nach § 31 Gleichbehandlungsgesetz (GlBG) darf niemand auf Grund des Geschlechts oder der ethnischen Zugehörigkeit beim Zugang zu und bei der Versorgung mit Gütern und Dienstleistungen, die der Öffentlichkeit zur Verfügung stehen, unmittelbar oder mittelbar diskriminiert werden.10 Das GlBG nennt für Güter und Dienstleistungen nur diese beiden Merkmale, aber Alter, Religion oder Behinderung haben in meiner Preismaschine trotzdem nichts verloren. Postleitzahl, Vorname oder Gerätetyp können als Stellvertreter wirken. Offen beworbene Nachlässe, etwa für Studierende, sind eine bewusste kaufmännische Entscheidung mit eigener rechtlicher Prüfung, nichts, was ein Algorithmus selbst entdecken sollte. Zweitens nutzt die Maschine nie personenbezogene Daten ohne Rechtsgrundlage und nie Daten aus Cookies oder ähnlichen Techniken, für die eine Einwilligung nötig war, die der Mensch nicht gegeben hat.11 Drittens bepreist die Maschine Produkte, Ausgaben, Kanäle und Zeitpunkte, damit stellt sich weder die Hinweispflicht noch die Frage nach Artikel 22 DSGVO. Die Schnittstelle price_for_user aus der ersten Version des Codes ist weg.
Algorithmische Kollusion: auf den Markt reagieren, nie sich abstimmen
Auf die Preise, die deine Mitbewerber veröffentlichen, selbstständig zu reagieren, ist genau der Wettbewerb, den das Recht will. § 1 Kartellgesetz 2005 (KartG 2005) verbietet Vereinbarungen zwischen Unternehmern und aufeinander abgestimmte Verhaltensweisen, die eine Verhinderung, Einschränkung oder Verfälschung des Wettbewerbs bezwecken oder bewirken, ausdrücklich auch die unmittelbare oder mittelbare Festsetzung von Verkaufspreisen,12 und Artikel 101 des Vertrags über die Arbeitsweise der Europäischen Union (AEUV) sagt dasselbe, wo der Handel zwischen Mitgliedstaaten betroffen ist.13 Die Geldbuße verhängt das Kartellgericht, und sie kann für ein Unternehmen bis zu 10 % des im vorausgegangenen Geschäftsjahr erzielten Gesamtumsatzes erreichen.14 Software ändert daran nichts.
Das deutsche Bundeskartellamt und die französische Autorité de la concurrence beschreiben in ihrer gemeinsamen Studie zu Algorithmen zwei feinere Wege: einen Dritten, etwa einen Softwareanbieter, der Wettbewerbern denselben oder einen abgestimmten Algorithmus bereitstellt, oft Hub and Spoke genannt, und Algorithmen, die ganz ohne Kommunikation lernen, Preise hoch zu halten.15 In einem simulierten Markt haben Preisagenten auf Basis von Q Learning gelernt, Preise über dem Wettbewerbsniveau zu halten und einen Mitbewerber, der senkt, zu bestrafen.16 Das war ein Laborergebnis, kein Befund gegen einen echten Shop, aber es ist der Grund für drei Bauregeln. Die Maschine liest nur die eigenen Daten des Shops und öffentliche Preise der Mitbewerber. Wenn du einen Repricing Dienst kaufst, frag schriftlich, ob seine Empfehlungen nicht öffentliche Daten anderer Kunden nutzen. Und jeder Preis im Protokoll trägt einen Grund, den ein Mensch lesen kann, in Begriffen der eigenen Kosten, des Bestands und der Strategie des Shops, nie in Begriffen dessen, was ein Mitbewerber als Nächstes tun wird.
Die Umsetzung in Solidus
Jetzt der Code. Er setzt einen Solidus Shop auf einem aktuellen Rails voraus, einen Crawler, der sich schon an die Regeln oben hält und speichert, was er findet, und API Zugang zu Google Ads und Meta. Es ist ein lauffähiges Gerüst, kein fertiges Gem: Die Klassennamen sind meine, und Strategien, Faktoren und Grenzen passt du an dein Sortiment an.
Tabellen: Mitbewerberpreise und ein Preisprotokoll
Zwei Tabellen. Eine hält den aktuellen öffentlichen Preis je Mitbewerber und Variante. Die andere ist das Preisprotokoll: jeder Preis, den der Shop verlangt hat, mit Grund und Eingangswerten. Das Protokoll ist dein Nachweis für den vorherigen niedrigsten Preis, deine Trainingsdaten für die nächste Elastizitätsschätzung und deine Antwort, wenn eine Kundin oder eine Behörde fragt, warum sich ein Preis bewegt hat.
# db/migrate/20260806000001_create_pricing_tables.rb
class CreatePricingTables < ActiveRecord::Migration[7.2]
def change
create_table :competitor_prices do |t|
t.references :variant, null: false, foreign_key: { to_table: :spree_variants }
t.string :competitor_domain, null: false
t.decimal :price, precision: 10, scale: 2, null: false
t.decimal :shipping_cost, precision: 10, scale: 2, null: false, default: 0
t.boolean :in_stock, null: false, default: true
t.datetime :seen_at, null: false
t.timestamps
end
add_index :competitor_prices, [:variant_id, :competitor_domain], unique: true
create_table :price_changes do |t|
t.references :variant, null: false, foreign_key: { to_table: :spree_variants }
t.string :currency, null: false
t.decimal :old_amount, precision: 10, scale: 2
t.decimal :new_amount, precision: 10, scale: 2, null: false
t.string :reason, null: false
t.jsonb :inputs, null: false, default: {}
t.timestamps
end
add_index :price_changes, [:variant_id, :currency, :created_at]
end
end
# app/models/competitor_price.rb
class CompetitorPrice < ApplicationRecord
belongs_to :variant, class_name: "Spree::Variant"
scope :fresh, -> { where(seen_at: 36.hours.ago..) }
scope :in_stock, -> { where(in_stock: true) }
def total_price
price + shipping_cost
end
def self.for_variant(variant)
fresh.in_stock.where(variant: variant)
end
def self.lowest_total(variant)
for_variant(variant).map(&:total_price).min
end
def self.average_total(variant)
totals = for_variant(variant).map(&:total_price)
totals.empty? ? nil : totals.sum / totals.size
end
end
# app/models/price_change.rb
class PriceChange < ApplicationRecord
belongs_to :variant, class_name: "Spree::Variant"
# Niedrigster Preis in den `days` Tagen vor `at`, einschließlich des Preises,
# der beim Beginn des Zeitraums schon galt. Das ist der vorherige Preis, den
# § 9a PrAG bei jeder Preisermäßigung verlangt.
def self.lowest_before(variant, at:, currency: "EUR", days: 30)
scope = where(variant: variant, currency: currency)
window_start = at - days.days
in_window = scope.where(created_at: window_start..at).minimum(:new_amount)
in_force = scope.where(created_at: ...window_start).order(created_at: :desc).pick(:new_amount)
[in_window, in_force].compact.min
end
end
Mitbewerberpreise abgleichen
Der Abgleich liest aus dem eigenen Speicher deines Crawlers. Die Zuordnung ist der Schritt, der am häufigsten schiefgeht, deshalb stützt er sich auf eine Zuordnungstabelle, die ein Mensch bestätigt hat, zuerst befüllt über die GTIN, wo beide Shops sie zeigen. Die erste Version suchte Barcodes der Mitbewerber in der Solidus Spalte sku, was nur funktioniert, wenn deine Artikelnummern zufällig Barcodes sind.
# app/jobs/competitor_price_sync_job.rb
class CompetitorPriceSyncJob < ApplicationJob
queue_as :default
def perform
CrawlerStore.observations_since(26.hours.ago).each do |obs|
mapping = CompetitorProductMapping.confirmed.find_by(
competitor_domain: obs.domain, competitor_url: obs.url
)
next unless mapping
CompetitorPrice.upsert(
{
variant_id: mapping.variant_id,
competitor_domain: obs.domain,
price: obs.price,
shipping_cost: obs.shipping_cost || 0,
in_stock: obs.in_stock,
seen_at: obs.fetched_at,
created_at: Time.current,
updated_at: Time.current
},
unique_by: [:variant_id, :competitor_domain]
)
end
end
end
Die Preismaschine
Die Maschine schlägt vor, sie entscheidet nicht allein. Ihre Eingangswerte sind die Kosten der Variante, der Bestand, die öffentlichen Preise der Mitbewerber und die Elastizitätsschätzung des Produkts. Nichts über die Kundin geht hinein.
# app/services/pricing_engine.rb
class PricingEngine
Proposal = Struct.new(:amount, :reason, :inputs, :needs_review, keyword_init: true)
MAX_STEP = 0.05 # nie mehr als 5 % pro Lauf
ELASTICITY_WEIGHT = 0.3 # wie weit sich jeder Lauf der Aufschlagsregel nähert
def initialize(variant, currency: "EUR")
@variant = variant
@product = variant.product
@currency = currency
@config = PricingConfig.for(@product)
end
def propose
return nil if in_checkout?
cost = @variant.cost_price
return nil unless cost && current_price
target = strategy_price
target = lean_towards_markup_rule(target, cost)
target *= stock_adjustment
capped = target.clamp(current_price * (1 - MAX_STEP), current_price * (1 + MAX_STEP))
final = capped.clamp(floor(cost), ceiling).round(2)
Proposal.new(
amount: final,
reason: "#{@config.strategy}, #{weeks_of_stock.round(1)} Wochen Bestand",
inputs: inputs(cost),
needs_review: final == floor(cost) || final == ceiling
)
end
private
def current_price
@current_price ||= @variant.price_for_options(pricing_options)&.amount
end
def pricing_options
Spree::Config.pricing_options_class.new(currency: @currency)
end
def strategy_price
lowest = CompetitorPrice.lowest_total(@variant)
average = CompetitorPrice.average_total(@variant)
case effective_strategy
when :undercut then lowest ? lowest - @config.undercut_amount : current_price
when :match then average || current_price
when :premium then (average || current_price) * (1 + @config.premium_share)
end
end
def effective_strategy
return @config.strategy.to_sym unless @config.strategy == "by_stock"
return :undercut if weeks_of_stock > 8
return :premium if weeks_of_stock < 1
:match
end
# Die Aufschlagsregel P* = C * e / (1 + e) gilt nur bei elastischer Nachfrage
# (e < -1) und nur mit einer echten Schätzung. Ohne sie bleibt der Strategiepreis.
def lean_towards_markup_rule(price, cost)
e = @product.price_elasticity
return price unless e && e < -1.0
optimal = cost * e / (1 + e)
price * (1 - ELASTICITY_WEIGHT) + optimal * ELASTICITY_WEIGHT
end
def stock_adjustment
case weeks_of_stock
when ...1 then 1.03
when 1...4 then 1.0
when 4...8 then 0.98
else 0.95
end
end
def weeks_of_stock
@weeks_of_stock ||= begin
weekly = SalesVelocity.weekly_average(@variant, weeks: 8)
weekly.positive? ? @variant.total_on_hand.to_f / weekly : 99.0
end
end
def floor(cost)
[cost / (1 - @config.minimum_margin), @config.price_floor || 0].max
end
def ceiling
@config.price_ceiling || current_price * 1.5
end
# Eine Variante in einer Bestellung, die bei der Zahlung angekommen ist,
# behält ihren Preis, bis die Bestellung abgeschlossen oder abgebrochen ist.
def in_checkout?
Spree::LineItem.joins(:order)
.where(variant_id: @variant.id)
.where(spree_orders: { state: %w[payment confirm], completed_at: nil })
.where("spree_orders.updated_at > ?", 2.hours.ago)
.exists?
end
def inputs(cost)
{
cost: cost.to_f,
current_price: current_price.to_f,
competitor_lowest: CompetitorPrice.lowest_total(@variant)&.to_f,
competitor_average: CompetitorPrice.average_total(@variant)&.to_f,
elasticity: @product.price_elasticity,
weeks_of_stock: weeks_of_stock.round(2),
strategy: effective_strategy
}
end
end
Preise in Solidus schreiben
Solidus speichert Preise als Datensätze vom Typ Spree::Price je Währung und optional je Land, und ein austauschbarer Price Selector wählt den passenden aus. Der Standard wählt nach Währung und Land.17 Die Maschine schreibt deshalb einen ganz normalen Preisdatensatz, und Storefront, Warenkorb und Feeds lesen ihn wie gewohnt. Über Spree::Config.variant_price_selector_class kannst du den Selector austauschen, wenn du Preise je Land oder Kanal brauchst. Für Preise je Kundin nutze ich diese Stelle nicht, aus den Gründen oben.
# app/services/price_writer.rb
class PriceWriter
def apply!(variant, proposal, currency: "EUR")
return if proposal.nil? || proposal.needs_review
price = variant.prices.find_or_initialize_by(currency: currency, country_iso: nil)
old_amount = price.amount
return if old_amount && (proposal.amount - old_amount).abs < 0.01
Spree::Price.transaction do
price.update!(amount: proposal.amount)
PriceChange.create!(
variant: variant, currency: currency,
old_amount: old_amount, new_amount: proposal.amount,
reason: proposal.reason, inputs: proposal.inputs
)
end
end
end
Vorschläge, die an der Unter oder Obergrenze anstoßen, werden nicht angewendet. Sie landen auf einer kurzen Tagesliste für einen Menschen, denn eine Maschine, die an einer Grenze klebt, sagt dir meist, dass Kosten, eine Zuordnung oder eine Elastizitätsschätzung falsch sind.
Die Budgetaufteilung
Die Aufteilung setzt die Punktzahl aus dem Rechenbeispiel um. Die erste Version filterte auf eine Spalte total_on_hand und mittelte price in SQL, aber Solidus führt den Bestand in Stock Items und die Preise in einer eigenen Tabelle, also gibt es beide Spalten in der Variantentabelle nicht. Diese Version rechnet beides in Ruby.
# app/services/budget_allocator.rb
class BudgetAllocator
def initialize(monthly_budget:, platform:)
@monthly_budget = monthly_budget
@platform = platform
end
def allocation
scores = eligible_products.to_h { |product| [product, score(product)] }
total = scores.values.sum
return {} if total.zero?
scores.transform_values { |s| (@monthly_budget * s / total).round(2) }
end
private
def eligible_products
Spree::Product.available.includes(:variants).select do |product|
product.variants.any? { |v| v.cost_price.present? && v.total_on_hand.positive? }
end
end
def score(product)
margin(product) *
(ConversionMetrics.rate_for(product, days: 30) || 0.0) *
stock_factor(product) *
competitive_factor(product)
end
def margin(product)
options = Spree::Config.default_pricing_options
rates = product.variants.filter_map do |v|
price = v.price_for_options(options)&.amount
next unless price&.positive? && v.cost_price
(price - v.cost_price) / price
end
rates.empty? ? 0.0 : rates.sum / rates.size
end
def stock_factor(product)
weekly = SalesVelocity.product_weekly_average(product, weeks: 8)
weeks = weekly.positive? ? product.variants.sum(&:total_on_hand).to_f / weekly : 99.0
case weeks
when ...1 then 0.5
when 1...2 then 0.8
when 2...4 then 1.0
when 4...8 then 1.3
else 1.5
end
end
def competitive_factor(product)
options = Spree::Config.default_pricing_options
positions = product.variants.filter_map do |v|
lowest = CompetitorPrice.lowest_total(v)
highest = CompetitorPrice.for_variant(v).map(&:total_price).max
price = v.price_for_options(options)&.amount
next unless lowest && price
if price <= lowest then 1.2
elsif price >= highest then 0.7
else 1.0
end
end
positions.empty? ? 1.0 : positions.sum / positions.size
end
end
Budgets und Preise an die Plattformen senden
In der Google Ads API wird ein Kampagnenbudget in Micros angegeben, einem Millionstel der Kontowährung, und Google begrenzt die tatsächlichen Monatsausgaben auf das 30,4 Fache des Tagesbetrags.18 Aus einer Monatszuteilung wird also ein Tagesbudget, indem du durch 30,4 teilst, nicht durch 30: Aus den 1.884 € für den Bräter werden rund 61,97 € am Tag.
# app/services/google_ads_budgets.rb
class GoogleAdsBudgets
def initialize(client: GoogleAdsClientFactory.build,
customer_id: Rails.application.credentials.google_ads[:customer_id])
@client = client
@customer_id = customer_id
end
def set_daily!(budget_resource_name:, monthly_amount:)
daily = monthly_amount / 30.4
operation = @client.operation.update_resource.campaign_budget(budget_resource_name) do |b|
b.amount_micros = (daily * 1_000_000).round
end
@client.service.campaign_budget.mutate_campaign_budgets(
customer_id: @customer_id, operations: [operation]
)
end
end
Meta setzt Budgets auf Anzeigengruppen über die Marketing API, mit daily_budget in der kleinsten Einheit der Kontowährung.19 Die Version der Graph API gehört in die Konfiguration, nicht in den Code: Die erste Version hatte v18.0 fest eingetragen, das längst veraltet ist.
# app/services/meta_budgets.rb
class MetaBudgets
def initialize
creds = Rails.application.credentials.meta_ads
@token = creds[:access_token]
@base = "https://graph.facebook.com/#{creds[:graph_version]}"
end
def set_daily!(adset_id:, monthly_amount:)
minor_units = (monthly_amount / 30.4 * 100).round
response = Faraday.post("#{@base}/#{adset_id}", daily_budget: minor_units, access_token: @token)
raise "Meta budget update failed: #{response.body}" unless response.success?
end
end
Die Preise in den Produktfeeds müssen dem Shop folgen. Google ruft deine Zielseiten ab und vergleicht den Preis dort mit dem Preis in deinen Produktdaten, und eine Abweichung kann zur Ablehnung von Produkten führen.20 Google hat die Content API for Shopping heuer am 18. August abgeschaltet, Anfragen schlagen seitdem schrittweise fehl, also laufen Feed Updates über die Merchant API.21 Ich halte das hinter einem kleinen MerchantFeed Wrapper, gebaut nach Googles Migrationsanleitung, damit der Rest des Codes nicht wissen muss, welche API Version gerade aktuell ist.
Der nächtliche Job
# app/jobs/nightly_pricing_job.rb
class NightlyPricingJob < ApplicationJob
queue_as :default
def perform
return unless PricingSwitch.on? # ein Schalter stoppt die ganze Schleife
CompetitorPriceSyncJob.perform_now
writer = PriceWriter.new
Spree::Variant.joins(:product)
.where(spree_products: { dynamic_pricing: true })
.where.not(cost_price: nil)
.find_each do |variant|
writer.apply!(variant, PricingEngine.new(variant).propose)
end
MerchantFeed.push_changed_prices(since: 1.hour.ago)
MetaCatalogue.push_changed_prices(since: 1.hour.ago)
google = BudgetAllocator.new(monthly_budget: AdBudget.monthly(:google), platform: :google)
google.allocation.each do |product, amount|
mapping = CampaignMapping.find_by(product: product, platform: "google")
next unless mapping
GoogleAdsBudgets.new.set_daily!(budget_resource_name: mapping.budget_resource_name, monthly_amount: amount)
end
end
end
# config/recurring.yml (Solid Queue), oder das Gegenstück in sidekiq-cron
production:
nightly_pricing:
class: NightlyPricingJob
schedule: every day at 3am
Messen, ob es funktioniert
Miss die Schleife am Gewinn, nicht an der Betriebsamkeit. Fünf Zahlen, wöchentlich, gegen die Wochen vor dem Start und, wo es geht, gegen eine Kontrollgruppe von Produkten, die die Schleife nicht anfasst.
Bruttomarge je Bestellung, die steigen sollte, wenn sich Preise bei elastischen Produkten der Aufschlagsregel nähern. Rohertrag je Sitzung, der Preis und Konversion in die eine Zahl fasst, auf die es ankommt. POAS je Kampagne, der steigen sollte, wenn Budget zum Gewinn wandert. Preisänderungen je Produkt und Woche, wobei null heißt, die Schleife tut nichts, und viele heißt, sie jagt Rauschen hinterher. Und die Prüfliste: wie viele Vorschläge an eine Grenze stoßen, und warum.
Die Kontrollgruppe ist der Teil, den viele weglassen. Preise werden selten zufällig gesetzt, ein Margenanstieg nach dem Start kann also die Saison sein, ein Mitbewerber ohne Ware oder ein neues Produkt. Eine passende Gruppe von Produkten sechs bis acht Wochen bei festen Preisen zu lassen, zeigt dir, ob die Schleife den Unterschied verdient hat. Wie du den Test aufsetzt, steht im Artikel zur Elastizität, und einen einfacheren ersten Schritt, mit Regeln vor Modellen, findest du in dynamische Preisgestaltung mit KI.
Was sich ändert, wenn das Marketing die Hebel hält
Das Marketing bekommt meist ein Produkt, einen Preis und ein Budget und soll das Beste daraus machen. Der Preis gehört jemand anderem, der Bestand dem Lager, die Marge der Buchhaltung. So kann ein Team hervorragende Kampagnen fahren, die mit Verlust ein Produkt verkaufen, das niemand beworben hätte, der seine Marge gesehen hätte.
Die Schleife oben bringt Preis, Bestand, Marge und Werbeausgaben an einen Ort, mit Grenzen, die ein Mensch setzt, und einem Protokoll, das ein Mensch liest. Das ist kein Autopilot. Es sind Entscheidungen, die du sowieso treffen würdest, jede Nacht getroffen, mit den Zahlen vor Augen, im Rahmen des Rechts, und aufgeschrieben.
Wenn du einen Shop auf Solidus oder Rails betreibst und das gebaut haben willst, fange ich mit einem kostenlosen Workshop an, und die ersten zwei Wochen Arbeit gehen auf mich. Individueller Solidus Code, den ich für deinen Shop schreibe, gehört nach vollständiger Bezahlung dir. Die Elastizitätsschätzungen und Preismodelle sind Data Science: Deine Rohdaten bleiben deine, und die Bedingungen für Code und Modelle stehen in den Bedingungen für Analytics und Data Science. Buch den Workshop und bring ein Jahr Bestellungen mit.