Das Prinzip der "Trading Venues" bei lemon.markets


blog photo
Veröffentlicht von Joanne Snel am 15. Juli 2021
Product


Hi! Mein Name ist Joanne und ich bin neu im (stetig wachsenden) lemon.markets-Team. Wir bauen eine API, die es Entwickler:innen ermöglicht, ihre eigene Trading Experience an der Börse zu bauen. Da unsere Closed Beta vor ein paar Wochen gestartet ist (hast Du Dich schon auf unsere Warteliste eingetragen?), möchte ich Dir gerne einige Funktionen unserer API vorstellen. Das Thema dieser Woche: Trading Venues. Stell Dir unter einem Trading Venue einen Handelsplatz oder eine Börse vor, an der Aktien und sonstige Wertpapiere gehandelt werden, z. B. die London Stock Exchange (LSE).

Bei lemon.markets haben wir in unserer API eine Reihe von Endpoints entwickelt, die unter anderem auch den Trading Venue adressieren. In diesem Blogbeitrag werde ich Dir die einzelnen Endpoints vorstellen und erklären, warum bzw. wie Du sie für Dich nutzen kannst. Außerdem zeige ich Dir, wie Du mit diesen Endpunkten automatische E-Mails einrichten kannst, die Dich benachrichtigen, wenn der Markt schließt.

trading venues at lemon markets

Trading Venues sind eine neue Funktion, die wir in unsere neue API aufgenommen haben. Wir glauben, dass sie die API leistungsfähiger macht und die Funktionalität erweitert. Auf unserem Weg, einen transparenten Broker des 21. Jahrhunderts zu bauen, halten wir es für wichtig, dass unsere Nutzer:innen wissen (und entscheiden können), an welchem Handelsplatz sie ihre Orders platzieren. Doch bevor wir uns die Trading Venues in einem speziellen lemon.markets Kontext anschauen, sollten wir uns zunächst mit ein paar Hintergrundinformationen vertraut machen:

Während ich diesen Blogpost schreibe (Juli 2021) gibt es weltweit 21 Börsen mit einer Marktkapitalisierung von über einer Billion US-Dollar. All diese Börsen zusammen sind besser bekannt unter dem Namen “1-Trillion-Dollar-Club” (eng.: Billionen = Trillion). Zudem gibt es sehr viele kleinere Börsen, die eine geringere Marktkapitalisierung und ein geringeres Handelsvolumen haben. Hast Du beispielsweise schonmal von der Maldives Stock Exchange(MSE) gehört, bei der nur 10 Unternehmen gehandelt werden? Wie Du siehst, sind die Optionen (Achtung Wortwitz 😉) für den Handel schier endlos.

Je nachdem, was Du mit unserer API bauen möchtest, kann es hilfreich sein die Besonderheiten der einzelnen Handelsplätze zu kennen, an denen Du Deine Orders platzieren möchtest. In Gesprächen mit unseren Nutzer:innen haben wir festgestellt, dass es unterschiedliche Präferenzen für die verschiedenen Handelsplätze gibt. Daher wollen wir eine flexible Struktur für unsere API schaffen, die es uns ermöglicht, in Zukunft weitere Handelsplätze bei lemon.markets zu integrieren.

Ein kleines Trading Venue Repository

Wir haben ein kleines Projekt erstellt, um eine Reihe von Anwendungsfällen für die Trading Venues aufzuzeigen. Das entsprechende Github Repository findest Du hier 👩🏿‍💻👨‍💻👩🏼‍💻🧑🏿‍💻.

Die Grundlagen 

Zunächst müssen wir ein paar Hilfsfunktionen definieren. Da wir in unserem Skript E-Mails versenden wollen, definieren wir eine Klasse "EmailSenderSendgrid". Wir verwenden Sendgrid, da es den API-basierten E-Mail-Versand vereinfacht. Um unser Repo nutzen zu können, musst Du ein Sendgrid Konto erstellen und Deinen Sendgrid-API-Schlüssel als Umgebungsvariable übergeben. Falls Du noch keinen Account haben solltest: Melde Dich hier an.

