Forem: Joanne

Exploring the lemon.markets instruments endpoint

Joanne — Fri, 21 Jan 2022 14:35:20 +0000

At lemon.markets, we’re empowering developers to take brokerage into their own hands by building Europe’s first trading API. In today’s article, we want to showcase one of the useful endpoints we provide: /instruments. It can be used to identify the various financial instruments that can be traded on lemon.markets, such as stocks and ETFs.

The lemon.markets API currently offers 8250+ popular stocks and ETFs — we’ve got (most 😉) big-name instruments. Not sure if we carry a particular listing? You can easily use the '/instruments' endpoint to search for specific financial instruments. Want to see how it’s done? Let’s jump right in.

Why search for my financial instrument? 🔎

If you already know the name of the financial instrument you wish to trade, why should you use the /instruments endpoint? Our API identifies financial instruments through an ISIN (International Securities Identification Number). If you know the ISIN of the instrument you wish to trade, you’re ready to place your order! But, if you don’t, you can use this endpoint to find the ISIN associated with that instrument.

Besides the ISIN, the /instruments endpoint also provides information about:

the exchange the instrument is listed on,
the symbol, WKN and title associated with the instrument,
the type of instrument you’re dealing with (stock/ETF/etc.),
in which currency the instrument is traded and
whether it’s currently tradable.

This information allows you to double-check that you’re referring to the correct instrument, on the correct exchange, in the correct currency. Additionally, only placing orders if the instrument is currently tradable (and the exchange on which it’s traded is open), will ensure that you have no surprise unexecuted orders.

The /instruments endpoint 🎺

To access the /instruments endpoint, you’ll need to use the following URL:

https://data.lemon.markets/v1/instruments/

In Python, a GET request using this URL looks as follows (note: we have sample code snippets in JavaScript in our docs):

import requests

response = requests.get("https://data.lemon.markets/v1/instruments/", 
                        headers={"Authorization": f"Bearer YOUR-API-KEY"})

print(response.json())

If you’d like to use this code snippet, you’ll have to insert your own API key.

Without any search specifications, this endpoint will return all of the instruments that can be traded with the lemon.markets API (only a very short portion of the response is listed). Perhaps this is useful if you’re simply browsing what we have on offer. But, what if you’re looking for something specific?

Specifying your search ➡️

Imagine you’re looking for the ISIN that belongs to Coinbase. How do we alter the search? There’s a number of query parameters that can be added to the end of the URL. These are:

search, search query for a name, title, ISIN, WKN or symbol (note: your query must be longer than 4 characters),
isin, if you know the ISIN of the instrument you’re looking for (you can specify up to 10 different ISINs if you’re looking for more than one),
mic, the Market Identifier Code of the exchange you wish to trade on,
currency, ISO currency code for the currency in which you’d like to trade and
tradable, a boolean value to filter for tradable and non-tradable instruments.

Besides that, if your API result contains several entries, you can paginate through the response using the pagination parameters limit and page. If you’d like to learn more, you can find the details here.

In our case, we’re interested in specifying search because we know the title of the instrument we’re looking for. And let’s specify tradable because we only wish to return instruments that can be traded. This means the URL against which we place the request turns into:

https://data.lemon.markets/v1/instruments/?search=coinbase&tradable=true

The request is placed in the same way as in the above code sample. The API outputs the following response:

{
    "results": [
        {
            "isin": "US19260Q1076",
            "wkn": "A2QP7J",
            "name": "COINBASE GLB.CL.A -,00001",
            "title": "COINBASE GLOBAL INC.",
            "symbol": "1QZ",
            "type": "stock",
            "venues": [
                {
                    "name": "Börse München - Gettex",
                    "title": "Gettex",
                    "mic": "XMUN",
                    "is_open": true,
                    "tradable": true,
                    "currency": "EUR"
                }
            ]
        }
    ],
    "previous": null,
    "next": null,
    "total": 1,
    "page": 1,
    "pages": 1
}

Note that the results list now only contains one instrument because we specified our query with enough detail to narrow down the search. We can now use this ISIN to place trades with the Trading API.

That’s all there is to know about the /instruments endpoint! We hope it was helpful in exploring what can be done with lemon.markets. If you’re not yet signed-up, join us today!

Joanne from 🍋.markets

Manage your trading portfolio with the lemon.markets brokerage API

Joanne — Tue, 21 Dec 2021 18:55:21 +0000

An important part of a functional brokerage service is the possibility to conveniently monitor everything related to your portfolio. Therefore, in this blog post, I want to dive deeper into how to keep an overview of your portfolio items with the lemon.markets brokerage API.

lemon.markets was born out of the wish/need to have more flexibility in the way you manage your trading activities. The result of months of iteration with our beta users is an API that allows you to build your own brokerage experience at the stock market, customised to your individual use case. Check out our documentation to learn more about the structure of our API and what you can build with it.

We offer different endpoints to, for instance, buy or sell stocks, retrieve historical market data or manage your account. However, in this blog post we we want to specifically deal with the /portfolio endpoint which allows you to conveniently monitor your (who would’ve guessed?) portfolio.

In general, your portfolio consists of different portfolio items that are the result of executed orders. This means that if your portfolio is empty and you place an order for 10 Tesla shares, once that order is executed (i.e. placed and filled at the stock market) your portfolio consists of 10 shares of Tesla stock.

Let’s take a look at how you get that information through the lemon.markets API.

Using the /portfolio endpoint

To access your portfolio, use the following URL:

https://paper-trading.lemon.markets/v1/portfolio/

Below, find an example code snippet in Python. Check out our documentation for additional code snippets in JavaScript.

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/portfolio/", 
                       headers={"Authorization": "Bearer YOUR-API-KEY"})
print(request.json())

Making the request stated above will result in a response similar to this one:

{
  "time":"2021-11-21T19:34:45.071+00:00",
  "status": "ok",
  "results": [
    {
     "space_id": "sp_pyPFYssNNJyV4m8rxtK7LnfGwKLMk2njSv",
     "isin": "US19260Q1076",
     "isin_title": "COINBASE GLOBAL INC.",
     "quantity": 1,
     "buy_quantity": 1,
     "sell_quantity": 0,
     "buy_price_avg": 2965000,
     "buy_price_min": 2965000,
     "buy_price_max": 2965000,
     "buy_price_avg_historical": 2965000,
     "sell_price_min": null,
     "sell_price_max": null,
     "sell_price_avg_historical": null,
     "orders_total": 1,
     "sell_orders_total": 0,
     "buy_orders_total": 1
    },
    {
      "space_id": "sp_pyPFYssNNJyV4m8rxtK7LnfGwKLMk2njSv",
      ...
    }
  ]
}

The results part of the response is an array of objects. Each object represents a different portfolio item and you can retrieve a lot of interesting information from it. For instance, the space_id tells you which Space the portfolio item belongs to, isin is the International Security Identification Number through which an instrument can uniquely be identified. Additionally, you receive information on the current quantity of the instrument in your portfolio, how many shares you bought, how many you sold and at what price.

Working with query parameters

While a general overview of all portfolio items is nice, you might want to narrow your search. That’s what query parameters are for. In the /portfolio endpoint, you can query for the space_id and the isin, which allows you to either only see portfolio items from a specific Space or only portfolio items for a specific instrument. Or both.

Using the query parameters is really easy, you simply add them to your request URL.

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/portfolio/?isin=US88160R1014", 
                       headers={"Authorization": "Bearer YOUR-API-KEY"})
print(request.json())

This will result in only Tesla portfolio items being displayed. If you have multiple Spaces with which you traded Tesla stock, you will still retrieve multiple objects, e.g. Space 1 with 17 Tesla shares, Space 2 with 9 Tesla shares, and Space 3 with 2 Tesla shares. However, if you only hold the respective portfolio item in one of your Spaces, the API will only return a results array of length one.

