Build a Telegram Bot for Medusa E-Commerce Store

Hey ya, e-commerce enthusiasts! Are you ready to take your Medusa store to the next level? Well, buckle up because we're about to show you how to build a Telegram bot that will blow your customers' minds! But before we dive into the exciting stuff, let's catch up. I've been on vacation for a while, so sorry for my absence in the writing world. But now, I'm back and ready to share some amazing projects with you.

In this article, we'll go through the process of building a Telegram bot that allows users to purchase products from your Medusa-powered e-commerce store. We'll be using Python and Flask for the backend and the python-telegram-bot library to interact with the Telegram API.

Step 1: Setting up a Telegram bot

To get started, you'll need to create a Telegram bot. You can do this by talking to the BotFather on Telegram and following the instructions provided. Once you've set up your bot, make a note of the API key that you're given.

Step 2: Building the backend

The backend of the bot will handle all the interactions between the bot and your Medusa store. We'll be using Python and Flask for the backend. You'll need to make sure that the backend can handle requests from Telegram and make calls to the Medusa API to retrieve product information and process orders.

First, let's start by creating a new Flask project and installing the required libraries:

# create a new Flask project
$ mkdir medusa-telegram-bot && cd medusa-telegram-bot
$ python3 -m venv venv
$ source venv/bin/activate
(venv) $ pip install flask python-telegram-bot

Next, let's create a new file called app.py and set up a basic Flask application:

from flask import Flask, request
from telegram import Bot
app = Flask(__name__)

@app.route('/', methods=['POST'])
def handle_update():
    # handle the incoming update from Telegram
    pass

if __name__ == '__main__':
    app.run(debug=True)

Now we need to initialize the bot:

bot = Bot(token='YOUR_TELEGRAM_BOT_TOKEN')

Step 3: Connecting the backend to Telegram

Once the backend is set up, we'll need to connect it to Telegram. This is done by configuring a webhook that points to the URL of the backend. Once this is done, Telegram will send all incoming messages to the backend for processing.

To set up a webhook, we can use the setWebhook method provided by the python-telegram-bot library:

bot.setWebhook(url='https://your-server-url.com/' + bot.token)

Step 4: Connecting Medusa to the Telegram bot

In this step, we'll integrate Medusa into our Telegram bot by using the Medusa Python library. This library provides a simple interface for interacting with the Medusa API and allows us to easily fetch and update products, orders, and other data from our storefront.

Here's an example of how we can use the Medusa library to fetch a list of products from our storefront and send them to the user through Telegram:

from medusa import Medusa

medusa = Medusa(api_key='YOUR_MEDUSA_API_KEY')

@app.route('/handle_message', methods=['POST'])
def handle_message():
    # Get the incoming message from Telegram
    message = request.get_json()
    text = message['message']['text']

    # Determine the user's intent
    if '/products' in text:
        products = medusa.products.list()
        product_list = ''
        for product in products:
            product_list += product['title'] + '\n'
        reply_text = 'Here are a list of products in our store: \n' + product_list
    else:
        reply_text = 'I am sorry, I do not understand what you want me to do.'

    # Send the reply
    reply_to_message(reply_text, message['chat']['id'])

    return 'ok'

In this example, the function checks if the message contains '/products' and then fetch products from Medusa, and sends a list of products to the user through Telegram. You can customize this to fit your needs and you can also add other functionalities like creating a new order, or updating an existing order. Please note that this is just an example and may require further modification to work in your specific use case.

Step 5: Creating the Medusa Module for Telegram Bot Integration

Create a new file called medusa.py in your project directory. In this file, you can define the Medusa class and any other necessary functions or classes:

import requests

class Medusa:
    def __init__(self, base_url, api_key):
        self.base_url = base_url
        self.api_key = api_key

    def create_product(self, product_data):
        headers = {'Authorization': 'Bearer {}'.format(self.api_key)}
        response = requests.post(self.base_url + '/products', json=product_data, headers=headers)
        return response.json()

    def update_product(self, product_id, updates):
        headers = {'Authorization': 'Bearer {}'.format(self.api_key)}
        response = requests.patch(self.base_url + '/products/{}'.format(product_id), json=updates, headers=headers)
        return response.json()

    def get_products(self):
        headers = {'Authorization': 'Bearer {}'.format(self.api_key)}
        response = requests.get(self.base_url + '/products', headers=headers)
        return response.json()

This is an example of how you can define the Medusa class in medusa.py. The class has three methods: create_product, update_product, and get_products. Each method makes a request to the Medusa API using the requests library, passing in the necessary data and headers.

You will need to replace the base_url and api_key with the actual values for your Medusa instance. Additionally, you may need to modify the methods to match the specific API endpoint and request format for the Medusa API.

Once the medusa module is defined and imported in the telegram bot script, you can call the class methods to interact with the Medusa instance.

Please note that this is just an example and you should check the Medusa API documentation for the correct endpoints and request format.

Step 6: Running the Telegram Bot with Medusa Integration

Now that the Telegram bot and Medusa module have been set up, it's time to run the bot and test the integration.

Open a terminal or command prompt and navigate to the root directory of your bot project.
Start the bot by running the command python3 bot.py (assuming your main bot file is named bot.py).
Open Telegram and search for your bot's username.
Send a message to the bot and see if the Medusa integration is working as expected.
Stop the bot, simply close the terminal/command prompt or use the CTRL+C command.

Note: Make sure that all the required packages installed and the token is correct.

You can now continue to add more functionality and features to your Telegram bot and Medusa integration, and use it in your e-commerce website.

Congratulations 🎉, you have successfully created a Telegram bot that integrates with Medusa, an open-source alternative to Shopify. With this bot, you can now easily manage your e-commerce store and communicate with your customers through Telegram.

It's always a good idea to keep testing and improving your bot, and you can also add new features and functionality as per your requirement. With Medusa and Telegram, the possibilities are endless.

Don't forget to take a break, I went on vacation and that's why I discontinued writing articles. But now I'm back and ready to share more exciting projects and ideas with you. Thanks for reading!

Omar Moustafa