Als Nächstes definieren wir Funktionen für GET, PUT und POST Anfragen, um sie im Skript verwenden zu können.

Außerdem müssen wir eine Reihe von Umgebungsvariablen definieren, um das Skript verwenden zu können:

TOKEN_KEY = “Your lemon.markets Access Token”

BASE_URL = “The base URL of our Paper Money API”

MIC = “Market Identifier Code of Trading Venue”

SPACE_UUID = “UUID of your space”

SENDGRID_API_KEY = “Your Sendgrid API Key”

EMAIL_FROM = “Email you want to send emails from”

EMAIL_TO= “Email you want to send emails to”

1import os
2import smtplib
3from email.mime.multipart import MIMEMultipart
4from email.mime.text import MIMEText
5import requests
6from dotenv import load_dotenv
7from sendgrid import SendGridAPIClient
8from sendgrid.helpers.mail import Mail
9class EmailSenderSendgrid:
10    def __init__(self, mail_text: str, mail_subject: str):
11        load_dotenv()
12        message = Mail(
13            from_email=os.environ.get('EMAIL_FROM'),
14            to_emails=os.environ.get('EMAIL_TO'),
15            subject=mail_subject,
16            html_content=mail_text)
17        try:
18            sg = SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))
19            response = sg.send(message)
20            print(response.status_code)
21            print('email successfully delivered')
22        except Exception as e:
23            print(e.message)
24class RequestHandler:
25    load_dotenv()
26    url: str = os.environ.get("BASE_URL")
27    def get_data(self, endpoint: str):
28        """
29        :param endpoint: {str} only append the endpoint to the base url
30        :return:
31        """
32        response = requests.get(self.url + endpoint,
33                                headers={
34                                    "Authorization": "Bearer "+os.environ.get("TOKEN_KEY")
35                                })
36        return response.json()
37    def put_data(self, endpoint: str):
38        response = requests.put(self.url + endpoint,
39                                headers={
40                                    "Authorization": "Bearer " + os.environ.get("TOKEN_KEY")
41                                })
42        return response.json()
43    def post_data(self, endpoint: str, data):
44        response = requests.post(self.url + endpoint,
45                                 data,
46                                 headers={
47                                     "Authorization": "Bearer " + os.environ.get("TOKEN_KEY")
48                                 })
49        return response.json()

Bestimmung des Trading Venue

Wenn alle Vorbereitungen abgeschlossen sind, können wir uns endlich mit den Trading Venues befassen.

Stell Dir vor, Du möchtest ein paar Deiner Lieblingsaktien kaufen, weißt aber nicht so richtig, wo Du anfangen sollst? Wir denken, es ist ein guter erster Schritt sich zu überlegen, an welchem Handelsplatz man seine Order platzieren möchte. Es gibt einige Gründe, warum Du einen Handelsplatz einem Anderen vorziehen könntest, z. B. ein größeres Angebot, niedrigere Transaktionskosten oder bessere Öffnungszeiten. Um zu sehen, welche Trading Venues lemon.markets integriert hat, kannst die folgende URL verwenden, die eine Liste aller von uns angebotenen Handelsplätze zurückgibt:

1https://paper-data.lemon.markets/v1/venues/

Folgender Code liefert Dir eine Antwort im praktischen JSON Format.

1from helpers import RequestHandler
2class TradingVenues(RequestHandler):
3    def get_all_trading_venues(self):
4        endpoint = 'venues/'
5        response = self.get_data(endpoint)
6        print(response)
7if __name__ == "__main__":
8    TradingVenues().get_all_trading_venues()