Additionally, you can also enforce to only get one result by also specifying a space_id next to the isin. Simply add &space_id={YOUR_SPACE_ID} to the request URL displayed above. With that request, you will get the portfolio information of a specific instrument in a specific Space.

And now: what to do with it?

The possibilities from here on are (almost) endless. You could build your own dashboard to display your portfolio using some cool charts, you could integrate the information in your own custom trading app or build an analysis tool that automatically buys or sells stock to rebalance your portfolio. Get creative!

We are really excited for you to try out our API and help shape a product that developers enjoy using. Make sure to sign up on our website and join our growing Slack community where we discuss all things lemon.markets with more than 400 developers.

See you there,

the 🍋.markets team

Placing your first order with the lemon.markets Trading API

Joanne — Tue, 21 Dec 2021 18:47:22 +0000

lemon.markets offers a simple API that allows you to create your own brokerage experience at the stock market. An important part of that is the possibility to place orders with one simple API call. In this blog post, I will walk you through the steps you need to take to place and activate an order with the lemon.markets Trading API. Ready, set, go 🏃👩‍💻

Getting access

Start by signing up on our dashboard. After you verified your account, you can log in and use the first API Key and Space that we already created for you by default. After that, you are ready to place your first order.

Place your first order

To place an order with lemon.markets, you need to address the trading API by making a POST request against the base URL and add /orders/ to it:

https://paper-trading.lemon.markets/v1/orders/

Make sure to specify your order through your request body.

Some of the parameters in there are required (isin to specify the instrument you want to buy, expires_at to define when the order expires, side to either buy or sell, quantity to specify how many shares you wish to buy, venue to address a specific trading venue, and space_id to place the order for a specific space).

Others are optional (stop_price to place a stop market order, limit_price for a limit order, or both for a stop limit order, or notes if you want to add some notes with your order so you later know why you placed it in the first place).

See an example request in Python below. You can check out our documentation for additional code snippets in JavaScript and more detailed explanations on different request parameters.

import requests
import json

request = requests.post("https://paper-trading.lemon.markets/v1/orders/",
          data=json.dumps({
              "isin": "US19260Q1076",
              "expires_at": "2021-11-25",
              "side": "buy",
              "stop_price": 5000000,
              "limit_price": 5300000,
              "quantity": 1,
              "venue": "XMUN",
              "space_id": "123456789",
              "notes": "I want to attach a note to this order"
            }), headers={"Authorization": "Bearer YOUR-API-KEY"})
print(request.json())

Place your order

Dealing with the API Response

When you successfully placed your order, the API responds with a

200 
"status": "ok"

and outputs some additional response elements. For instance, you learn about the estimated_price or the regulatory information associated to your order. And you receive the order_id, which is crucial for the next (and final) step before your order can get executed.

Activating an Order

Before we route your order to a trading venue, you first need to activate it. You can do this through the following endpoint:

https://paper-trading.lemon.markets/v1/orders/{order_id}/activate/

See now why it is crucial that the POST request against the /orders/ endpoint returns the order_id? Using the ID, we can activate the order through:

import requests
import json

request = requests.post("https://paper-trading.lemon.markets/v1/orders/{order_id}/activate/",
            headers={"Authorization": "Bearer YOUR-API-KEY"})
print(request.json())

Activate an order through its order_id

On success, the order is activated and routed to the specified trading venue. You can now sit back and relax — your work here is done (for now).

Retrieving your Orders

You can retrieve all your orders by posting a GET request against the /orders endpoint:

https://paper-trading.lemon.markets/v1/orders/

To specify your request, you can add query parameters to your request:

space_id: filter for orders from a specific space
from & to: you can define a time range from which you want to retrieve orders
isin: add this query parameter to only see orders related to a specific isin
side: query parameter to see only buy or sell orders
status: filter for order status, e.g. inactive or executed
type: filter for different types of orders: market, stop, limit, stop_limit

See the example request below to learn how to use the query parameters in your request. In the example, we only want to see Tesla buy orders, therefore using the isin and side query parameters:

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/orders/?isin=US88160R1014&&side=buy", 
                       headers={"Authorization": "Bearer YOUR-API-KEY"})
print(request.json())

Ideas for Inspiration

You now know how to place an order with the lemon.markets Trading API. Now: what to do with it? There are plenty of use cases. Think of the order placement as the final step in your awesome trading project. You have an automated trading strategies that buys stocks based on predefined criteria? Great, the order endpoint is triggered when a certain threshold in your algo is crossed. You built your own trading app to buy and sell stocks? Great, whenever you click the buy/sell button in your application, you will need the POST /orders/ endpoint. What are your additional ideas for how to use the /orders endpoint? Let us know 🙂

I hope you got a good understanding of one of our most crucial API endpoints. If you have any questions or want to get in touch with other liked-minded developers: join our growing Slack community and discuss your newest trading project idea. And for more inspiration: check out our other blog articles.

Excited to see what you are building with us 😍

Working with lemon.markets Spaces👩‍🚀

Joanne — Tue, 21 Dec 2021 18:24:40 +0000

Hey there, it’s Joanne from lemon.markets. We are building a brokerage API to enable developers to build their own brokerage experience at the stock market. In this blog post, we’re not just hopping on the trendy #ToTheMoon hashtag, but instead introduce a real lemon.markets concept: the Space 🚀. Spaces are a crucial component for using lemon.markets. We’ve already written a whole article about the concept and why you should use them, but if you’d like the TL;DR: a Space is an isolated workspace for you to run your trading algorithm/product in such that you can segment your different projects.

In this article, I’ll walk you through how to work with the /spaces endpoint (note that all examples will be in Python). Strap in, we’re blasting off in 3.. 2.. 1.. 👾

Getting your Space(s) 🌌

When you sign-up to lemon.markets, we’ll automatically create a ‘Default’ Space for you — meaning you can start trading right away. Let’s look at that Space, shall we? To retrieve a list of your Spaces, send the following request:

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/spaces/", 
                       headers={"Authorization": "Bearer YOUR-API-KEY"})

print(request.json())

We are using the Paper Trading URL in these examples, but you can apply the same concepts to the Real Money environment by changing the URL to https://trading.lemon.markets/v1/spaces/

This will output something along the lines of:

{
    "time": "2021-12-09T14:14:27",
    "status": "ok",
    "results": [
        {
            "name": "Default",
            "description": null,
            "type": "manual",
            "risk_limit": 100000000,
            "linked": null,
            "created_at": "2021-11-11T19:04:03.984+00:00",
            "id": "sp_example",
            "buying_power": 100000000,
            "earnings": 0,
            "backfire": 0
        },
    ],
    "previous": null,
    "next": null,
    "total": 1,
    "page": 1,
    "pages": 1
}

Each Space has an associated ID. We’ve changed the “id” to “sp_example” in this response for the sake of the article, but you’ll get a longer string.

At this point, we only have a single Space, which is why this list only contains a single element (can also be seen from the total parameter in the response). Each Space can be identified by its Space ID (id in the response). If you want to retrieve the details for a single Space, you can specify the Space ID as a path parameter. This means the URL in the above request changes to:

https://paper-trading.lemon.markets/v1/spaces/{space_id}/

where space_id is the ID of the desired Space.

It’s also possible to filter the retrieved list of Spaces by type (automatic or manual) by including the query parameter type in the URL. For example:

https://paper-trading.lemon.markets/v1/spaces/?type=manual

