Build an algorithmic trading app with Python, Django, SnapTrade and Massive

You can follow the SnapTrade portion of this course on Build, SnapTrade’s free Commercial plan for development and testing.

As of September 24, 2026, Build is $0 and includes up to 5 brokerage connections, real-time data, trading included where supported, and Discord community support. You do not need to pay for Launch just to complete this tutorial.

Build is intended for development and testing before production. If you turn the tutorial into a real product, review the current Launch or Custom requirements before going live.

• →Start building
• →Current SnapTrade pricing

Know the four SnapTrade credentials and identifiers

clientId

identifies your SnapTrade API key.

consumerKey

secret used by your server to authenticate API requests. Keep it on a secure backend.

userId

a stable, immutable identifier your application chooses for a Commercial SnapTrade user. Avoid using an email address because emails can change.

userSecret

secret returned when that SnapTrade user is registered. Store it securely and never expose it in browser-side code.

If the opening account setup video says 'consumer ID' at one point, the credential is called consumerKey.

The finished project is a Django application that turns market data into a simple momentum ranking, connects a paper brokerage account, and lets you submit a paper order from the app.

1. 1

   1. Retrieve market data

   The application uses Massive to retrieve historical U.S. stock prices. You’ll build logic for historical price requests, bulk market data, caching, API limits, retries, and dates when the market was closed.

2. 2

   2. Calculate momentum

   The app calculates a 12-minus-1 momentum score for a stock universe, ranks the stocks, and stores the results so they can be displayed in the dashboard and used to generate example trading signals.

3. 3

   3. Connect a brokerage account

   SnapTrade connects the Django application to an Alpaca Paper account. Once connected, the application can work with brokerage accounts, cash balances, positions, and orders through one brokerage API layer.

4. 4

   4. Generate trading signals

   The strategy layer uses the momentum rankings to generate example signals. The course implementation focuses on buy signals for the highest-ranked stocks and uses a simple equal-dollar allocation so the emphasis stays on the software architecture.

5. 5

   5. Submit and verify a paper trade

   The application submits an order through SnapTrade to the connected Alpaca Paper account. You’ll then open Alpaca and verify that the paper order was received.

Create a SnapTrade Commercial Build account

1. 1Go to the SnapTrade Dashboard.
2. 2Choose Commercial.
3. 3Create your account and verify your email.
4. 4Enable two-factor authentication.
5. 5Open API Keys and generate a test API key.
6. 6Save your clientId and consumerKey securely.
7. 7Keep the consumerKey on your backend. Do not commit it to GitHub or expose it in client-side code.

• →Start building
• →Pricing and Build plan details

Create a Massive account

Create a Massive account and generate an API key. You’ll use this later when you build the market-data client.

• →Massive
• →Massive docs

Create an Alpaca Paper account

Create an Alpaca account and use the Paper Trading environment for the tutorial. The paper account simulates trading and is separate from live trading.

Use accurate information when creating your account and follow Alpaca’s current eligibility rules for your location. If an account type is not available where you live, do not enter false residency information just to follow the tutorial.

• →Alpaca paper trading
• →Alpaca Trading API docs

Set up your local development tools

• Python
• Git
• GitHub
• A code editor
• An authenticator app for two-factor authentication
• uv for the Python virtual environment and dependency workflow used in the course

Massive supplies the market data. Your Python code turns that market data into momentum scores. Django stores the data and exposes it through a web interface. SnapTrade connects the app to the brokerage account. Alpaca Paper receives the simulated brokerage orders.

Architecture

That separation is important. SnapTrade does not decide which stocks to buy. Massive does not connect the brokerage account. Your strategy code sits in the middle and makes the application-specific decisions.

The project uses a 12-minus-1 momentum calculation. In simple terms, it measures how much a stock moved over a longer historical period while excluding roughly the most recent month.

A simplified expression is:

Momentum = (price about 1 month ago / price about 12 months ago) - 1

The application calculates this across its stock universe, ranks the stocks, and stores the results. The tutorial uses momentum because it creates a realistic reason to combine historical market data, calculations, rankings, portfolio data, trading signals, and brokerage APIs.

The strategy is an educational example. It is not a recommendation to buy, sell, short, or hold any security, and historical momentum does not guarantee future performance.

The course starts from an empty repository. You’ll build the project in small pieces and see the mistakes, debugging, and fixes that happen during normal development.

Create the environment and install Django

You’ll create an isolated Python environment, install the project requirements, bootstrap Django, run the local development server, and apply the initial database migrations.

Useful commands from this stage include:

uv venv
uv pip install -r requirements.txt
python manage.py migrate
python manage.py runserver

The Django project is divided into two main apps so market/strategy logic and brokerage portfolio data do not become one large codebase.

You’ll register both apps in INSTALLED_APPS so Django knows to load them.

Whenever the models change, Django migrations translate the Python model definitions into database schema changes.

