Anleitung für eine Mean Reversion Strategie mit der lemon.markets API & Hosting in der Cloud


blog photo
Veröffentlicht von Marius Sprenger am 7. September 2021
Trading


Hallo zusammen! Mein Name ist Marius und ich kümmere mich um die Community bei lemon.markets 🍋. Wir bauen eine API, die es Dir ermöglicht, Deine eigene Trading Experience an der Börse zu bauen. Eine von vielen Möglichkeiten ist beispielsweise eine eigene automatisierte Handelsstrategie. Wir arbeiten gerade fleißig an unserem Sandbox-Launch und sind in ein paar Wochen soweit von der closed in die open beta zu wechseln. Aber vielleicht findest du ja auch schon jetzt eine Möglichkeit lemon.markets zu nutzen? 😏 Ansonsten meld dich gerne für unsere Warteliste an. Weißt Du schon wo Du anfangen möchtest? Falls nicht, habe ich da etwas für Dich.

In diesem Beitrag möchte ich Dir zeigen, wie Du die lemon.markets API nutzen kannst, um eine der bekanntesten Handelsstrategien zu bauen: Die Mean Reversion Strategie. Außerdem zeige ich Dir, wie Du Deine Strategie mit Heroku in der Cloud hosten kannst, damit Dein Skript weiterläuft, auch wenn Dein Laptop ausgeschaltet ist.