So, what does this response tell you? You can access the name of the Space and it’s description (which is null in this case, but I’ll show you how to add a description to a new Space shortly). You can also see whether it’s a ‘manual’ or ‘automatic’ Space, namely whether your Space is configured with order execution that requires manual approval or not. You can see the risk limit, the amount of funds that you have allocated to that Space (note: monetary amounts are represented with 4 trailing zeroes, i.e. €100 is represented as 1000000). You’ll see whether it is linked to a Real Money/Paper Space, when it was created and its ID. And lastly, you’ll be able to retrieve the buying power, which is the amount of money you have left to invest, your earnings, which is the profit of that Space and your backfire, which are your aggregated earnings and losses.

Creating a Space 🛸

To create a new Space, send the following POST request:

import requests
import json

request = requests.post("https://paper-trading.lemon.markets/v1/spaces/",
          data=json.dumps({
              "name": "My Space",
              "type": "manual",
              "risk_limit": 10000000,
              "description": "I want to buy ETFs with this Space",
            }), headers={"Authorization": "Bearer YOUR-API-KEY"})

print(request.json())

Remember, we use 4 trailing zeroes, this means this Space has a risk limit of €1,000.

In this example, we create a Space with the name ‘My Space’ and description ‘I want to buy ETFs with this Space’.

Altering your Space 🛰️

If you’ve made a mistake in naming your Space, you can always alter its details, specifically the name, description and risk limit. You can do that with a PUT request as follows:

import requests
import json

request = requests.put("https://paper-trading.lemon.markets/v1/spaces/{space_id}/",
          data=json.dumps({
              "description": "I've added more money to My Space",
              "risk_limit": 50000000,
            }), headers={"Authorization": "Bearer YOUR-API-KEY"})

print(request.json())

You’ll need to replace {space_id} with your own Space ID.

Now, My Space has a new description and a higher risk limit.

Deleting your Space 👽

If you don’t need your Space anymore, you can delete it with the following DELETE request (proceed with caution because this action is not reversible):

import requests

request = requests.delete("https://paper-trading.lemon.markets/v1/spaces/{space_id}/", 
                          headers={"Authorization": "Bearer YOUR-API-KEY"})

print(request.json())

It’s important to note that you can only delete Spaces that do not hold any open positions or pending orders. You must close out of all your positions before deleting a Space.

That’s all there is to know about Space creation, deletion, updates and retrieval. Do you have any additional questions? Feel free to leave them below or reach out to us via Slack.

If you’re not yet signed-up to lemon.markets, you can do that here. We’d love to have you on board! 🚀

See you soon,

Joanne 🍋

How to access your lemon.markets Trading API Account with one API call

Joanne — Tue, 21 Dec 2021 16:45:18 +0000

We at lemon.markets provide the infrastructure so everyone can build their own brokerage experience at the stock market. In this blog post, we show you how to easily access your trading account information with one simple API call. Additionally, we dive a little deeper into our /account endpoint. Let us begin!

Signing up

The first step to accessing your account is to make sure that you actually have one. So, sign up on our dashboard and verify your account through the email that we send you after registration. You can then sign into the dashboard, where we already provide you with your first API Key.

Finding your way around our API

Using that API Key, you can go ahead and start testing our API. You can find everything you need to know in our documentation. We created several endpoints concerned with everything related to your account. Using these endpoints, you can find information about your name (in case you forgot), your current balance, how much cash you have left to invest, the IBAN of your brokerage account and many many more things.

To retrieve information about your account, place a GET request against the following request URL:

https://paper-trading.lemon.markets/v1/account/

You can do so by grabbing the API Key from your dashboard and placing it into the following Python code snippet (find a JavaScript example in our documentation).

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/account/", 
                       headers={"Authorization": "Bearer YOUR-API-KEY"})
print(request.json())

Placing this request will result in a response similar to this one:

{
  "time": "2021-11-22T15:37:56.520+00:00",
  "status": "ok",
  "results": {
    "created_at": "2021-10-12T10:29:49.769+00:00",
    "account_id": "acc_pyNQNll99hQbXMCS0dRzHyKQCRKYHpy3zg",
    "firstname": "Michael",
    "lastname": "Burry",
    "email": "m_burry@tradingapi.com",
    "phone": "+491637876521",
    "address": "Ritterstraße 2A 10969 Berlin",
    "billing_address": "Ritterstraße 2A 10969 Berlin",
    "billing_email": "m_burry@tradingapi.com",
    "billing_name": "Michael Burry",
    "billing_vat": "DE999999999",
    "mode": "money",
    "deposit_id": "K2057263187",
    "client_id": "2057263",
    "account_number": "2057263187",
    "iban_brokerage": "DE12345678902057263",
    "iban_origin": "DE123456789012345",
    "bank_name_origin": "Test Bank",
    "balance": 100000000,
    "cash_to_invest": 80000000,
    "cash_to_withdraw": 20000000,
    "trading_plan": "basic",
    "data_plan": "basic",
    "tax_allowance": 8010000,
    "tax_allowance_start": "2021-01-01",
    "tax_allowance_end": "2021-01-01"
  }
}

As you can see, you get a lot of information on everything related to your account, like when it was created, what your current balance is, on which trading & data plan you are on and the IBAN of your brokerage account. Make sure to check out our documentation for in-depth information on all endpoint response parameters.

Withdrawing money

As you can see in the endpoint response above, you also have a response element called cash_to_withdraw. This is your current balance minus the current sum of your buy orders. Based on that number, you can very easily withdraw money into your reference account via:

https://paper-trading.lemon.markets/v1/account/withdrawals/

(Note that we are currently still working on releasing the real money feature, so it might take some more time until you can use this endpoint 🙂)
Use the following code snippet (with your own API Key, of course) to withdraw money into your reference account.

import requests
import json

request = requests.post("https://paper-trading.lemon.markets/v1/account/withdrawals/",
          data=json.dumps({
               amount: 5000000,
               pin: 1234
            }), headers={"Authorization": "Bearer YOUR-API-KEY"})
print(request.json())

Define the amount you want to withdraw in your request body, along with your individual 4-digit PIN that you set during your onboarding process. After a successful API request, the specified amount is automatically withdrawn.

Retrieving your Bank statements

Obviously, as a user you are interested in staying up to date regarding all activity that is happening on your account. That is what the /bankstatements endpoint is there for. The endpoint returns a list of objects containing all activities from your last “active day” (in the paper money environment) and all activities from the last working day (in the real money environment), where, by default, an end of day balance is created for you. You can access your bank statements using the following request URL:

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/account/bankstatements/?type=order_buy", 
                       headers={"Authorization": "Bearer YOUR-API-KEY"})
print(request.json())

This will return a response similar to the following one:

"time": "2021-12-20T12:48:06.199+00:00",
"status": "ok",
"mode": "paper",
"results": [
        {
            "id": "bst_pyHLSwwFFd6r9fJsNbFhxrB3sl43xCP1GK",
            "account_id": "acc_pyNQNll11hQbXMCS0dRzHyNKLZTYHpy3zg",
            "type": "eod_balance",
            "date": "2021-12-16",
            "amount": 987033450,
            "isin": null,
            "isin_title": null
        },
        {
            "id": "bst_pyQWCwwFFrBm9NhMYJ1yYDnhnMtMs64DNT",
            "account_id": "acc_pyNQNll11nQbXMCS0dRzHyKQCRKYHpy3zg",
            "type": "order_buy",
            "date": "2021-12-16",
            "amount": 8829000,
            "isin": "US88160R1014",
            "isin_title": "TESLA INC."
        }
    ],
"previous": null,
"next": null,
"total": 2,
"page": 1,
"pages": 1
}

As you can see, the last thing I did was I placed a buy order in the paper environment and an end of day balance was created for me.

Seeing some documents