The normal workflow is:

1. 1Change a model.
2. 2Run python manage.py makemigrations.
3. 3Review the generated migration.
4. 4Run python manage.py migrate.
5. 5Check that the application still runs and the database matches the intended schema.

Django’s built-in admin gives you a fast way to inspect the database while you build.

You’ll create a superuser, register the project models, and configure useful list columns, search, filters, ordering, and read-only fields.

Create a local superuser with:

python manage.py createsuperuser

Why this matters: when the front end says there are no positions or signals, the admin is a quick way to determine whether the problem is the UI or whether the records were never written to the database.

The project uses environment variables so secret credentials are not hard-coded into Python files.

Your local environment will eventually contain values similar to:

MASSIVE_API_KEY=
SNAPTRADE_CLIENT_ID=
SNAPTRADE_CONSUMER_KEY=

Keep the real values in a local .env file. Use .env.example to document the required variable names without exposing real credentials. Add .env to .gitignore before pushing the repository.

For a production application, use an appropriate secret-management system rather than treating a local .env file as production secret storage.

The first major external integration is the market data service. Instead of scattering API calls throughout the project, you’ll create a dedicated Massive client.

The service is responsible for:

• Requesting historical prices
• Converting responses into application-friendly data
• Caching repeated requests
• Respecting plan-level request limits
• Retrying recoverable failures
• Handling missing market dates
• Retrieving data for many stocks efficiently

Cache repeated requests

If the application has already requested the same ticker and historical period, it can reuse that result instead of immediately making another external API request. This reduces unnecessary work and helps stay within API limits.

Handle request limits

The course adds logic to keep track of outgoing requests and wait when needed instead of repeatedly sending requests until the provider rejects them.

Use bulk market data

Requesting one stock at a time becomes inefficient when the strategy needs a broad stock universe. Massive’s grouped daily market endpoint can return daily OHLC and volume data for U.S. stocks in one request, which is useful for wide-scale analysis.

• →Massive Stocks API overview

Handle weekends and holidays

A historical date does not always correspond to a trading day. The market-data service includes fallback logic so the application can look around a requested date instead of failing whenever the exact date is a weekend or market holiday.

Once historical prices are available, the momentum service calculates scores for the stock universe.

The service can:

• Retrieve the relevant historical prices
• Calculate the 12-minus-1 momentum value
• Calculate many scores in one run
• Rank the stocks
• Group them
• Identify high- and low-ranked stocks
• Save the results to the database
• Return summary statistics for the dashboard

The calculation periods are configurable, so the project can later be adapted to experiment with other definitions of momentum.

This is where the project moves from market analysis into brokerage connectivity.

The application uses a Commercial SnapTrade API key. For each end user, the app registers a SnapTrade user, securely stores that user’s credentials, generates a Connection Portal URL, and then uses the connected account in later API requests.

Register a SnapTrade user

A Commercial integration creates one SnapTrade user for each end user in the application. Use a stable, immutable userId from your own system and securely store the returned userSecret.

• →Current API reference

Generate the Connection Portal

The app generates a SnapTrade Connection Portal URL and sends the user through the brokerage connection flow. Current Connection Portal URLs expire after a short period, so generate them when the user is ready to connect.

If the account will place trades, use the trading-enabled connection flow where supported rather than creating a read-only connection.

• →Current API reference

Connect Alpaca Paper

For this course, the user chooses Alpaca and authorizes the paper account. Once the connection finishes, SnapTrade makes the connected brokerage accounts available to the application.

Retrieve positions

The application reads positions from the connected brokerage account and maps them into the local Position model.

• →Current positions endpoint

Retrieve balances

The application also retrieves the connected account’s cash balances so portfolio information can be stored and displayed locally.

• →Current balances endpoint

Submit an equity order

When a user chooses to execute a paper trade, the application sends the order through SnapTrade to the brokerage. The project stores its own trade record and the brokerage order identifier so it can track what happened.

• →Current SnapTrade trading guide
• →Current place equity order endpoint

Track order status

Submitting the request is not the end of the order lifecycle. Brokerage orders can be pending, accepted, partially filled, executed, canceled, rejected, or in another brokerage-specific state. The application includes logic for updating its local trade record as the brokerage order changes.

The strategy engine connects the momentum calculations to a portfolio.

It handles concepts such as:

• Whether a rebalance is needed
• Generating trading signals
• Executing selected signals
• Retrieving strategy-related performance information

The course intentionally leaves room for you to add proper backtesting. That is one of the best extensions to build after the tutorial.

The course uses Django templates for the front end so the entire application can stay in one Python/Django project.

You’ll connect:

• URL routes
• Django views
• HTML templates
• Database queries
• Form and button actions

A Django view receives a browser request, prepares the data required by the page, and renders the response into a template.

An empty database cannot produce useful momentum scores, so you’ll create a Django management command that seeds the application with an example stock universe and historical price information.