Wenn Du diesen Endpunkt verwendest und Dir die Antwort auf die Anfrage genauer ansiehst, wirst Du feststellen, dass wir in der lemon.markets Beta-Version derzeit nur einen Handelsplatz unterstützen. Wir gehen jedoch davon aus, dass lemon.markets in Zukunft mehrere Börsenplätze integrieren wird, was bedeutet, dass noch mehr Aktien, Anleihen, Fonds, ETFs und Optionsscheine zur Auswahl stehen. Natürlich werden unsere Nutzer:innen die Ersten sein, die erfahren, wenn wir weitere Handelsplätze integrieren.

Neben einer Übersicht über alle verfügbaren Trading Venues kannst Du über diesen Endpunkt auch einen einzelnen Handelsplatz abrufen:

1https://paper-data.lemon.markets/v1/venues/?mic={mic}

Auch hier verwenden wir Python. Ist Dir das "{mic}" in der Anfrage-URL aufgefallen? An dieser Stelle kannst Du den Handelsplatz angeben, den Du verwenden möchtest. Das “mic” steht für "Market Identifier Code". In unserem Skript wird dies durch Umgebungsvariablen (Environment Variables) gelöst, die wir dann in der Anfrage-URL verwenden. Aber Du kannst den “mic“ natürlich auch manuell setzen, wenn Dein Use Case von unserem abweicht.

1import os 
2from dotenv import load_dotenv
3from helpers import RequestHandler  
4class SingleTradingVenue(RequestHandler):    
5   def get_single_trading_venue(self):        
6        load_dotenv()        
7        mic = os.getenv("MIC")        
8        endpoint = f'venues/?mic={mic}'        
9        response = self.get_data_data(endpoint)        
10        print(response)  
11
12if __name__ == "__main__":   
13     SingleTradingVenue().get_single_trading_venue()

Die Anfrage dieses Endpunkts liefert Dir die folgende Antwort: 

1{ 
2  “name”: “Example Stock Exchange”, 
3  “title”: “stex”, 
4  “mic”: “XEXAMPLE”, 
5  “is_open”: true 
6}

Wie Du siehst, gibt der Endpunkt neben allgemeinen Informationen über den Handelsplatz auch zurück, ob der Handelsplatz derzeit geöffnet ist. Diese wertvolle Information kannst Du einfach in Deine Handelsstrategie integrieren. Wir kommen gleich darauf zurück und zeigen Dir anhand eines konkreten Beispiels, wie Du eine einfache E-Mail-Benachrichtigung einrichten kannst, wenn ein Handelsplatz geschlossen ist. Jeder Handelsplatz verfügt über eine Liste von Wertpapieren, welche dort gehandelt werden können. Diese kannst Du über folgenden Endpunkt bequem abfragen:

1https://paper-data.lemon.markets/v1/instruments/?mic={mic}&search=SEARCHTERM

Mit dem folgenden Code suchen wir nach Tesla und dem Typ = Aktie, aber Du kannst auch andere Abfrageparameter verwenden, z. B. die Währung oder ob die Aktie derzeit handelbar ist. Du kannst auch nach ISIN oder WKN suchen, wenn diese besser für Dich passen. Je genauer Du die Parameter in der Abfrage definierst, desto spezifischer werden die Ergebnisse sein.

1import os
2from dotenv import load_dotenv
3from helpers import RequestHandler  
4
5class TradingVenueInstrument(RequestHandler):    
6  def get_trading_venue_instruments(self):        
7        load_dotenv()        
8        mic = os.getenv("MIC")        
9        endpoint = f'instruments/?mic={mic}&search=Tesla&type=stock'
10        response = self.get_data_data(endpoint)
11        print(response)
12if __name__ == "__main__":
13    TradingVenueInstrument().get_trading_venue_instruments()

Öffnungszeiten

Eine der am meisten gewünschten Funktionen für unseren Prototyp, den wir im Herbst letzten Jahres gelauncht haben, war die Möglichkeit, die Öffnungszeiten der Handelsplätze zu überprüfen. Wir haben uns dieses Feedback zu Herzen genommen und das Feature umgesetzt.