Lastly, you have the chance to very easily access all important documents related to your account via the following URL:

https://paper-trading.lemon.markets/v1/account/documents/

Use the following code snippet, extended by your own API Key, to retrieve a list of documents:

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/account/documents/", 
                       headers={"Authorization": "Bearer YOUR-API-KEY"})
print(request.json())

This will provide you with a list similar to this one:

{
  "time": "2021-11-22T15:41:04.028+00:00"
  "status": "ok",
  "results": [
    {
      "id": "doc_pyNjNcc77ht3T3lH8dJa5fD8jhj2JHJ1xX",
      "name": "account_opening.pdf",
      "created_at": "2021-10-19T14:58:52.813Z",
      "category": "kyc",
      "public_url": "http://testpublicurl.de/",
      "link": "'https://trading.lemon.markets/v1/account/documents/doc_pyNjNcc77ht3T3lH8dJa5fD8jhj2JHJ1xX",
      "viewed_first_at": "2021-10-19T14:58:52.813Z",
      "viewed_last_at": "2021-10-19T14:58:52.813Z"
    }
  ]
}

In there, you find all documents, along with a download link. By clicking the link, you are redirected to a .pdf version of the file.

Alright, that was all there is to say about the lemon.markets account endpoints and what you can do with them. Make sure to sign up to our trading API to build your own brokerage experience at the stock market. Also, join our Slack community, where we discuss all things trading and lemon.markets with more than 400 developers.

Looking forward to seeing you there 🍋 🚀

Using the lemon.markets Postman workspace 📮

Joanne — Tue, 21 Dec 2021 14:20:20 +0000

An easy way to test out the lemon.markets API is by using Postman, a platform that allows you to make API calls right within your browser or desktop app. This way, before you get to building your brokerage product, you’ll know exactly what’s possible. We’ve set up a lemon.markets Postman workspace that can be used to familiarise yourself with the endpoints that we offer in our Market Data and Trading APIs. You’ll see just how simple it is to, for example, place a trade with lemon.markets (hint: it’s just one API call).

Why Postman? 📯

Postman is an easy-to-use application that allows you to test out an API without having to manually set up a testing environment. It’s as simple as filling in a request URL, providing the proper authorisation and inputting the relevant query/request body parameters. Luckily for you, we’ve already set up a lemon.markets Postman workspace with all requests included, all you need to do is fork it, fill in your API key and start sending requests.

Using Postman 👨

The lemon.markets Postman workspace can be found here. For personal use, you need to import the workspace into your own Postman account. Let’s see how that’s done!

Forking the workspace 🍴

We’re assuming you already have a Postman account, but if you don’t, you can easily set one up, here. Because the workspace is public, you need to fork it into your own workspace to be able to send requests.

To fork our workspace, click the ‘…’ next to the collection of your choice and select ‘Create a fork’.

You’ll be prompted to give the fork a name and select a workspace to copy it into. You can choose to create a separate lemon.markets workspace, or simply copy it into the default ‘My Workspace’.

To make requests, you’ll need to set up several environment variables — we’ve also set up a template for this (which you can also fork in the same way).

The environment templates can be found under the conveniently named ‘Environments’ tab on the left hand side.

Configuring the environment 🌳

To set-up your environment, you’ll want to fill in your lemon.markets API key (this can be found on your dashboard). Because your workspace is only accessible to you, it doesn’t matter whether you fill it in under ‘Initial Value’ or ‘Current Value’, but as a best practice, you should always fill in sensitive information under ‘Current Value’. This prevents the information from being synced with the Postman workspace (especially important if you’re working in a (semi-)public workspace).

You’ll know you’re in your forked workspace due to the Ψ next to the environment name — notice I’ve called my fork ‘lemon_tutorial’.

If you already know which Space you’d like to operate in, you can also fill in the ID here. But, if you still need to create a Space or don’t know its ID, we’ll show you how you can use the Trading API workspace to access this information.

Make sure you save any changes (upper right-hand corner) and set the environment active, you can do this by hovering over its name and clicking the check-mark, which should become grey upon success.

If you’ve properly set up your API key and environment, the environment should appear in the upper right-hand corner (as can be seen in the screenshot below). Additionally, if you navigate to the authorisation tab for either Collection, hovering over {{API-KEY}} should display the key you’ve filled in.

If you can’t see your API key upon hovering, ensure that your environment has been saved and set active (you might need to manually select it in the upper right-hand corner if you have more than one environment).

Making your first request ❓

Let’s begin by getting a list of our Spaces. Navigate to the ‘Space’ folder in the Trading API collection. Here, you have the option to retrieve a list of Spaces or a single Space, but also to create, delete and alter a Space (these are all the functionalities that our /spaces/ endpoint offers).

If you haven’t filled in a Space ID yet, you can copy one from the desired Space after placing this request and paste it into your environment (remember to save!). You’ll need to place other requests. You can also create a new Space using the POST request that can be found under the same Space header.

The API response can be found in the console below after clicking the blue ‘Send’ button. In the screenshot, my Space ‘Postman Space’ created on 24 November 2021 can be seen (scrolling shows my other Spaces).

You can also specify query parameters in your request. In this case, you can choose to filter by Paper Money and Real Money Spaces, all you need to do is toggle the ‘type’ key, fill in a value and run the request again. More on that in the next section. 👇

Other important considerations 🤔

To get the most of the lemon.markets workspace, we recommend you read the following tips:

Some endpoints, for example the /ohlc/ endpoint in our Historical Market Data API, have mandatory query parameters. For all query parameters that are required, we’ve configured the workspace to automatically toggle that parameter (indicated by the checked box). But, whether it is optional or required can also be found in the key-value description. In addition, some requests also require path variables as input — these are listed below any query parameters (they can also be recognised in the request URL by a ‘:’). If specified, these are always required.

Note that ‘isin’ is the only required query parameter for this endpoint, we also need to specify the path variable ‘x1’ in order to send this request.

Other endpoints require a request body, you’ll recognise this by the green dots next to the headers underneath the request URL. For example, for the /orders/ endpoint in our Trading API, you’ll notice the green dot next to ‘Body’, this means that we need to fill in information here. Notice that there’s a lot of required variables here! I’ve filled in some example values below.

In the above screenshot, you’ll see I placed a buy order for 2 shares of Tesla.

All other requests follow a similar format — some require you to fill in both ‘Params’ and ‘Body’ variables. Keep an eye out for those green dots!

You’re ready to explore on your own! How about you try placing and activating a trade? And then having a look at your portfolio? Have a look at our documentation to see what’s possible.

Over to you! 🤝

We want to know how we can make this collection better! If there’s any improvements that come to mind, do not hesitate to reach out to us through Twitter, Instagram or Slack. And remember, if you haven’t signed up to lemon.markets yet, do that now to kickstart your automated trading journey.

Joanne from lemon.markets🍋

Understanding the lemon.markets Trading API

Joanne — Tue, 21 Dec 2021 14:00:51 +0000

Offering our users the possibility to conveniently trade via an API is what we at lemon.markets have been working on on a daily basis over the past year. As we just started our public beta a few weeks ago, this goal now slowly becomes reality. In this blog post, I want to introduce you to the structure and functionalities of our Trading API so you can easily get started building your own brokerage experience at the stock market. Let’s get going.

Why trade via an API?

The starting point for lemon.markets was in early 2020 when we painfully realised that there’s no brokerage service in Europe that allows its users to build a trading product in a flexible way, just as they imagine it. What initially started as an interface to automate your trades, lemon.markets evolved into an infrastructure that gives you the freedom to build (basically) any kind of product. Some people may be unsatisfied with the current offering of trading apps and want to create their own application. Others may be interested in setting up an automated trading strategy that does all the work for them. Some people might even be interested in placing a trade in their favourite messaging app (what a coincidence, see an example for a Telegram Trading bot here).

