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 (50−20)×400=12.000(50 - 20) \times 400 = 12.000, also 12.000 €. Bei 35 € kaufen alle, der Gewinn ist (35−20)×1.000=15.000(35 - 20) \times 1.000 = 15.000, 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 (40−20)×400=8.000(40 - 20) \times 400 = 8.000, 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 50−22=2850 - 22 = 28 Euro. Wenn sich die Gruppen sauber aufteilen, ist der Gewinn 28×400+15×600=11.200+9.000=20.20028 \times 400 + 15 \times 600 = 11.200 + 9.000 = 20.200, also 20.200 €. Das sind rund 35 % mehr als beim besten Einheitspreis.

Gewinn in Euro bei einem Preis von 40, einem Preis von 50, einem Preis von 35 und bei zwei Ausgaben zu 50 und 35 Euro. Zwei Ausgaben bringen mit 20.200 Euro am meisten. Zum Vergrößern antippen: Vollbild, frei verschiebbar

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:

ε=%ΔQ%ΔP\varepsilon = \frac{\%\Delta Q}{\%\Delta P}

ε\varepsilon ist die Elastizität, %ΔQ\%\Delta Q die prozentuale Änderung der verkauften Menge und %ΔP\%\Delta P die prozentuale Änderung des Preises. Eine Elastizität von −2-2 heißt, eine Preiserhöhung um 10 % kostet rund 20 % der Stückzahl. Eine Elastizität von −0,5-0{,}5 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

P−CP=−1ε⟹P∗=C ε1+ε\frac{P - C}{P} = -\frac{1}{\varepsilon} \qquad\Longrightarrow\qquad P^{*} = \frac{C \, \varepsilon}{1 + \varepsilon}

PP ist der Preis, CC die Grenzkosten einer weiteren Einheit (Einkaufspreis plus Verpackung, Zahlungsgebühren und der Versand, den du bezuschusst, kein Durchschnitt, in dem die Miete steckt), ε\varepsilon die Elastizität und P∗P^{*} der gewinnmaximale Preis. Die linke Seite, (P−C)/P(P - C)/P, ist die Marge als Anteil am Preis. Die Regel gilt nur, wo die Nachfrage elastisch ist, also bei ε<−1\varepsilon < -1. Die Herleitung und wie du ε\varepsilon 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 C=20C = 20 und ε=−2\varepsilon = -2 ergibt die Regel P∗=20×(−2)1−2=−40−1=40P^{*} = \frac{20 \times (-2)}{1 - 2} = \frac{-40}{-1} = 40, also 40 €. Mit ε=−4\varepsilon = -4, einem deutlich preisempfindlicheren Produkt, ergibt sie P∗=−80−3=26,67P^{*} = \frac{-80}{-3} = 26{,}67, also 26,67 €.

Aus derselben Formel folgen zwei Warnungen, und die erste Version dieses Artikels hat beide übersehen. Mit ε=−1,5\varepsilon = -1{,}5 sagt die Regel P∗=−30−0,5=60P^{*} = \frac{-30}{-0{,}5} = 60, also 60 €. Rutscht die Schätzung von −2-2 auf −1,5-1{,}5, was gut innerhalb der Fehlerspanne der meisten echten Schätzungen liegt, verschiebt sich der "optimale" Preis um die Hälfte. Und mit ε=−0,8\varepsilon = -0{,}8 ergibt die Regel −160,2=−80\frac{-16}{0{,}2} = -80, 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 −2-2, wenn keine bekannt war. Der neue Code unten nutzt die Regel nur, wenn es eine echte Schätzung unter −1-1 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.

Zum Vergrößern antippen: Vollbild, frei verschiebbar

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.

Zum Vergrößern antippen: Vollbild, frei verschiebbar

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):

POAS=R−COGSS=ROAS×m\text{POAS} = \frac{R - \text{COGS}}{S} = \text{ROAS} \times m

RR ist der Umsatz aus den Anzeigen, COGS\text{COGS} der Wareneinsatz dieser Bestellungen, SS die Werbeausgabe und mm die Bruttomarge als Anteil am Umsatz, also ROAS=R/S\text{ROAS} = R/S. 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 POAS=4×0,2=0,8\text{POAS} = 4 \times 0{,}2 = 0{,}8. 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 POAS=2×0,6=1,2\text{POAS} = 2 \times 0{,}6 = 1{,}2, 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:

wi=si∑jsj,si=mi×ci×fiBestand×fiMarktw_i = \frac{s_i}{\sum_j s_j}, \qquad s_i = m_i \times c_i \times f_i^{\text{Bestand}} \times f_i^{\text{Markt}}

wiw_i ist der Budgetanteil von Produkt ii, sis_i seine Punktzahl und ∑jsj\sum_j s_j die Summe aller Punktzahlen. mim_i ist die Bruttomarge als Anteil, cic_i die Konversionsrate aus Anzeigenklicks der letzten 30 Tage, fiBestandf_i^{\text{Bestand}} ein Bestandsfaktor und fiMarktf_i^{\text{Markt}} 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 0,5×0,03×1,3×1,0=0,01950{,}5 \times 0{,}03 \times 1{,}3 \times 1{,}0 = 0{,}0195. Das Messerset hat 35 % Marge, konvertiert mit 2,0 %, hat normalen Bestand (1,0) und den niedrigsten Preis am Markt (1,2), also 0,35×0,02×1,0×1,2=0,00840{,}35 \times 0{,}02 \times 1{,}0 \times 1{,}2 = 0{,}0084. 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 0,2×0,045×0,5×0,7=0,003150{,}2 \times 0{,}045 \times 0{,}5 \times 0{,}7 = 0{,}00315.

Die Punktzahlen ergeben zusammen 0,0195+0,0084+0,00315=0,031050{,}0195 + 0{,}0084 + 0{,}00315 = 0{,}03105. Der Bräter bekommt 0,0195/0,03105=62,8 %0{,}0195 / 0{,}03105 = 62{,}8\ \% des Budgets, 1.884 €. Das Messerset bekommt 27,1 %27{,}1\ \%, 812 €. Die Pfanne bekommt 10,1 %10{,}1\ \%, 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.

Wenn du einen Shop auf Solidus oder Rails betreibst und Preise und Werbebudget aus denselben Zahlen steuern willst, starte ich mit einem kostenlosen Workshop, und die ersten zwei Wochen Arbeit gehen auf mich. Bring ein Jahr Bestellungen und deine Werbekonten mit, und ich zeige dir, welche Produkte dein Budget tragen sollten.