Mit unserer API hat man jetzt die Möglichkeit, die Öffnungstage und -zeiten eines bestimmten Handelsplatzes abzufragen. Hierfür haben wir den folgenden Endpunkt eingerichtet:

1https://paper-data.lemon.markets/v1/venues/?mic={mic}

Das folgende Codeschnipsel gibt eine Liste von Tagen mit bestimmten Öffnungs- und Schließzeiten zurück.

1import os
2from dotenv import load_dotenv
3from helpers import RequestHandler  
4class TradingVenueOpeningDays(RequestHandler):
5    def get_trading_venue_opening_days(self):
6        load_dotenv()
7        mic = os.getenv("MIC")
8        endpoint = f'venues/?mic={mic}'
9        response = self.get_data_data(endpoint)
10        opening_days = response['results'][0].get('opening_days', None)
11        print(opening_days)
12 if __name__ == "__main__":
13    TradingVenueOpeningDays().get_trading_venue_opening_days()

Mit der Response erhältst Du den aktuellen und alle zukünftigen Tage, und Du kannst diese Informationen nutzen, um Deine Strategie so anzupassen, dass sie nur Aufträge erteilt, wenn der Handelsplatz tatsächlich geöffnet ist. Auf diese Weise wird vermieden, dass Du eine Order erstellst, nur um festzustellen, dass es ein Samstag ist und der Auftrag erst in zwei Tagen ausgeführt werden kann. Oder dass Du eine Market Order nach Börsenschluss erstellst, die dann am nächsten Morgen zu einem unerwünschten Eröffnungskurs ausgeführt wird.

Wie Du siehst, erhältst Du die Zeitstempel für den aktuellen und alle zukünftigen Tage. Mit dieser Information kannst Du Deine Strategie so anpassen, dass nur Orders platziert werden, wenn der jeweilige Handelsplatz tatsächlich geöffnet ist. Auf diese Weise vermeidest Du, dass Du eine Order erteilst und dann feststellst, dass es beispielsweise Samstag ist und der Auftrag erst in zwei Tagen ausgeführt wird. Oder dass Du eine Market Order nach Börsenschluss erteilst, die dann am nächsten Morgen zu einem schlechteren Eröffnungskurs ausgeführt wird.

Das muss ja nicht sein! Indem Du die Öffnungszeiten des von Dir gewählten Trading Venues einbeziehst, kannst Du Deine Strategie so konfigurieren, dass zum Beispiel nicht ausgeführte Orders nach Börsenschluss verfallen, keine neuen Orders während der volatilsten Zeiten des Handelstages platziert werden oder Du benachrichtigt wirst, wenn der Markt öffnet und schließt.

Ein praktischer Use Case

Wir möchten Dir Inhalte zur Verfügung stellen, die Dich inspirieren und mit denen Du direkt anfangen kannst, Dinge mit lemon.markets zu bauen. Daher haben wir für Dich ein kleines Python-Skript erstellt, das überprüft, ob der Handelsplatz derzeit geöffnet ist. Wenn ja, wird Deine Order platziert und wenn nicht, erhältst Du eine automatische E-Mail, die Dich darüber informiert. Außerdem schickt Dir das Skript bei Börsenschluss eine automatische E-Mail, die Dich über Deine Portfoliopositionen informiert.

Wie bereits erwähnt, verwenden wir Sendgrid, um E-Mails zu versenden und wir empfehlen Dir, dies ebenfalls zu tun, da es sich perfekt in Dein Python-Skript integrieren lässt.