So, we set out on bringing this infrastructure to life and (tada 🎉) have now arrived at a point where we want to share what we created with all of you.

You can see the structure of our Trading API below.

Let’s dive into the endpoints

As you can see, there are two base URLs for our Trading API:

https://paper-trading.lemon.markets/v1/

and

https://trading.lemon.markets/v1/

We have separate URLs for Paper and for Real Money Trading. The APIs follow a near-identical structure (with some real-money specifics). This means that before exposing your product to your hard earned money, you can safely deploy it to a simulated paper-money environment. All without making any changes to your implementation. And once you’re happy with it, you can simply exchange the base URL and your project will be running as before, only this time with real money.

For the rest of the article, we will use the Paper Money base URL for demonstration purposes. We will take a look at:

how to retrieve your account information,
how to see your spaces and create a new one,
how to create a new order and see previous orders,
how to see all your transactions and
how to monitor your portfolio.

If you are interested in diving deeper into our API: check out our docs. There, you will also find information about how to get access to the API.

Interacting with your account

To retrieve information about your account such as name, email address, the IBAN of your brokerage account or how much cash you have left to invest, make a request against the /account endpoint. See below how to address this endpoint.

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/account/", 
                       headers={"Authorization": "Bearer YOUR-API-KEY-HERE"})
print(request.json())

Spaces

Spaces are an important concept for using the lemon.markets API. It allows you to split your account into different trading projects and thereby limit the overall risk. Find out more about the concept here. To create a new Space, use the following code snippet:

import requests
import json

request = requests.post("https://paper-trading.lemon.markets/v1/spaces/",
          data=json.dumps({
              "name": "MyNewSpace",
              "type": "manual",
              "risk_limit": 10000000,
              "description": "I am trying out my new strategy",
            }), headers={"Authorization": "Bearer YOUR-API-KEY-HERE"})
print(request.json())

Make sure to post the request body in JSON format. You have the option to set a name, type of Space (manual or auto), risk limit (the overall limit you can spend on orders with that trade) as well as a description. To learn more about Spaces, e.g. what the difference between a manual and an automated space is, check out our documentation.

Afterwards, you can see all your Spaces. You can also use the query parameter type to only see manual or auto Spaces. Use the following code snippet for that:

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/spaces/?type=manual", 
                       headers={"Authorization": "Bearer YOUR-API-KEY-HERE"})
print(request.json())

Your response will look something like this. As you can see, you can, among others, retrieve your Space ID, which you can use to perform requests for your space, e.g. placing an order or retrieving your portfolio. You also get information on how much money you have left to spend within that space and what your risk limit is.

{
  "time": "2021-12-20T12:54:09.192+00:00",
  "status": "ok",
  "mode": "paper",
  "result": 
  [
    {
      "name": "MyPersonalSpace",
      "description": "In this Space, I only trade stocks",
      "type": "manual",
      "risk_limit": 100000000,
      "linked": "string",
      "id": "sp_pyJHBffGGDyV4m8rxtJ7BnfGwKLNk3bnBy",
      "buying_power": 97035000,
      "earnings": 0,
      "backfire": 2965000
    }
  ]
}

Orders

Placing orders is one of the core features of the Trading API. You can do that with one simple request. In there, you specify all things relevant for your order placement. Using the “isin” request parameter, we buy one share of Coinbase in the example below. Additionally, you can specify when you want the order to expire (“expires_at”) or the Space you want to place the order within (“space_id”).

import requests
import json

request = requests.post("https://paper-trading.lemon.markets/v1/orders/",
          data=json.dumps({
              "isin": "US19260Q1076",
              "expires_at": "2021-11-10T22:59:00.000+00:00",
              "side": "buy",
              "quantity": 1,
              "venue": "XMUN",
              "space_id": "123456789",
              "notes": "This is an informative note attached to my order"
            }), headers={"Authorization": "Bearer YOUR-API-KEY-HERE"})
print(request.json())

Afterwards, you may want to check the orders you already placed. You can filter the orders returned by the API by different query parameters. For example, you could be interested in only seeing buy orders for a specific ISIN. To retrieve these orders, use:

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/orders/?side=buy&&isin=US88160R1014", 
                       headers={"Authorization": "Bearer YOUR-API-KEY-HERE"})
print(request.json())

Portfolio

Finally, using our Trading API you can also retrieve all of your portfolio items by calling the /portfolio endpoint. To make the request more specific, you can query by space and/or ISIN:

import requests

request = requests.get("https://paper-trading.lemon.markets/v1/portfolio/?space_id=123456789&&isin=US88160R1014/", 
                       headers={"Authorization": "Bearer YOUR-API-KEY-HERE"})
print(request.json())

Conclusion

Alright, that was our little deep dive into the lemon.markets Trading API. We hope you learned something and are now more than hyped to start building. We can’t wait to have you on board. Side note: the Trading API is only one of the two APIs that we offer, the other one is our Market Data API, which you can learn more about here.

We are looking forward to seeing what you are building with us. Make sure to sign up on lemon.markets and build your own brokerage experience at the stock market 🍋

10+ online resources for high-quality stock market news

Joanne — Tue, 21 Dec 2021 01:13:38 +0000

When trading stocks, you want to make sure that you are well-informed so you stay ahead of the curve with your investments. Therefore, I want to introduce you to a number of online resources that can help you make better investment decisions by providing you with high-quality news about developments on the stock market. I am part of lemon.markets 🍋, an early stage startup from Berlin, Germany that is working on building a trading API so everyone can create their own brokerage experience at the stock market. Let’s get started!

Being informed is 🔑

While this may be true for a lot of areas in life, it is especially important for making investment-decisions. You don’t want to be the guy/gal that buys stocks based on vague assumptions or even is purely uninformed. Instead, you want to do thorough research and then make decisions based on the results of that research.

While there are a lot of ways to achieve a good basis for decision making, in this article we want to focus on online resources that provide you with information about trends and developments in the stock market. This list is nowhere near complete, as there are (tens of?) thousands of available stock market news websites/podcasts/YouTube channels/newsletters. But we still think that they may be a good starting point if you are just starting out in the investment world (and, of course also, when you are already a bit more experienced, more knowledge never hurt anyone 💁‍♂️).

News Websites

Let’s start with a few websites that focus on providing you with a good overview of current developments in the market and up-to-date stock price data. Essentially, they all go into a similar direction so we don’t want to bore you with an endless list of providers that do (almost) the same thing. Instead, we are going to introduce three (in our humble opinion) cool options. Check them out and decide for yourself — maybe they are a great option to scrape data from and build an awesome trading strategy out of it?

Yahoo Finance

Yahoo Finance is one of the household names when it comes to access to stock market news (and data). The website comes with a few powerful tools that offer you a holistic “stock market experience”. For example, they have a news section with the most recent developments in the (investing) world, intuitive charts and key figures for important/trending stocks/indices or different Watchlists informing you about top performers Additionally, you have the option to customise your Yahoo experience by linking your brokerage account(s) to conveniently monitor your portfolio(s) in one place.

Market Watch

Market Watch is another interesting alternative in the stock market news section. What we especially like about it is the investing subpage of the website where you can get the most recent headlines, conveniently subdivided by different industries. In fact, we liked it so much that we decided to use it for one of our projects, where we implemented a trading strategy that automatically makes investment decisions based on sentiment scores of news headlines — read the article here!

The great thing about Market Watch is the simple UI that displays tickers and price movements along with their articles, which makes it very easy to follow the news presented on the website (or create an automated trading strategy out of it 😏).

