Build, Deploy & Manage Stocks & Options Strategies with a Single API

If you're a Python developer building trading tools, dashboards, or execution engines, chances are, you've hit the same roadblocks over and over:

• Managing different broker APIs

• Handling SL, target, and trailing SL logic

• Managing the strategy execution lifecycle: entry and exit

• Building simulations for forward testing (paper trading)

• Managing multi-legoptions strategies

What if you could skip all of that?

No broker integration headaches. No complex order management code. Just plug into one trading API and you're ready to build.

Welcome to AlgoTest's Signals API, built for developers who want to automate trading using Python.

The Problem: Broker APIs Are a Pain

If you’ve ever worked with broker APIs like Zerodha, Groww, Dhan, or Upstox, you know the story:

• Every broker has their own authentication model

• Order types and execution rules vary wildly

• SL/Target logic? You’ll have to code it from scratch

• Trailing SLs? You’re on your own

• Want to switch brokers? Rewrite everything again

That’s where AlgoTest comes in.

The Solution: One Payload to Rule Them All

With AlgoTest, you can define your entire strategy, including SL, Target, Trailing SL, Entry/Exit Buffers, and Product Types, in one clean JSON payload.

We take care of the rest:

• Connect with any supported broker (Zerodha, Dhan, Upstox, etc.)

• Handle order placement, modification, exits

• Manage risk logic like MTM-based stop loss

• Allow forward testing with virtual capital

• Monitor and retry orders on your behalf

Ready to Get Started?

We've created detailed Signals API Documentation to help you understand the API, configure your strategy, and get started with API-based execution.

You can explore the API endpoints, request parameters, strategy configuration, and execution workflow directly from the documentation.

The API supports strategy configurations for indices, individual NSE stocks, and supported crypto instruments. It also supports options, futures, and cash/equity legs, subject to instrument and exchange-specific restrictions.

AlgoTest handles the execution layer for supported brokers, so you can focus on building your strategy.

Automate Options Strategies Through an API

Options strategies often involve multiple legs, different strikes, position types, and risk-management rules.

For example, you can configure a NIFTY strategy with a short 23850 CE and 23350 PE and add an overall MTM stop loss.

You can define the legs in your API payload:

"Legs": [
  {
    "PositionConfig": {
      "InstrumentKind": "LegType.CE",
      "StrikeParameter": 23850,
      "PositionType": "PositionType.Sell",
      ...
    },
    "ExecutionConfig": {
      "EntryOrder": {
        "Type": "OrderType.Limit",
        "Value": {
          "Buffer": { "LimitBuffer": 3 }
        }
      }
    }
  },
  ...
]

Add an overall MTM stop loss:

"OverallSL": {
  "Type": "OverallTgtSLType.MTM",
  "Value": 3000
}

And you're done.

Forward Test Before You Go Live

Not ready to deploy with real capital?

You can use the paper trading endpoint for forward testing before moving to live execution.

The Signals API provides separate endpoints for live and paper execution, allowing you to test your strategy before deploying it with real capital.

This can be useful for:

• Strategy validation

• Testing entry and exit logic

• Monitoring virtual P&L

• Testing your API integration before live execution

No Need to Integrate Every Broker

Want to trade live?

Connect your supported broker account and use the live Signals API endpoint to start the strategy.

For live execution, the API requires abroker_id, which can be obtained from the Broker Setup page. The paper endpoint does not require the broker ID.

Your strategy configuration remains in the API payload while AlgoTest handles the execution layer for the supported broker.

Manage SL, Target and Trailing SL

You can configure risk-management rules at both the strategy and individual-leg level.

The API supports:

• Overall MTM stop loss

• Overall MTM target

• Premium percentage-based overall SL/target

• Per-leg stop loss

• Per-leg target

• Underlying-based SL/target

• Trailing stop loss in points or percentage
  This allows you to define your strategy's risk-management rules along with its entry and execution configuration.

Built for Python Developers

You’re already writing strategy logic in Python, so we’ve made our APIs extremely simple to call from any Python script or backend.

Here’s a basic structure using requests:

import requests
payload = {
  "access_token": "<your-token>",
  "alert_name": "strategy_1",
  "exit_time": "2025-11-29T15:15:00",
  "strategy": {
    ...
  }
}
res = requests.post("https://algotest.in/api/webhook/custom-strategy/execution/start/<signal_id>", json=payload)
print(res.json())

Whether you’re building an options dashboard, a trading strategy, or an execution engine, AlgoTest lets you:

• Deploy your entire strategy with one API

• Trade with any brokervia a unified interface

• Forward test with virtual capital

• Skip the execution headache

Ready to Automate Your Strategy?

Get started with AlgoTest Signals API:

1. Review the Signals API Documentation.

2. Start Free with AlgoTest.

3. Configure your strategy and get your API access token.

4. Test your strategy using the paper/forward-testing endpoint.

5. Connect your supported broker and trigger your strategy through the API for live execution.

Explore the Signals API Documentation to start building your automated trading workflow.

Want help setting up your flow? Drop us a message — we love chatting with developers.

If you want to execute TradingView alerts with AlgoTest Signals, read How to Use AlgoTest Signals to Execute Your First TradingView Alert.

Additional Resources

📚 Product Documentation

Trading Tools

• Margin Calculator

• IVR & IVP

• VRP Analysis

• OpenBroker