Für den Anfang definieren wir einige Hilfsfunktionen:

  1. Eine Funktion zur Ermittlung der "nächsten Schlusszeit". Dazu rufen wir das erste Element des JSON-Arrays mit den Öffnungs- und Schließungszeiten für den jeweiligen Handelsplatz ab und geben das erste Array-Element zurück.

  1. Eine Funktion zum Abrufen des Portfolios. Dazu verwenden wir den Portfolio-Endpunkt, wandeln die JSON-Antwort in einen String um und übergeben ihn an unsere Funktion "E-Mail senden" (siehe unten).

  1. Eine Funktion, die "schläft", bis der Markt schließt, und dann eine E-Mail mit den Positionen des Portfolios versendet. Wir ermitteln die aktuelle Zeit als UNIX-Timestamp und subtrahieren sie vom nächsten Börsenschluss. Dann schicken wir die Funktion in den wohlverdienten Schlaf und rufen unser Portfolio ab, wenn sie "aufwacht".

  1. Eine Funktion, die prüft, ob der Handelsplatz derzeit geöffnet ist. Wir verwenden den Endpunkt, um einen einzelnen Handelsplatz abzurufen, greifen auf das Attribut "is_open" zu und geben einen booleschen Wert zurück.

  1. Eine Funktion zur Aktivierung einer platzierten Order. In unserer Papiergeld-API musst Du zusätzlich alle Aufträge aktivieren, nachdem Du sie erteilt hast. Diese Hilfsfunktion nimmt die Order UUID als Eingabeparameter und ruft anschließend den Endpunkt "activate order" auf.

Schließlich können wir unsere Hauptfunktion definieren: place_order(). Hier kommen alle unsere zuvor definierten Hilfsfunktionen zum Einsatz. Zunächst prüfen wir, ob der Handelsplatz derzeit geöffnet ist. Ist dies nicht der Fall, senden wir eine E-Mail mit dem Hinweis, dass der Markt derzeit geschlossen ist. Ist der Marktplatz geöffnet, platzieren wir unsere Order. Außerdem warten wir, bis der Markt schließt, und senden dann die E-Mail mit unserem Portfoliopositionen bei Marktschluss.

1import os
2from dotenv import load_dotenv
3import json  
4from helpers import RequestHandler, EmailSenderSendgrid  
5
6class TradingVenue(RequestHandler):
7        def send_out_email(self):
8        load_dotenv()
9        space_uuid = os.getenv("SPACE_UUID")
10        endpoint = f'spaces/{space_uuid}/portfolio/'
11        response = self.get_data_trading(endpoint)
12        email_text = json.dumps(response)
13        subject = "Your Portfolio at market close"
14        EmailSenderSendgrid(email_text, subject)
15
16     def check_if_open(self):
17        load_dotenv()
18        mic = os.getenv("MIC")
19        endpoint = f'venues/?mic={mic}'
20        response = self.get_data_data(endpoint)
21        is_open = response['results'][0].get('is_open', 'It was not possible to retrieve the is_open attribute')  
22        print(is_open)
23        return is_open    
24  def activate_order(self, order_uuid):
25        load_dotenv()
26        space_uuid = os.getenv("SPACE_UUID")
27        endpoint = f'spaces/{space_uuid}/orders/{order_uuid}/activate/'
28        response = self.put_data(endpoint)
29        print(response)     def place_order(self):
30             load_dotenv()
31            if not self.check_if_open():
32            email_text = "Hey there. You tried to place an order with the lemon.markets API, but the market is currently closed. Please try again later."
33            subject = "The market is currently closed"
34            EmailSenderSendgrid(email_text, subject)
35            return         # send notification email if trading venue is closed
36                 try:            order_details = {
37                "isin": "DE0008232125",  # ISIN of Lufthansa
38                "valid_until": 2000000000,  # specify your timestamp
39                "side": "buy",
40                "quantity": 1,
41            }
42            space_uuid = os.getenv("SPACE_UUID")
43            endpoint = f'spaces/{space_uuid}/orders/'
44            response = self.post_data(endpoint, order_details)
45            order_uuid = response.get('uuid')
46            # access helper function to activate the order
47            self.activate_order(order_uuid)
48            print('order was activated')
49            # additionally, we send an email with the portfolio items at market close
50            self.send_out_email()
51        # throw exception in case something goes wrong
52        except Exception as e:
53            print('placing order not possible', e)
54if __name__ == "__main__":    TradingVenue().place_order()