This part is primarily development setup. In a production system, you would design the data-loading process around your actual market universe, provider limits, data licensing, and refresh requirements.

Once enough historical data is available, you can calculate momentum for the full example universe.

The dashboard then begins showing:

• Highest-ranked momentum stocks
• Lowest-ranked momentum stocks
• Average momentum
• Median momentum
• Connected portfolios
• Rebalance information

The securities and returns shown in the course are historical examples from the time the recording was made. Your results will differ if you run the project with newer market data.

Next, create a portfolio inside the Django application and connect it to Alpaca Paper.

The flow is:

1. 1Create a portfolio in the app.
2. 2Launch the SnapTrade Connection Portal.
3. 3Choose Alpaca.
4. 4Authenticate with your Alpaca Paper account.
5. 5Authorize the connection.
6. 6Return to the Django application.
7. 7Sync the connected account data.

If the connection worked, the application should be able to retrieve the paper account’s brokerage data through SnapTrade.

With momentum scores and a connected portfolio available, the strategy can generate example trading signals.

The course keeps portfolio construction deliberately simple. It creates buy signals for the highest-ranked names and uses an equal dollar amount per selected stock.

A production investment system would need a much more deliberate approach to portfolio construction, risk, trade validation, and user confirmation.

The final workflow connects everything you built.

You select a signal in the Django app, submit the paper order, then open Alpaca Paper and verify that the order was received.

Because the tutorial uses a paper account, the course does not require you to risk real money.

The course code may age as SDKs and APIs evolve. If a method name or initialization pattern in the recording does not match the version you install, use the current SnapTrade documentation as the source of truth.

• →Getting started and Commercial quickstart
• →Commercial vs Personal authentication
• →Register user
• →Generate Connection Portal URL
• →List all account positions
• →List account balances
• →Trading with SnapTrade
• →Place equity order
• →Supported brokerages
• →Commercial pricing

The course is designed to teach application architecture and API integration. A tutorial project is not automatically production-ready trading software.

A real application should also address:

• Application authentication
• User authorization
• Secure secret storage
• Trade confirmation
• Risk controls
• Order idempotency
• Monitoring and alerting
• Retries and failure recovery
• Webhook handling where appropriate
• Brokerage-specific edge cases
• Connection health and reconnection flows
• Data freshness
• Production database design
• Audit logging
• Testing across market conditions
• Applicable legal, compliance, and brokerage requirements

When you are ready to move beyond development and testing, review SnapTrade’s launch guidance and current pricing before creating a production key.

• →Launch guide
• →Pricing

Build the backtester

The strategy engine leaves room for proper backtesting. Build a system that runs the strategy over historical periods, records portfolio states, accounts for realistic assumptions, and produces reproducible results.

Add a better portfolio construction model

Replace the equal-dollar example with a portfolio-sizing approach and explicit risk constraints.

Add risk controls

• Maximum position size
• Portfolio exposure limits
• Cash checks
• Trade confirmation
• Daily loss or trade limits where appropriate
• Additional order validation

Expand the stock universe

The course intentionally uses a limited universe to make development manageable. Expand it and see what needs to change in your market-data workflow, database, calculation performance, and UI.

Add portfolio analytics

• Historical portfolio value
• Returns
• Asset allocation
• Drawdown
• Position performance
• Cash history
• Contributions and withdrawals

Improve order monitoring

• Order history
• Automatic status updates
• Rejected-order handling
• Partial fills
• Cancel and replace flows
• Better brokerage error messages

Improve the front end

The course intentionally keeps the Django UI simple. You could redesign the application with a more polished Django interface or use a separate front end such as React or Next.js.

Connect another brokerage

The architecture can be extended beyond Alpaca. SnapTrade supports multiple brokerage integrations, but data and trading capabilities vary by brokerage.

• →Explore brokerage integrations

Algorithmic trading

Using software and predefined logic to help generate, manage, or execute trading decisions.

Brokerage API

An interface that allows an application to work programmatically with brokerage accounts and brokerage functions.

Connection Portal

SnapTrade’s user-facing flow for connecting a brokerage account and authorizing the connection.

Connected account

A brokerage account made available to an application through a completed brokerage connection.

Market data

Price, volume, reference, and other market information used for research, analytics, or trading logic.

Momentum

A measure of how a security’s price has changed over a period of time.

Paper trading

Simulated trading that lets you test an application or strategy without using real money.

Position

A security or asset currently held in a brokerage account.

Rebalance

Changing a portfolio so it better matches the target produced by a strategy or allocation model.

Trading signal

An output from a strategy indicating a potential action such as buying, selling, or holding.

userId

In a Commercial SnapTrade integration, a stable identifier chosen by your application for one end user.

userSecret

A secret associated with a Commercial SnapTrade user. It is returned when the user is registered and must be stored securely.