Quellen

  1. 1.

    Robert S. Pindyck, Lecture Notes on Pricing, 15.013 Industrial Economics for Strategic Decisions, MIT Sloan School of Management, August 2010, https://www.mit.edu/~rpindyck/Courses/Pricing_10.pdf

  2. 2.

    Europäisches Parlament und Rat, Richtlinie (EU) 2019/2161 (Omnibus Richtlinie), Erwägungsgrund 45 und Artikel 2 (Einfügung von Artikel 6a in die Richtlinie 98/6/EG), EUR Lex, 2019, https://eur-lex.europa.eu/legal-content/DE/TXT/HTML/?uri=CELEX:32019L2161

  3. 3.

    Republik Österreich, Bundesgesetz gegen den unlauteren Wettbewerb 1984 (UWG), § 2 Irreführende Geschäftspraktiken, Abs. 1, Rechtsinformationssystem des Bundes (RIS), https://www.ris.bka.gv.at/Dokumente/Bundesnormen/NOR40279748/NOR40279748.html

  4. 4.

    Republik Österreich, Bundesgesetz gegen den unlauteren Wettbewerb 1984 (UWG), Anhang, Z 7, Rechtsinformationssystem des Bundes (RIS), https://www.ris.bka.gv.at/Dokumente/Bundesnormen/NOR40279754/NOR40279754.html

  5. 5.

    Republik Österreich, Preisauszeichnungsgesetz (PrAG), § 9a Abs. 1, Rechtsinformationssystem des Bundes (RIS), https://www.ris.bka.gv.at/Dokumente/Bundesnormen/NOR40245445/NOR40245445.html

  6. 6.

    Republik Österreich, Preisauszeichnungsgesetz (PrAG), § 15 Strafbestimmungen, Abs. 1, Rechtsinformationssystem des Bundes (RIS), https://www.ris.bka.gv.at/Dokumente/Bundesnormen/NOR40278461/NOR40278461.html

  7. 7.

    Gerichtshof der Europäischen Union, Urteil vom 26. September 2024, Verbraucherzentrale Baden-Württemberg gegen Aldi Süd, Rechtssache C-330/23, https://curia.europa.eu/juris/liste.jsf?num=C-330/23&language=de

  8. 8.

    Republik Österreich, Fern- und Auswärtsgeschäfte-Gesetz (FAGG), § 4 Inhalt der Informationspflicht, Abs. 1 Z 4a, Rechtsinformationssystem des Bundes (RIS), https://www.ris.bka.gv.at/Dokumente/Bundesnormen/NOR40279253/NOR40279253.html

  9. 9.

    Europäisches Parlament und Rat, Verordnung (EU) 2016/679 (Datenschutz Grundverordnung), Artikel 22 Absätze 1 bis 3, EUR Lex, 2016, https://eur-lex.europa.eu/legal-content/DE/TXT/HTML/?uri=CELEX:32016R0679

  10. 10.

    Republik Österreich, Gleichbehandlungsgesetz (GlBG), § 31 Gleichbehandlungsgebot, Abs. 1, Rechtsinformationssystem des Bundes (RIS), https://www.ris.bka.gv.at/Dokumente/Bundesnormen/NOR40151383/NOR40151383.html

  11. 11.

    Republik Österreich, Telekommunikationsgesetz 2021 (TKG 2021), § 165 Abs. 3, BGBl. I Nr. 190/2021, Rechtsinformationssystem des Bundes (RIS), https://www.ris.bka.gv.at/Dokumente/Bundesnormen/NOR40238623/NOR40238623.html

  12. 12.

    Republik Österreich, Kartellgesetz 2005 (KartG 2005), § 1 Kartellverbot, Abs. 1 und 2 Z 1, Rechtsinformationssystem des Bundes (RIS), https://www.ris.bka.gv.at/Dokumente/Bundesnormen/NOR40065786/NOR40065786.html

  13. 13.

    Vertrag über die Arbeitsweise der Europäischen Union (AEUV), Artikel 101, EUR Lex, https://eur-lex.europa.eu/legal-content/DE/TXT/HTML/?uri=CELEX:12016E101

  14. 14.

    Republik Österreich, Kartellgesetz 2005 (KartG 2005), § 29 Geldbußentatbestände, Abs. 1 Z 1 lit. a, Rechtsinformationssystem des Bundes (RIS), https://www.ris.bka.gv.at/Dokumente/Bundesnormen/NOR40236037/NOR40236037.html

  15. 15.

    Bundeskartellamt und Autorité de la concurrence, Algorithms and Competition, November 2019, https://www.bundeskartellamt.de/SharedDocs/Publikation/EN/Berichte/Algorithms_and_Competition_Working-Paper.pdf?__blob=publicationFile&v=5

  16. 16.

    Emilio Calvano, Giacomo Calzolari, Vincenzo Denicolò und Sergio Pastorello, Artificial Intelligence, Algorithmic Pricing, and Collusion, American Economic Review, Band 110, Heft 10, Seiten 3267 bis 3297, 2020, https://www.aeaweb.org/articles?id=10.1257/aer.20190623

  17. 17.

    Solidus contributors, Spree::Variant::PriceSelector, Quellcode von Solidus auf GitHub, https://github.com/solidusio/solidus/blob/main/core/app/models/spree/variant/price_selector.rb

  18. 18.

    Google, CampaignBudget (Feld amount_micros), Google Ads API Referenz, abgerufen im November 2026, https://developers.google.com/google-ads/api/reference/rpc/latest/CampaignBudget

  19. 19.

    Meta, Ad Set reference (Feld daily_budget), Marketing API Dokumentation, abgerufen im November 2026, https://developers.facebook.com/docs/marketing-api/reference/ad-campaign/

  20. 20.

    Google, How to fix: Mismatched product price, Google Merchant Center Hilfe, abgerufen im November 2026, https://support.google.com/merchants/answer/6098334

  21. 21.

    Google, Content API for Shopping (deprecated), Hinweis auf die Abschaltung am 18. August 2026 und die Migrationsanleitung zur Merchant API, Google for Developers, abgerufen im November 2026, https://developers.google.com/shopping-content/guides/quickstart