Investopedia

If you ever wanted to know more about a specific investment term, chances are high that you stumbled across Investopedia at some point. The website can be described as the Wikipedia for investing, but the offer does not end there. Actually, Investopedia also offers a lot of additional services like current market news and a whole section on trending stocks/topics. You can also use a simulator to “learn stock trading” with paper money. Investopedia is therefore a great starting point to get familiar with the most important terms/concepts and become more confident over time.

As mentioned above, the list of stock market news website goes on and on, which is why we’ll make a hard limit (yup, it’s possible to make API jokes) here and head over to some alternative formats. However, feel free to also check out some of the other popular websites like Bloomberg Europe, Financial Times, Seeking Alpha, Benzinga or Google Finance to find the one that suits you best 🙂

Some cool providers that go beyond offering news

While news are great, you sometimes might be looking for something else that allows you to address a different need. Don’t worry, we’ve got you covered.

Stock News API

We don’t think there ever was a more literal company name — and what you see is what you get. The Stock News API offers a very simple interface that allows you to extract news on different stocks/equities via their tickers. You can specify your requests by focusing on different topics, extracting video news or determining a corresponding sentiment score. The API is sleek and elegant and allows you to easily integrate stock market news into your trading projects. And who knows, maybe you even have an idea for combining the Stock News API with the lemon.markets API? 😏

Finimize

Finimize has been in the news in recent weeks because of its acquisition through the Scottish investment company abrdn. Finimize grew rapidly over the last few years and now has ~1 million subscribers to its newsletter. However, what may be even more interesting is the Finimize community that actively discusses all things investing and regularly meets up for specific events. Along with a sleek mobile app that conveniently displays current news in written or audio form (depending on what you prefer), Finimize is the go-to place for many amateur and professional investors. Maybe it’s also exactly the right place for you?

Newsletters to stay up-to-date via your inbox

For some of you, it may be too much of a time effort to go looking for relevant information all by yourself. It can be hard to distinguish between news that are actually meaningful and such that are basically not worth talking about. A solution might be to sign up for a newsletter that conveniently sends relevant information directly to your inbox. Luckily, there a number of great options out there that make sure that you are always up-to-date.

Sifted Newsletter

Sifted is one of the most important names in the European start-up scene. The media site that is backed by the Financial Times offers valuable insights on all things happening within the (European) entrepreneurial landscape. While their focus is on breaking news on innovative start-up companies, one of their focus areas is FinTech, with important stories and reports on developments being published regularly. Thus, it comes with no surprise that Sifted also offers a convenient newsletter that informs you about the FinTech scene once a week. Even though this is not stock news per se, it can still be a great tool to stay up-to-date with all things FinTech and spot future trends that will help you make better investment decisions.

Robinhood Snacks

Say what you will about Robinhood, but they brought investing at the stock market to the masses with their easy-to-use and modern mobile application. Although the public opinion about the company has massively decreased in the course of the r/wallstreetbets affair (if you need a reminder, read here) and their different ways of making money has sparked criticism from different sides, it is still the #1 option for many (American) people. Besides their main product, the mobile app, Robinhood also offers a number of additional services. One of them is Robinhood Snacks, a daily newsletter that, if we believe Robinhood, takes only 3 minutes to read. Sounds like a minimum effort for staying ahead of the curve, doesn’t it?

Podcasts

It seems almost illegal to create a list of online resources without including a number of podcasts. Therefore, we won’t even try. In recent years, podcasts have rapidly found their way into mass consumption. And for a reason: you can listen to them while you take the subway to work, wash your dishes at night or drink your morning coffee. We identified three examples which we think will bring value to you.

Ohne Aktien wird schwer from OMR and TradeRepublic

This is a podcast for the German-speaking users. OMR, a leading platform for online marketing hosts a daily (well, Mon-Fri) podcast concerned with delivering up-to-date stock news. The podcast is supported by Trade Republic, a neo-broker from Berlin that recently closed a large financing round valuating the company at around $5 billion dollars. The ~10 minute long episodes give you a condensed overview each morning, which is why it is a perfect way to start your day.

Odd Lots

Odd Lots, the in-house podcast by media company Bloomberg, is run by Joe Weisenthal, a news director covering all topics concerned with the stock market and Tracy Alloway, an executive editor for Bloomberg Markets who, prior to her work at Bloomberg, used to work as a financial correspondent for the Financial Times. The podcast, which is released twice a week, covers all financial topics and newest developments at the stock market.

The Investopedia Express

There is a reason why Investopedia makes our list twice. While the website itself already offers great value the Investopedia service is extended by a great podcast: The Investopedia Express. Hosted by Caleb Silver, editor-in-chief of Investopedia, sheds a weekly light on all important stories in finance and global economics. A great thing about this podcast are the frequent guests, with which Silver sits down to analyse developments or share insights. Highly recommended.

Conclusion

This concludes our list of online resources for high-quality stock market news. We hope you could find an option that suits your needs. In the end, there are different preferences regarding consumption of content, which is why it is important (and great) that there are so many different alternatives out there.

Do you think there is something missing on our list? Let us know in the comments. Otherwise we are looking forward to welcoming you to lemon.markets, where you can put all your newly-gained knowledge into action and create your own brokerage experience at the stock market. We are really excited to see what you are building with us.

See you there 🍋

Automated news-following trading strategy using sentiment analysis

Joanne — Mon, 22 Nov 2021 13:16:57 +0000

In this project we’ll build a sentiment analysis strategy that autonomously trades based on news headlines. We show you how to:

scrape headlines from a financial website using the Python requests library and BeautifulSoup,
determine sentiment using VADER,
arrive at trade decisions and
place trades using the lemon.markets trading API. 🍋

We’re excited to show you how lemon.markets is the perfect tool for a project like this.

If you want to get started developing straight away, you can check out our GitHub repository for this project here. Otherwise, keep reading to learn more about the strategy.

Collecting your data 📊

For this project, our goal is to place trade automatically based on the news. The first step is to decide how we want to gather our data, and especially from which source. We went for MarketWatch because the data is presented in an easily digestible format — for each headline, we are given its date and the ticker(s) corresponding to the headline, see the example below.

To collect these headlines, we use a simple GET request against the desired URL. Using the requests package, this looks as follows:

import requests
page = requests.get("https://marketwatch.com/investing/technology")

And to parse this data, we use BeautifulSoup, which is a Python package that can extract data from HTML documents.

import pandas as pd
from bs4 import BeautifulSoup

soup = BeautifulSoup(page.content, "html.parser")
article_contents = soup.find_all("div", class_="article__content")

for article in article_contents:
    headline = article.find("a", class_="link").text.strip()
    ticker = article.find("span", class_="ticker__symbol")
    headline_ticker = [headline, ticker]
    headlines.append(headline_ticker)

columns = ["headline", "US_ticker"]
headlines_df = pd.DataFrame(headlines, columns=columns)

Keep in mind, this code won’t work for just any website, see this article for help with web scraping. You’ll notice that we access the article content in something called “div” and “article__content”. You’ll need to adjust this on a website-by-website basis, and this requires some inspection of the page you are on. In Chrome, you can do this by right-clicking on any website and selecting ‘Inspect’ (if you use another browser, use these steps instead). You’ll be met with a jumble of HTML. The easiest way to figure out where the headlines are ‘hiding’, is to Ctrl-F (or Command-F on iOS) a particular headline. You can also click the ‘Select an element in the page to inspect it’ button on the top-left of the Developer console to pinpoint where to find your desired data.

