The ability to place orders concurrently is important for active traders, especially those handling large funds, as it allows executing multiple trade orders at the same time and helps in managing risk better. In Python, this can be done using the ThreadPoolExecutor from the concurrent.futures module, as demonstrated in the provided sample code.
This approach lets traders send multiple orders in parallel, which reduces the time it takes to execute trades. Below is a brief tutorial on how to place concurrent orders in Python using the ThreadPoolExecutor.
What is ThreadPoolExecuteor?
ThreadPoolExecutor, part of the Python standard library, is a high-level interface for asynchronously executing callables, provided by the concurrent.futures module in Python. It abstracts the management of a pool of threads, enabling you to run tasks concurrently, thereby improving the performance of I/O-bound and high-latency activities. This executor is useful where executing operations in parallel can reduce the overall execution time, such as making multiple network requests, performing I/O operations, or handling computational tasks that can be distributed across multiple threads.
import requests
import time
from concurrent.futures import ThreadPoolExecutor
# Define the URL and the JSON payload
url = 'http://127.0.0.1:5000/api/v1/placeorder'
data = {
"apikey": "<apikey>",
"strategy": "Test Strategy",
"symbol": "NIFTY29FEB2422100CE",
"action": "BUY",
"exchange": "NFO",
"pricetype": "MARKET",
"product": "NRML",
"quantity": "1000"
}
# Function to send a POST request
def send_order(data):
start_time = time.time()
response = requests.post(url, json=data)
end_time = time.time()
response_time_ms = (end_time - start_time) * 1000
return f"API Order Response Time: {response_time_ms:.2f} milli seconds"
# Start measuring total time
total_start_time = time.time()
# Use ThreadPoolExecutor to send requests in parallel
with ThreadPoolExecutor(max_workers=5) as executor:
# Create a list to hold references to the future objects returned by submit
futures = [executor.submit(send_order, data) for _ in range(10)]
# Iterate through the future objects to get the results
for count, future in enumerate(futures):
response_time = future.result()
print(f"Order No {count} {response_time}")
# Stop measuring total time
total_end_time = time.time()
total_time_ms = (total_end_time - total_start_time) * 1000
print(f"Total time taken to place all 10 orders: {total_time_ms:.2f} milli seconds")
Output

Understand the Setup
First, let us understand the setup. The provided sample code uses the requests library to send HTTP POST requests to a trading API and the concurrent.futures module to achieve concurrency. The target API endpoint is a mock URL (http://127.0.0.1:5000/api/v1/placeorder), and the data payload includes details such as the API key, trading strategy, symbol, action, exchange, price type, product, and quantity.
Define the Order Sending Function
The send_order function takes a data dictionary as input, representing the order details. It sends a POST request to the API endpoint and measures the response time, returning a string that includes the API order response time in milliseconds. This function holds the logic needed to send an individual order to the trading platform.
Implement Concurrency with ThreadPoolExecutor
The sample code uses the ThreadPoolExecutor from the concurrent.futures module to send orders concurrently. The ThreadPoolExecutor is initialized with a max_workers parameter, which specifies the number of threads to use for sending orders. In the example, max_workers=5 means that five orders can be sent in parallel.
Place Orders Concurrently
Within the ThreadPoolExecutor context manager, futures are created for sending orders concurrently. A future represents an asynchronous execution that can be queried for status or result without blocking the calling thread. By calling executor.submit(send_order, data) for each order, the code schedules the send_order function to be executed concurrently for each order. The submit method returns a future object, which is stored in a list (futures).
After submitting the orders, the code iterates over the futures list, calling future.result() on each. This call blocks until the order’s response is received, allowing the collection of response times for each order.
Measure Overall Execution Time
The total execution time for placing all orders is measured by recording the start and end times before and after the concurrent execution block. This demonstrates the efficiency gained by using concurrent orders instead of sending them sequentially.
By using ThreadPoolExecutor for concurrent order placement, active traders can reduce the time taken to execute multiple orders. This is useful when dealing with large funds, where the speed of order execution can affect the strategy’s results. The sample code shows a simple way to implement concurrent orders.
Learn by watching: free videos every week
Market Profile, order flow, Python, AI and OpenAlgo tutorials on YouTube.

