Skip to main content

Get Blockchain Data on Telegram Chat in Real-Time

With this code, your Telegram bot will respond to the /start command by initiating a WebSocket connection to Bitquery and sending blockchain data updates to the Telegram chat. This is how it will look chat

You can find the complete code here

Step-by-Step Tutorial

  1. Install the required Python libraries:
pip install asyncio json websockets tracemalloc telegram-bot-api

Step 2: Define Your Token and Keys You need to provide your Telegram bot token from the BotFather. For this step you need to create a new Telegram bot. Check official tutorial here


Replace 'tokenn' with your actual bot token.


You also need to get your API key from Bitquery, you can get it for free by creating an account here

Step 3: Define a Function to Send Messages A function named send_message is defined. It takes an update object and a message string as arguments and sends the message to the Telegram chat.

def send_message(update: Update, message: str):

Step 4: Define Functions for Handling Long Messages Since the response received from the Bitquery API is much longer than allowed limits( 4000 characters), we will write a function that splits the text and sends it to the chat.

def split_text(text, max_length):
return [text[i:i + max_length] for i in range(0, len(text), max_length)]

def send_long_message(update: Update, long_message, max_message_length=4000):
message_parts = split_text(long_message, max_message_length)
for part in message_parts:
send_message(update, part)

Two functions, split_text and send_long_message, are defined to handle long messages. split_text breaks a long message into smaller parts, and send_long_message sends a long message as multiple smaller messages to avoid Telegram's message length limits.

Step 5: Define WebSocket Code

The my_component function is an asynchronous function that handles the WebSocket connection to Bitquery. You can read more about how to use it here The below code sends a GraphQL subscription query that listens to server for latest transfers on the Ethereum chain, i.e. it subscribes to the EVM.Transfers event. Put your API key from Bitquery in

"X-API-KEY": "keyy"

async def my_component(update):
url = 'wss://'
message = json.dumps({
"type": "start",
"id": "1",
"payload": {
"query": "subscription {\n EVM {\n Transfers {\n Transfer {\n Amount\n __typename\n Currency {\n __typename\n Symbol\n }\n }\n }\n }\n}",
"variables": {}
"headers": {
Authorization: "Bearer your_access_token_here",

async def connect(update):
async with websockets.connect(url, subprotocols=['graphql-ws']) as ws:
await ws.send(message)

while True:
response = await ws.recv()
response = json.loads(response)

if response.get('type') == 'data':
response_text = f"{response['payload']['data']['EVM']['Transfers']}"
send_long_message(update, response_text)

await connect(update)

  1. It waits for new events.
  2. When it receives a new event, it sends the event data to the Telegram bot.

Step 6: Start WebSocket and Send Updates to Telegram The start_websocket_and_send_updates function initiates the WebSocket connection defined in my_component. It also handles exceptions if the connection encounters any issues.

async def start_websocket_and_send_updates(update):
await my_component(update)
except Exception as e:

Step 7: Command Handler to Start WebSocket Connection The start function is a command handler that responds to the /start command on Telegram. It sends a message indicating that it's starting the WebSocket connection and then calls start_websocket_and_send_updates to begin the WebSocket connection.

def start(update: Update, context: CallbackContext):
update.message.reply_text("Starting WebSocket connection...")

Step 8: Create and Configure the Telegram Bot In the main function, the Telegram bot is created and configured. It registers the /start command handler. It then starts the bot and waits for updates.

def main():
updater = Updater(BOT_TOKEN, use_context=True)
dp = updater.dispatcher

dp.add_handler(CommandHandler("start", start))


**Step 9: Run the Bot** The script checks if it's the main module and starts the bot.

if __name__ == "__main__":