Once you’ve found the tags corresponding to the right element(s), you can paste the names into the code snippet above to retrieve its contents. We suggest frequently printing your output to determine whether you are collecting the desired information and whether it needs to be pre-processed. For example, in line 8, we remove the whitespace surrounding the headline to clean up our data. When you’re happy with your output, you can collect all relevant information in a Pandas DataFrame.

Pre-processing your data 👩‍🏭

At this stage, it’s likely your data needs some (additional) pre-processing before it’s ready for sentiment analysis and trading.

In the GitHub repository, you’ll notice that we removed any headlines without tickers and headlines with tickers that we know are not tradable on lemon.markets (to make the dataset smaller). Additionally, to trade on lemon.markets, we need to obtain the instrument’s ISIN. Because we trade on a German exchange, querying for a US ticker will not (always) result in the correct instrument. Therefore, to ensure that there are no compatibility issues, we suggest mapping a ticker to its ISIN before trading. We’ve published an article that’ll help you do just that.

Performing the sentiment analysis 😃😢

Once we’ve collected our headlines and tickers (or ISINs), we need to be able to decide whether the headlines report positive or negative news. This is where our sentiment analysis tool, VADER, comes in. It’s a model for lexical scoring based on polarity (positive/negative) and intensity of emotion. The compound score indicates whether a text is positive (>0), neutral (0), or negative (<0). In the above headlines, it can determine that ‘“Squid Game” is worth nearly $900 million to Netflix’ has a somewhat positive sentiment as the word ‘worth’ is likely part of the positive sentiment lexicon. If you’d like to read more about how VADER works, check out this article. There’s also alternatives out there, like TextBlob or Flair. You might want to try out all three to determine which one works best on your dataset.

For our use-case (determining sentiment scores of online newspaper headlines), the implementation is really simple:

from nltk.sentiment.vader import SentimentIntensityAnalyzer

vader = SentimentIntensityAnalyzer()

scores = []

for headline in headlines_df.loc[:,"headline"]:
    score = vader.polarity_scores(headline).get("compound")
    scores.append(score)

headlines_df.loc[:,"score"] = scores

If we have more than one headline (and scores) for a particular ticker, we have to aggregate them into a single score:

headlines_df = headlines_df.groupby("ticker").mean()
headlines_df.reset_index(level=0, inplace=True)

We’ve chosen to combine scores by taking the simple average, but there are several measures that you might opt to use. For example, a time-weighted average to penalise older deadlines as they probably are less representative of current (or future) market movements.

Placing your trades 📈

Once you’ve obtained the compound scores for the tickers, it’s time to place trades. However, you first need to decide on a trading strategy — what kind of score justifies a buy order? What about a sell order? And how much are you trading? There are several components to keep in mind here, such as your total balance, your current portfolio, the ‘trust’ you have in your strategy and others.

Our base project works with a very simple trade rule: buy any instrument with a score above 0.5 and sell any instrument with a score below -0.5 (see if you can come up with something a bit more complex 😉):

buy = []
sell = []

for index, row in headlines_df.iterrows():
    if row['score'] > 0.5 and row['isin'] != 'No ISIN found':
        buy.append(row['isin'])
    if row['score'] < -0.5 and row['isin'] != 'No ISIN found':
        sell.append(row['isin'])

We can then feed this list of ISINs to the lemon.markets API (if you’re not signed up yet, do that here) to place and activate our trades:

orders = []

# place buy orders
for isin in buy:
    side = 'buy'
    order = requests.post(
        f"https://paper-trading.lemon.markets/v1/orders/",
        data={"isin": isin,
              "expires_at": "p0d",
              "side": side,
              "quantity": 1,
              "venue": "XMUN", 
              "space_id": YOUR-SPACE-ID},
        headers={"Authorization": f"Bearer {<YOUR-API-KEY>}"}).json()
    orders.append(order)

# place sell orders
for isin in sell:
    side = 'sell'
    order = requests.post(
        f"https://paper-trading.lemon.markets/v1/orders/",
        data={"isin": isin,
              "expires_at": "p0d",
              "side": side,
              "quantity": 1,
              "venue": "XMUN", 
              "space_id": YOUR-SPACE-ID},
        headers={"Authorization": f"Bearer {<YOUR-API-KEY>}"}).json()
    orders.append(order)

# activate orders
for order in orders:
    order_id = order['results'].get('id')

    requests.post(
        f"https://paper-trading.lemon.markets/v1/orders/{order_id}/activate/", 
        headers={"Authorization": f"Bearer {<YOUR-API-KEY>}"})
    print(f'Activated {order["results"].get("isin")}')

For demonstration purposes, our trades are all of size 1, but depending on your capital, you might want to increase this parameter (or even make it dynamic depending on the sentiment score). Besides this, there are lots of other ways you can make this project even more extensive!

Further extensions 🤓