Natürlich ist dieses kleine Skript nur ein Ausgangspunkt für Dich, der Dir zeigt, wie Du unsere Trading Venue-Endpunkte gezielt nutzen kannst, um mehr Flexibilität und Stabilität in Deine automatisierte Handelsstrategie zu bringen. Wenn Du Interesse hast, schau Dir unser öffentliches GitHub-Repository an, das in diesem Blogbeitrag verlinkt ist und mache einen PULL request. Wie wäre es, wenn Du Dir eine weitere E-Mail sendest, wenn der Markt wieder geöffnet wird? Oder wenn wir ein wenig warten, bis wir die Order aktivieren, um den bestmöglichen Preis zu erhalten? Wie wäre es, wenn wir die Order am nächsten Morgen, 2 Stunden nach Öffnung des Handelsplatzes erteilen? Spiel ruhig ein bisschen mit der API herum und baue etwas Verrücktes 😵.

Wir sind sehr gespannt auf Deine Ideen!

Was kann man sonst noch mit Trading Venue Endpunkten machen?

Während wir oben einen grundlegenden Anwendungsfall behandelt haben, gibt es viele weitere interessante Ideen für unsere Trading Venue-Endpunkte.

Vielleicht könntest Du Dein Programm mit Deinem Kalender verbinden, um automatisch die Tage zu markieren, an denen der Markt geschlossen ist. Wir empfehlen, den Endpunkt GET /trading-venues/{mic}/opening-days aufzurufen, um alle Öffnungstage eines bestimmten Trading Venue zu erhalten. Für jeden Tag, der nicht in der Liste enthalten ist, können Du davon ausgehen, dass der Markt geschlossen ist. Du kannst auch die Wochenenden herausfiltern, weil wir Du sicher weist, dass der Markt dann geschlossen ist. Diese Tage können z. B. in die Google Calendar API eingespeist werden. Mit den Ressourcen calendars() und events() können dann sowohl ein neuer Kalender als auch entsprechende Ereignisse erstellt werden.

Du kannst Dein Programm auch so konfigurieren, dass es nach Börsenschluss eine automatische E-Mail mit der Wertentwicklung Deines Portfolios versendet. Dazu kannst Du denselben Endpunkt wie oben abrufen, nämlich GET /trading-venues/{mic}/opening-days, und wenn "closing_time" mit der aktuellen Uhrzeit übereinstimmt, eine E-Mail-Benachrichtigung über dieselbe E-Mail-Ressource auslösen, wie in dem oben beschriebenen Anwendungsfall. In der E-Mail könntest Du einfach den Gesamtzuwachs Deines Portfolios melden, indem Du den Wert Deines Portfolios bei Börsenschluss mit dem des Vortags vergleichst (versuche es mit dem Endpunkt GET spaces/{space_uuid}/portfolio, weitere Informationen zu Spaces findest Du hier). Du könntest Dir sogar die Mühe machen, die Leistung mit einer (Python-)Bibliothek wie f.fn() zu messen. Wenn Du kein großer Fan von E-Mails bist: Wie wäre es, wenn Du Dein eigenes Trading-Dashboard am Ende eines jeden Tages automatisch mit Deinem Portfoliowert bei Marktschluss aktualisieren würdest? Wir wiederholen uns nur ungern, aber die Möglichkeiten sind (fast) endlos.

Hast Du weitere Ideen? Wir würden uns freuen zu hören (und natürlich zu sehen), welche interessanten Anwendungen für die Trading Venue-Endpunkte Du Dir ausdenkst.

Um mit dem Entwickeln zu beginnen, solltest Du Dich auf unsere Warteliste setzen lassen, um die API in der Praxis zu testen. Schreib uns eine E-Mail an [email protected] oder werde Mitglied unserer wachsenden Slack-Community.

Wir sehen uns auf lemon.markets 🍋

Joanne

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