Die Idee der Mean-Reversion-Strategie (ich werde sie von nun an MR-Strategie nennen, denn wer mag schon Bandnudelsätze?) ist leicht erklärt: Dahinter steht die Annahme, dass sich eine Aktie immer einem Mittelwert (oder "Durchschnitt", eng. “mean”) annähern wird. Stell Dir also vor, Du hast eine Aktie des aufstrebenden Online-Supermarktes "SuperCompany", die einen durchschnittlichen Aktienkurs von 97,00 € hat (z.B. über die letzten zwei Wochen) und aktuell bei 92,50 € gehandelt wird. Die MR-Strategie geht davon aus, dass sich der Kurs bald dem durchschnittlichen Aktienkurs annähert, was bedeutet, dass jetzt ein guter Zeitpunkt zum Kaufen wäre (#buythedip). Auf der anderen Seite, wenn der aktuelle Aktienkurs gerade bei 103,50 € liegen würde, wäre es (wenn wir der MR-Logik folgen) eine gute Idee, die Aktie zu verkaufen, da ihr Preis derzeit höher ist als der durchschnittliche Aktienkurs der letzten zwei Wochen und wir daher erwarten, dass er bald fallen wird.

Klingt einfach, oder? Ist es auch.

Und was noch wichtiger ist, die Logik dahinter ist einfach zu implementieren, wenn wir die richtige Infrastruktur dazu zur Verfügung haben. Du hast es sicher schon erraten: Hier kommt lemon.markets ins Spiel. Mit der lemon.markets API kannst Du mit wenig Aufwand selbst eine MR-Strategie bauen. Man munkelt, dass sogar die frühen Erfolge von Jim Simons auf eine MR-basierte Strategie zurückzuführen sind. Für alle, die noch etwas tiefer in die Mean Reversion Strategie eintauchen wollen, können wir diesen Artikel empfehlen.

Dann lass uns doch direkt mal loslegen.

Umsetzung der Mean Reversion Strategy

Um den Überblick über unser Python Projekt zu behalten, definieren wir zunächst eine Reihe von Hilfsdateien und -funktionen, die wir später in unserem Hauptskript verwenden können. Dazu erstellen wir eine Datei helper.py und implementieren darin die Klasse RequestHandler. Diese enthält eine Reihe von Hilfsfunktionen, um API-Requests durchzuführen, die wir dann später wiederverwenden können und dadurch überflüssigen Code vermeiden können. Wir können die Funktionen nutzen, um einen neuen Token anzufordern und um GET, PUT und POST Requests zu stellen.

1import os
2import requests
3from dotenv import load_dotenv
4class RequestHandler:
5    load_dotenv()
6    url_data: str = os.environ.get("BASE_URL_DATA")
7    url_trading: str = os.environ.get("BASE_URL_TRADING")
8    auth_url: str = os.environ.get("AUTH_URL")
9    def get_token(self, endpoint: str, data):
10        """
11        :param data:
12        :param endpoint:
13        :return: access token as String
14        """
15        response = requests.post(self.auth_url + endpoint, data)
16        return response
17    def get_data_trading(self, endpoint: str):
18        response = requests.get(self.url_trading + endpoint,
19                                headers={
20                                    "Authorization": "Bearer " + os.environ.get("TOKEN_KEY")
21                                })
22        return response.json()
23    def get_data_data(self, endpoint: str):
24        """
25        :param endpoint: {str} only append the endpoint to the base url
26        :return:
27        """
28        response = requests.get(self.url_data + endpoint,
29                                headers={
30                                    "Authorization": "Bearer " + os.environ.get("TOKEN_KEY")
31                                })
32        return response.json()
33    def put_data(self, endpoint: str):
34        response = requests.put(self.url_trading + endpoint,
35                                headers={
36                                    "Authorization": "Bearer " + os.environ.get("TOKEN_KEY")
37                                })
38        return response.json()
39    def post_data(self, endpoint: str, data):
40        response = requests.post(self.url_trading + endpoint,
41                                 data,
42                                 headers={
43                                     "Authorization": "Bearer " + os.environ.get("TOKEN_KEY")
44                                 })
45        return response.json()

Environment-Variablen

Wenn Du Dir die obige Datei anschaust, merkst Du schnell, dass wir auf eine Reihe von Environment-Variablen zugreifen. Wenn Du Dein Skript lokal ausführen möchtest, empfehlen wir Dir, eine .env Datei zu erstellen. Diese enthält die folgenden Variablen, die Du dann über folgenden Befehl bekommst:

1os.getenv(“ENV-VARIABLE")
1| ENV Variable   |      Explanation      |  
2|----------|:-------------:|
3| TOKEN_KEY |  Your Access Token | 
4| CLIENT_ID |   Your client id   |   
5| CLIENT_SECRET | Your client secret |
6|MIC| Market Identifier Code of Trading Venue|
7|BASE_URL_TRADING | Base URL of our paper money API |
8|BASE_URL_DATA | Base URL of our paper money API |
9|AUTH_URL | URL of our authentication API|
10|SPACE_UUID | Your Space UUID |

Environment Variables for Mean Reversion Python script

Wenn Du Deinen Algorithmus in der Cloud hosten willst, musst Du etwas anders vorgehen. Aber dazu kommen wir später ;)

Eine Anzahl von Modellen definieren

Um innerhalb unseres Projektes den Überblick zu behalten, definieren wir eine Reihe von Python Modellen als Klassen, die wir dann im gesamten Projekt verwenden können. Diese Modelle spiegeln direkt unsere API-Struktur wider (mehr dazu in unserer Dokumentation). Dabei definieren wir Funktionen, die sich direkt auf die jeweilige Klasse beziehen.

Order Klasse

Letztendlich wollen wir entweder eine Kauf- oder eine Verkaufsorder platzieren, je nachdem, was unsere Mean-Reversion-Kriterien nahelegen.  Deshalb erstellen wir eine Order-Klasse und weisen ihr eine Reihe von Funktionen zu. Am Ende wollen wir in der Lage sein, drei verschiedene Dinge im Kontext von Orders zu tun:

  • Eine Order platzieren
  • Eine Order aktivieren
  • Alle unsere Orders ansehen

Alle drei oben genannten Dinge können durch API-Calls umgesetzt werden, weshalb wir die Order Klasse zu einer Unterklasse unserer RequestHandler Klasse machen, die wir zuvor in unserer helper.py Datei definiert haben. So können wir dann auf die GET, PUT und POST Requests in unserer Order Klasse zugreifen.

1import os
2from dotenv import load_dotenv
3from helpers import RequestHandler
4class Order(RequestHandler):
5    def __init__(self, isin: str = "", valid_until: float = 0, quantity: int = 0, side: str = "",
6                 stop_price: float = 0, limit_price: float = 0, uuid: str = ""):
7        self.isin = isin
8        self.valid_until = valid_until
9        self.quantity = quantity
10        self.side = side
11        self.stop_price = stop_price
12        self.limit_price = limit_price
13        self.uuid = uuid
14    def place_order(self):
15        order_details = {
16            "isin": self.isin,  # set ISIN
17            "valid_until": self.valid_until,  # specify your timestamp
18            "side": self.side,  # set side
19            "quantity": self.quantity,  # set quantity
20        }
21        load_dotenv()
22        space_uuid = os.getenv("SPACE_UUID")
23        endpoint = f'spaces/{space_uuid}/orders/'
24        response = self.post_data(endpoint, order_details)
25        return response
26    def get_orders(self):
27        load_dotenv()
28        space_uuid = os.getenv("SPACE_UUID")
29        endpoint = f'spaces/{space_uuid}/orders/'
30        response = self.get_data_trading(endpoint)
31        return response
32    def activate_order(self, order_uuid):
33        load_dotenv()
34        space_uuid = os.getenv("SPACE_UUID")
35        endpoint = f'spaces/{space_uuid}/orders/{order_uuid}/activate/'
36        response = self.put_data(endpoint)
37        return response

Instruments Klasse

Mit unserer Instruments Klasse folgen wir einem ähnlichen Ansatz. Hier definieren wir eine Funktion, um historische OHLC Marktdaten zu erhalten und eine, um die neuesten OHLC Daten zu erhalten. Du wirst sofort sehen, wofür wir die Daten in unserer Mean Reversion Strategie brauchen.

1import os
2from dotenv import load_dotenv
3from helpers import RequestHandler
4import time
5class Instruments(RequestHandler):
6    def __init__(self, isin: str = "", x1: str = ""):
7        self.isin = isin
8        self.x1 = x1
9    def get_market_data(self):
10        load_dotenv()
11        mic = os.getenv("MIC")
12        from_date = time.time() - (86400 * 7)
13        to_date = time.time()
14        isin = self.isin
15        x1 = self.x1
16        endpoint = f'ohlc/{x1}/?mic={mic}&isin={isin}&from={from_date}&to={to_date}'
17        response = self.get_data_data(endpoint)
18        print(response)
19        return response
20    def get_latest_market_data(self):
21        load_dotenv()
22        mic = os.getenv("MIC")
23        isin = self.isin
24        x1 = self.x1
25        endpoint = f'ohlc/{x1}/?mic={mic}&isin={isin}&from=latest'
26        try:
27            response = self.get_data_data(endpoint)
28            close_price = response['results'][0].get('c', None)
29            return close_price
30        except Exception as e:
31            print(e)

TradingVenue Klasse

Eines der wichtigsten Prinzipien bei der Nutzung unserer API, ist die Möglichkeit, bestimmte Handelsplätze anzusprechen. Daher erstellen wir ein eigenes Modell für Trading Venues. Darin benötigen wir drei Funktionen, die:

  • Prüfen, ob ein Handelsplatz aktuell geöffnet ist 
  • Die allgemeinen Öffnungszeiten für die nächsten Tage prüfen
  • Die Sekunden bis zur Wiedereröffnung des Handelsplatzes ermitteln.
1import os
2from dotenv import load_dotenv
3from helpers import RequestHandler
4from datetime import datetime, timedelta
5import datetime
6class TradingVenue(RequestHandler):
7    def __init__(self, is_open: bool = False):
8        self.is_open = is_open
9    def check_if_open(self):
10        load_dotenv()
11        mic = os.getenv("MIC")
12        endpoint = f'venues/?mic={mic}'
13        response = self.get_data_data(endpoint)
14        self.is_open = response['results'][0].get('is_open', None)
15        return self.is_open
16    def get_opening_times(self):
17        load_dotenv()
18        mic = os.getenv("MIC")
19        endpoint = f'venues/?mic={mic}'
20        response = self.get_data_data(endpoint)
21        return response
22    def seconds_till_tv_opens(self):
23        times_venue = self.get_opening_times()
24        today = datetime.datetime.today()
25        opening_days_venue = times_venue['results'][0].get('opening_days', None)
26        next_opening_day = datetime.datetime.strptime(opening_days_venue[0], '%Y-%m-%d')
27        next_opening_hour = datetime.datetime.strptime(times_venue['results'][0]['opening_hours'].get('start', None),                                            '%H:%M')
28        date_difference = next_opening_day - today
29        days = date_difference.days + 1
30        if not self.check_if_open():
31            print('Trading Venue not open')
32            time_delta = datetime.datetime.combine(
33                datetime.datetime.now().date() + timedelta(days=1), next_opening_hour.time()
34            ) - datetime.datetime.now()
35            print(time_delta.seconds + (days * 86400))
36            return time_delta.seconds
37        else:
38            print('Trading Venue is open')
39            return 0

Token Klasse

Du kannst Requests an unsere API stellen, indem Du einen Access-Token verwendest. Diesen erhältst Du, indem Du einen PUT-Request an unsere Authentifizierungs-API stellst und dabei Deine Client-ID und Dein Client-Secret aus Deinem jeweiligen Space verwendest. Allerdings haben unsere Access Token ein Ablaufdatum. Um zu verhindern, dass wir einen abgelaufenen Access Token verwenden, erstellen wir eine Token Klasse und fügen eine Funktion hinzu, die einen neuen Token anfordert.

1import os
2from helpers import RequestHandler
3class Token(RequestHandler):
4    def get_new_token(self):
5        token_details = {
6            "client_id": os.getenv("CLIENT_ID"),
7            "client_secret": os.getenv("CLIENT_SECRET"),
8            "grant_type": "client_credentials",
9        }
10        endpoint = f'token/'
11        response = self.get_token(endpoint, token_details)
12        os.environ['TOKEN_KEY'] = response.json().get('access_token', None)
13        return os.getenv('TOKEN_KEY')

Unser Main Script definieren

Nachdem wir alle Hilfsfunktionen und Modelle/Klassen erstellt haben, können wir damit beginnen, die Mean Reversion Logik in unserem Main Skript zu schreiben. Als erstes definieren wir eine Funktion mean_reversion_decision, die unsere Entscheidungslogik enthält. Hierbei holen wir uns die historischen Marktdaten für ein Wertpapier unserer Wahl und berechnen den Durchschnittspreis dafür. Dies ist die erste Komponente für unsere Mean Reversion Strategie.

Als nächstes ermitteln wir den letzten Schlusskurs, der dann als zweite Entscheidungskomponente dient. Wir vergleichen dann den Durchschnitt mit dem letzten Preis und geben True oder False zurück, je nachdem, welcher Wert höher ist (wenn der letzte Preis niedriger als der Durchschnittspreis ist, gehen wir davon aus, dass er schließlich zum Mittelwert konvergieren wird. In diesem Fall also True).

Anschließend wollen wir diese Information in unseren nachfolgenden Schritten nutzen. Je nachdem, was unsere Funktion mean_reversion_decision zurückgibt, kaufen oder verkaufen wir eine Aktie. Sobald die Order ausgeführt wurde, lassen wir unser Skript für 4 Stunden schlafen, bis wir unsere Mean Reversion Werte wieder prüfen (auch hier kannst Du gerne öfter/weniger prüfen. Dieses Skript dient nur als erste Idee und es gibt vieles, das noch optimiert kann).

Schließlich definieren wir unsere Hauptfunktion mean_reversion(). Hier prüfen wir, ob unser Handelsplatz aktuell geöffnet ist und führen, nachdem wir sichergestellt haben, dass wir einen funktionierenden Access Token haben, unsere Mean Reversion Logik aus. Wenn der Handelsplatz geschlossen ist, pausieren wir unser Skript, bis er wieder öffnet.

1from models.Order import Order
2from models.Instruments import Instruments
3from models.TradingVenue import TradingVenue
4from models.Token import Token
5import time
6import statistics
7def mean_reversion_decision(isin: str, x1: str = "d1"):
8    """
9    :param isin: pass the isin of your instrument
10    :param x1: pass what type of data you want to retrieve (m1, h1 or d1)
11    :return: returns whether you should buy (True) or sell (False), depending on MR criteria
12    """
13    market_data = Instruments(
14        isin=isin,
15        x1=x1
16    ).get_market_data()
17    d1_prices = market_data['results']
18    prices_close = [x["c"] for x in d1_prices]  # you can obviously change that to low, close or open
19    mean_price = statistics.mean(prices_close)
20    print(f'Mean Price: {mean_price}')
21    latest_close_price = Instruments(
22        isin=isin,
23        x1="m1"
24    ).get_latest_market_data()
25    print(f'Latest Close Price: {latest_close_price}')
26    if latest_close_price < mean_price:
27        return True
28    return False
29def check_if_buy(isin: str, x1: str = "d1"):
30    """
31    :param isin: pass the isin of the stock you are interested in
32    :param x1:  pass the market data format you are interested in (m1, h1, or d1)
33    """
34    # check for MR decision
35    if mean_reversion_decision(
36            isin=isin,
37            x1=x1
38    ):
39        # create a buy order if True is returned by MR decision function
40        try:
41            print('buy')
42            placed_order = Order(
43                isin=isin,
44                valid_until=time.time() + 86400,
45                side="buy",
46                quantity=1
47            ).place_order()
48            order_uuid = placed_order.get('uuid')
49            # subsequently activate the order
50            activated_order = Order().activate_order(order_uuid)
51            print(activated_order)
52            time.sleep(14400)  # check back in 4 hours
53        except Exception as e:
54            print(f'1{e}')
55            time.sleep(60)
56    else:
57        try:
58            # create a sell order if mean reversion decision returns False
59            print('sell')
60            placed_order = Order(
61                isin=isin,
62                valid_until=time.time() + 86400,
63                side="sell",
64                quantity=1
65            ).place_order()
66            order_uuid = placed_order.get('uuid')
67            activated_order = Order().activate_order(order_uuid)
68            print(activated_order)
69            time.sleep(14400)  # check back in 4 hours
70        except Exception as e:
71            print(f'2{e}')
72            time.sleep(60)
73def mean_reversion():
74    """
75    main function to be executed
76    """
77    while True:
78        if TradingVenue().check_if_open():
79            # make sure that you always have a functioning token
80            Token().get_new_token()
81            # make buy or sell decision
82            check_if_buy(
83                isin="US88160R1014",  # this is Tesla, but you can obviously use any ISIN you like :)
84                x1="d1"
85            )
86        else:
87            # sleep until market reopens in case it is closed
88            time.sleep(TradingVenue().seconds_till_tv_opens())
89if __name__ == '__main__':
90    mean_reversion()

Und das war es im Grunde schon. Du kannst das gesamte Repo auf GitHub finden - probiere es gerne mal aus. Natürlich wären wir Dir sehr dankbar, wenn Du einen PR öffnest oder uns eine Nachricht an [email protected] schickst. Wir freuen uns auf Deine Kommentare/Verbesserungen 🙂.

Hosting in der Cloud

Offensichtlich ist es sehr wichtig für einen Trading Algorithmus, dass er durchgängig läuft. Dafür gibt es eine Reihe von Möglichkeiten, Dein Python-Skript (oder jedes andere) in der Cloud zu hosten. Wir haben uns für Heroku entschieden, da es extrem einfach und schnell einzurichten ist.

Um ein Python-Skript in der Cloud zu hosten, gehe zu Deinem Dashboard und erstelle eine neue Anwendung. Nachdem dieser Schritt erledigt ist, gehe auf den Reiter "Deploy" und verbinde Dich mit Deinem GitHub Repository, in dem das Skript gehostet wird. Wähle automatische Deploys, wenn Änderungen im Repository ein neues Deployment triggern sollen. Alternativ wähle manuelle Deploys, wenn Du etwas mehr "Kontrolle" über Deine Heroku Deploys haben möchtest.

Wer diesen Blog Post aufmerksam gelesen hat, hat vermutlich bemerkt, dass wir noch unsere Umgebungsvariablen konfigurieren müssen. Das kannst Du tun, indem Du sie entweder im Dashboard unter Settings/Config Vars eingibst oder indem Du Dich in die Heroku CLI einloggst und sie wie folgt festlegst:

1heroku config:set ENV_VAR=value

Danach kannst Du Deine Anwendung deployen. Es kann ein paar Minuten dauern, bis Deine App läuft. Du kannst den Status überprüfen, indem Du Folgendes abfragst:

1heroku logs

Wenn die App nicht läuft, probiere es mit:

1heroku ps:scale worker=1

Schau mal in diesen und diesen Artikel, falls Du an irgendeinem Punkt während der Heroku Einrichtung stecken bleiben solltest.

Wenn alles läuft, kannst Du Dich entspannt zurücklehnen, Pizza bestellen und dem Algorithmus bei der Arbeit zuschauen 😎. Denn dafür ist lemon.markets schließlich da: Deine Trades zu automatisieren, damit Du mehr Zeit für andere Dinge hast.

Zusätzliche Überlegungen

Bevor du mit Deiner MR-Strategie anfängst, musst Du noch ein paar Entscheidungen treffen. Zum Beispiel, wie Du den Mittelwert bestimmst. Ist ein Zeitraum von zwei Wochen besser (wie bei uns) oder doch lieber nur wenige Stunden? Außerdem musst Du MR nicht auf Preise beschränken, Du kannst zum Beispiel auch das Kurs-Gewinn-Verhältnis (KGV) einer Aktie betrachten. In unserem Code-Snippet machen wir Trades, wenn sie absolut größer oder kleiner als der Mittelwert sind. Aber vielleicht möchtest Du Deine Strategie so zu bauen, dass Orders nur platziert werden, wenn der aktuelle Preis >0,05% größer als der Mittelwert ist.

Wie Du siehst, gibt es mehr als einen Weg, diese Basisstrategie komplexer (und dadurch hoffentlich rentabler) zu gestalten.

Mean Reversion oder Momentum?

Du hast vielleicht bemerkt, dass die MR-Strategie auf einer kritischen Annahme beruht, nämlich dass auf jede extreme Kursbewegung eine Rückkehr zu den langfristigen Durchschnittswerten folgt. Aber ist das wirklich eine vernünftige Annahme, die man einfach so machen kann? Schließlich kann ein dramatischer Kurseinbruch von Wertpapieren auch von Dauer sein, wenn sich zum Beispiel herausstellt, dass eine Aktie ihre Relevanz im Markt verliert.

Die MR-Strategie basiert auf der Regression zum Mittelwert, ein statistisches Konzept, das das Phänomen beschreibt, dass auf ein unwahrscheinliches Ereignis in der Regel ein erwartetes Ereignis folgt und nicht ein noch unwahrscheinlicheres. Doch wo ist der Haken? Dieses Konzept unterstellt eine Normalverteilung, was der Aktienmarkt einfach nicht ist. Stattdessen ähneln die Aktienrenditen eher einer Verteilung “Fat Tails”. Mit anderen Worten: An der Börse treten extreme Ereignisse häufiger auf als erwartet.

Warum ist MR dann so weit verbreitet? Viele Trader glauben, dass der Aktienmarkt zwischen Perioden von Mean Reversion und Momentum oszilliert. Oder einfach ausgedrückt: Wenn der Kurs eines Wertpapiers steigt, steigt er weiter (und das Gleiche gilt für Abwärtsbewegungen). (Übrigens: Perioden von Momentum sind der Grund, “Fat Tails”) Mean Reversion spiegelt vielleicht nicht immer den Markt wider, aber manchmal eben schon. Wie kannst Du also wissen, ob wir uns in einer Periode der Mean Reversion oder des Momentums befinden? Das ist die große Frage 😉  Es gibt ein paar Maße, die auf historische Kursdaten angewendet werden können, wie zum Beispiel der Hurst-Exponent. Mit diesem Skalar kannst Du eine Zeitreihe als mean-reverting, random-walk oder trending charakterisieren. Basierend darauf kannst Du entscheiden, ob Du eine Mean-Reversion- oder eine Momentumstrategie verfolgen möchtest. Wenn Du Dich für solche Dinge interessierst, kannst Du hier weiter lesen.

Ich hoffe, Du hast eine Vorstellung davon bekommen, was Du mit der lemon.markets API alles machen kannst. Wir freuen uns über jedes Feedback! Melde Dich einfach unter [email protected] oder tritt unserer Slack Community bei. Lass uns wissen, was Du denkst, reporte Bugs oder teile eine Strategie, die Du gebaut hast. Wir freuen uns, von Dir zu hören 🍋 💛.

Marius

Das könnte Dich auch interessieren

Richte Deinen eigenen Telegram-Bot für den Handel mit der lemon.markets API ein (Teil 1 von 2)

blog photo

Hallo! Ich bin Joanne aus dem lemon.markets Team. Ich habe in den letzten Wochen an einem Use-Case für unser Produkt gearbeitet und freue mich sehr, das Ergebnis hier mit Euch zu teilen! Es gibt hunderte Use-Cases für unser Produkt, von automatisierten Handelsstrategien bis hin zu Dashboards, die Dein Portfolio visualisieren. Heute zeige ich Dir, wie Du die lemon.markets API mit der Telegram API verbinden kannst. Warum? Damit Du einen personalisierten Butler - ähm, Bot - hast, der mit ein paar sehr einfachen Nachrichten Orders für dich platzieren kann.

Erstelle dein eigenes lemon.markets Dashboard mit Flutter

blog photo

Hallo zusammen! Mein Name ist Marius und ich bin Teil von lemon.markets, einem early-stage Startup aus dem Herzen Berlins. Wir arbeiten an einer Infrastruktur, mit der Du Deine eigene Trading Experience an der Börse bauen kannst. In diesem Blogbeitrag führe ich Dich durch ein Projekt unseres Community-Mitglieds Melanie. Dafür schauen wir uns an, wie man mit Flutter ein mobil-optimiertes Web Dashboard bauen kann. Hört sich das an als wäre es was für Dich? Dann lass uns keine Zeit verschwenden und direkt loslegen.

Anleitung für eine Mean Reversion Strategie mit der lemon.markets API & Hosting in der Cloud

blog photo

In diesem Beitrag möchte ich Dir zeigen, wie Du die lemon.markets API nutzen kannst, um eine der bekanntesten Handelsstrategien zu bauen: Die Mean Reversion Strategie. Außerdem zeige ich Dir, wie Du Deine Strategie mit Heroku in der Cloud hosten kannst, damit Dein Skript weiterläuft, auch wenn Dein Laptop ausgeschaltet ist.

Tiefer eintauchen

Finde weitere Ressourcen für einen einfachen Einstieg

In unserer Dokumentation erfahrt Ihr mehr über unsere API-Struktur, die verschiedenen Endpunkte und spezifische Anwendungsfälle.

Austauschen

Tritt der lemon.markets Community bei

Tritt unserem Slack-Channel bei, um Dich aktiv an unserer Community zu beteiligen, Fragen an andere Nutzer:innen zu stellen und immer auf dem Laufenden zu bleiben.

Team unterstützen

Lust lemon.markets mit uns zu bauen?

Wir sind immer auf der Suche nach großartigen Ergänzungen für unser Team, die uns beim Aufbau einer Brokerage Infrastruktur für das 21. Jahrhundert helfen.

Products
Pricing
For Developers
SlackGithubBlog
© lemon.markets 2021Privacy PolicyImprint
All systems normal