This project is only a start to your own sentiment trading strategy. You can make your trade decisions more robust by collecting news from several sources. Or you can conduct more extensive sentiment analysis by, for example, applying VADER on the whole article rather than just the headline (#clickbait 🎣). Perhaps you want to use a different sentiment analysis tool, like TextBlob. Or maybe you even want to create your own sentiment score library based on investment-specific jargon.

We suggest you begin by collecting data from a news source you trust and tweaking the trading decision rule. Let your imagination go wild!

You’re now set up to use BeautifulSoup, VADER and lemon.markets in your sentiment analysis project. See our GitHub repository for the entire script. And, if you come up with an interesting extension, feel free to make a PR! We look forward to seeing your ideas.

Joanne from lemon.markets 🍋

10 useful Python libraries & packages for automated trading

Joanne — Mon, 22 Nov 2021 13:07:36 +0000

Hey! I’m Joanne, an intern at lemon.markets, and I’m here to share some invaluable Python libraries & packages to use when you’re working with financial data and automated trading. At lemon.markets, we provide the infrastructure for developers to build their own brokerage experience at the stock market. Whatever your product might look like, there’s usually one or more Python libraries that can do the legwork for you. So, instead of re-inventing the wheel, let’s have a look at which packages can facilitate your automated trading.

The focus here is on Python, but many of the featured libraries have either wrappers that allow them to be used in other languages, or have comparable alternatives. If you have additional suggestions, feel free to leave a comment below. 💭

I’ve split the trading process into three general steps: manipulating (raw) data, performing technical analysis and finally assessing your portfolio. There’s probably 100+ steps that can be inserted into this process, but as a starting point, we think this is a solid place to begin. It covers the ‘before’, the ‘during’ and the ‘after’ when it comes to implementing your strategy. If you’re struggling to find more steps, perhaps consider: data collection, data visualisation, paper trading, backtesting, machine learning, portfolio management…must I go on?

Data Manipulation

We make the assumption here that you’re collecting data before writing your trading strategy. Live market data, historical data, trading sentiment: it all falls within this category. And before you can perform any kind of manipulation, you need data to do it on. Naturally, the lemon.markets market data API can be used to retrieve historical market data. We’ll also be providing real-time market data in the near future (stay tuned!). But you’re not restricted to only market data, you can also, for example, scrape headlines from financial news sites to perform sentiment analysis. Regardless of where you obtain your data, you’ll notice that often your source won’t present the data in exactly the format you need: cue data manipulation tools.

🐼 Pandas



import pandas as pd

No list of Python libraries for financial analysis (or really any kind of data-driven work) would be complete without the mention of Pandas. It’s a powerful data manipulation tool that works with data structures called Series (one-dimensional) and DataFrames (two-dimensional). It can be used to intelligently index data, merge and join different data sets and even perform computations. The documentation includes a 10-minute guide to Pandas and DataCamp has a tutorial on using Python for Finance.

🔢 NumPy



import numpy as np

NumPy, or the Numerical Python library, is the package when it comes to scientific computing in Python. Specifically, NumPy provides functions for linear algebra, Fourier transforms and random number generation. It’s widely used because it utilises vectorisation, which means it can turn a computation which might take 1000 cycles into one that takes 250 cycles. As developers, we’re always looking to reduce computational power where ever possible.

👩‍🔬 SciPy



import scipy as sp

SciPy is the scientific library that builds on NumPy — it includes modules for statistics, optimisation, integration, linear algebra and more. Similar to NumPy, but with more functionality (which comes at a price: slower computation speed). Check out the documentation to see if it meets your requirements!

📊 Matplotlib



import matplotlib.pyplot as plt

The Matplotlib library can be used to create static, animated and interactive visualisations in Python. There are a million reasons why you might like to visualise data in financial analysis. For example, you might want to measure the performance of a single stock (or basket of stocks) against an index like the S&P500. Or, you might want to construct a simple histogram of daily stock returns to determine (visually) whether they follow a normal distribution. Of course, this would need to be backed up by a statistical test, which can be done with the statsmodels library (coming up soon).

You’ll notice that the above four libraries are often used simultaneously in projects, and likely, in your use-case it’ll be the same situation. They integrate seamlessly. Many additional niche packages are built on top of these four packages, for example: PyNance. There’s lots of resources available regarding these libraries: to get started, here’s an introduction to NumPy and Pandas.


 python
import requests
import pandas as pd
import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt


def get_ohlc():
    response = requests.get(
        'https://data.lemon.markets/v1/ohlc/d1/?isin=US0378331005 \
               &from=2021-06-25T00:00:00&to=2021-11-14T00:00:00',
        headers={"Authorization": "Bearer YOUR-API-KEY"})

    results = response.json()['results']
    return results


def calculate_returns():
    df = pd.DataFrame(get_ohlc())
    # calculate returns based on closing price
    df['r'] = df['c'].pct_change().fillna(method='bfill')
    df.tail()
    return df


def plot_returns():
    returns = calculate_returns()['r']

    # plot returns
    plt.hist(returns, bins=25, density=True, alpha=0.6, color='darkorange')

    # plot normal distribution fitted to returns
    mu, std = norm.fit(returns)
    xmin, xmax = plt.xlim()
    x = np.linspace(xmin, xmax, 100)
    p = norm.pdf(x, mu, std)
    plt.plot(x, p, 'k', linewidth=2)
    plt.xlabel('Daily Tesla Returns')
    plt.ylabel('Probability Density Function')

    plt.show()


plot_returns()

This script will return the following histogram:

Obviously, we do not have enough data points to conclude whether Tesla daily returns follow a normal distribution. We hope that this little example shows you what can be done with these data manipulation packages and our OHLC endpoint.

Technical Analysis

Your strategy may or may not employ technical analysis. If you’re somehow using historical price data to predict future price movement, then this falls under technical analysis. If you’re not, don’t worry, it’s not necessary in order to implement an automated trading strategy (but might be helpful nonetheless, so feel free to dive in).

📈 TA-Lib



import talib as ta

TA-Lib, or Technical Analysis Library, can be used to perform technical analysis on financial data by calculating well-known technical indicators, such the Weighted Moving Average (WMA) or Relative Strength Index (RSI). It can also recognise candlestick patterns, such as the inverted hammer or homing pigeon, to name a few. These indicators might serve as buy or sell signals for your trading strategy.

📉 Statsmodels



import statsmodels.api as sm

Python already includes a built-in statistics module, but the statsmodels package can be used for more in-depth statistical analysis. Say you want to construct an ARIMA model for historical price data in order to predict price movement in the future, then this library would be the tool to use. Or, your use-case might be more simple, such as conducting a Jarque-Bera test for normality of residuals after a regression.

🙋 PyStan



import stan

Bayesian inference is used in financial modelling to assess return predictability and strategy risk (among other things). PyStan is the Python-adapted package to perform Bayesian inference. Note that you need to use a domain specific language based on C++ (called Stan), which makes this package a bit more difficult to use. However, it is very powerful in that it allows you to perform high-level statistical modelling, analysis and prediction.

➗ f.fn()



import ffn

ffn is a library that extends Pandas, NumPy and SciPy and contains functions often used within the quantitative finance framework. For example, you can use it to calculate the risk parity weights given a DataFrame (🐼) of returns. If you’re not familiar with risk parity, it’s an investment management technique that determines how to allocate risk within a portfolio. (Have we mentioned that reading the documentation of financial-related libraries is a great way to get familiarised with new metrics?)

The above four libraries can be used to determine when, what and how much to buy or sell. Once these decisions are made, the lemon.markets trading API can be used to place your orders on the stock market. An order can be placed as follows:


 python
import requests
import json

def place_order(isin: str, side: str, quantity: int):
    if trading_signal:
        request = requests.post("https://paper-trading.lemon.markets/v1/orders/",
                                data=json.dumps({
                                    "isin": isin,
                                    "expires_at": "p7d",
                                    "side": side,
                                    "quantity": quantity,
                                    "space_id": YOUR-SPACE-ID,
                                    "venue": "XMUN"}),
                                headers={"Authorization": "BEARER YOUR-API-KEY"})
        print("Your trade was placed")
    else:
        print("Your trade was not placed")

place_order("US0378331005", "buy", 1)

The boolean trading_signal indicates whether the trade should be placed or not (this is where the aforementioned libraries come in handy). However, in this script we have not defined it yet.

Portfolio Assessment

Once your strategy is finished and implemented, it’s important to measure its performance, not only by returns, but also by calculating e.g. the risk associated with it. Portfolio analysis is not a one-and-done event: a good investor assesses their portfolio (or automates the process) regularly and implements necessary changes, such as a rebalancing or purchasing additional stocks to diversify appropriately. Note: your lemon.markets portfolio can be accessed via the Portfolio endpoint:


 python
import requests

request = requests.get("https://paper-trading.lemon.markets/v1/portfolio/",
                       headers={"Authorization": "BEARER YOUR-API-KEY"})

print(request.json())

Which would return each instrument in your portfolio in the following fashion:



ISIN : {YOUR-SPACE-ID: {
   'buy_orders_total': '',
   'buy_price_avg': '',
   'buy_price_avg_historical': '',
   'buy_price_max': '',
   'buy_price_min': '',
   'buy_quantity': ''
   'orders_total': '',
   'quantity': '',
   'sell_orders_total': '',
   'sell_price_avg_historical': '',
   'sell_price_max': '',
   'sell_price_min': '',
   'sell_quantity': ''}

✋ Empyrical



import empyrical as em

Empyrical can be used to calculate well-known performance and risk statistics, for example the Sharpe ratio, alpha and beta. These metrics might show how the portfolio performs in relation to the market and indicate whether structural changes should be made. It’s an open-source project initiated by the now-defunct Quantopian, however the GitHub repository remains somewhat active (fingers crossed it stays that way 🙏🏼).

💼 PyFolio



import pyfolio as pf

PyFolio is quite similar to Empyrical in that it can create an image that reflects performance and risk analysis. It does this through a so-called tear sheet, which includes metrics such as the stability, maximum drawdown and kurtosis of your portfolio’s returns.

These ten Python libraries and packages should provide a good starting point for your automated trading journey. Integration with the lemon.markets API is possible at every step: market data can be retrieved for data manipulation, orders can be placed according to technical indicators and the portfolio can be accessed to do risk and performance assessments. We strive to make the API as transparent as possible, to give you, the developer, full control over your brokerage experience.

If you’re not already signed-up to lemon.markets, join our waitlist here, we’d love to have you! Connect with us by leaving behind a comment, sending us an email and joining our vibrant Slack community. You’re bound to pick up some additional tools and inspiration along the way.

See you soon,

Joanne 🍋