Django Polaris Python - Version

Getting Started

If you’re starting without an existing django application, see the polaris-project-template repository for getting started with the boilerplate code. To get a SEP-24 anchor server running quickly, see the tutorial.

For important updates on Polaris’ development and releases please join the email list.

The documentation below outlines the common set up needed for any Polaris deployment, but each SEP implementation has its own configuration and integration requirements. These requirements are described in the documentation for each SEP.

What is Polaris?

Polaris is an extendable django app for Stellar Ecosystem Proposal (SEP) implementations maintained by the Stellar Development Foundation (SDF). Using Polaris, you can run a web server supporting any combination of SEP-1, 6, 10, 12, 24, and 31.

While Polaris implements the majority of the functionality described in each SEP, there are pieces of functionality that can only be implemented by the developer using Polaris. For example, only an anchor can implement the integration with their partner bank.

This is why each SEP implemented by Polaris comes with a programmable interface for developers to inject their own business logic.

Polaris is completely open source and available on github. The SDF also runs a reference server using Polaris that can be tested using our demo wallet.

Installation and Configuration

These instructions assume you have already set up a django project. If you haven’t, take a look at the Django docs. It also assumes you have a database configured from the project’s

First make sure you have cd’ed into your django project’s main directory and then run

pip install django-polaris


Add the following to INSTALLED_APPS in


Add CorsMiddleware to your settings.MIDDLEWARE. It should be listed above other middleware that can return responses such as CommonMiddleware.


Polaris will accept requests from all origins to its endpoints. It does this by adding corsheaders signal that checks the request URI. However this does not change the CORS policy for any other endpoint on the server. You can change this functionality using the settings listed in the corsheaders documentation.

Optionally, you can add Polaris’ logger to your LOGGING configuration. For example:

    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'simple': {
            'format': '{levelname} {message}',
            'style': '{',
    'handlers': {
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'simple'
    'loggers': {
        'myapp': {
            'handlers': ['console'],
            'propogate': True,
            'LEVEL': 'DEBUG'
        'polaris': {
            'handlers': ['console'],
            'propagate': True,
            'LEVEL': 'INFO'

You may want to configure the LEVEL of the Polaris logger differently depending on whether you’re running the service locally or in production. One way to do this by reading a POLARIS_LOG_LEVEL variable, or something similar, from the project’s environment.

Environment Variables

Some environment variables are required for all Polaris deployments, some are required for a specific set of SEPs, and others are optional.

Environment variables can be set within the environment itelf, in a .env file, or specified in your Django settings file.

A .env file must be within the directory specified by Django’s BASE_DIR setting or specified explitly using the POLARIS_ENV_PATH setting.

To set the variables in the project’s settings file, the variable name must be prepended with POLARIS_. Make sure not to put sensitive information in the project’s settings file, such as Stellar secret keys, encryption keys, etc.


A list of Stellar Ecosystem Proposals (SEPs) to run using Polaris. Polaris uses this list to configure various aspects of the deployment, such as the endpoint available and settings required.

Ex. ACTIVE_SEPS=sep-1,sep-10,sep-24


An integer for the number of seconds a one-time-token used to authenticate the client with a SEP-24 interactive flow is valid for. This token (JWT) is distinct from the JWT returned by SEP-10, which should not be included in URLs.

Defaults to 30 seconds.



A boolean value indicating if Polaris is in a local environment. Defaults to False. The value will be read from the environment using environ.Env.bool().



A URL (protocol + hostname) for the Horizon instance Polaris should connect to.

Defaults to


HOST_URL : Required

The URL (protocol + hostname) that this Polaris instance will run on.

Ex. HOST_URL=, HOST_URL=http://localhost:8000


An integer limit for submitting Stellar transactions. Increasing this will increases the probability of the transaction being included in a ledger.

Defaults to the return value Python SDK’s Server().fetch_base_fee() source, which is the most recent ledger’s base fee, usually 100.



A boolean that if true, requires client applications to verify their identity by passing a domain in the challenge transaction request and signing the challenge with the SIGNING_KEY on that domain’s SEP-1 stellar.toml. See the SEP-10 section Verifying Client Application Identity for more information.

Defaults to False.



An integer for the number of seconds to wait before canceling a server-side request to the client_domain parameter specified in the request, if present. This request is made from the API server and therefore an unresponsive client_domain can slow down request processing.

Defaults to 3 seconds.



A list of domains that the server will issue challenge transactions containing client_domain Manage Data operations for. If SEP10_CLIENT_ATTRIBUTION_REQUIRED is True, client applications must pass a client_domain parameter whose value matches one of the elements in this list, otherwise the request will be rejected. If SEP10_CLIENT_ATTRIBUTION_REQUIRED is False, Polaris will return a challenge transaction without the requested client_domain Manage Data operation.



A list of domains that the server will not issue challenge transactions containing client_domain Manage Data operations for. If SEP10_CLIENT_ATTRIBUTION_REQUIRED is True, client applications that pass a client_domain parameter value that matches one of the elements in this list will be rejected. If SEP10_CLIENT_ATTRIBUTION_REQUIRED is False, Polaris will return a challenge transaction without the requested client_domain Manage Data operation.



A list of home domains (no protocol, only hostname) that Polaris should consider valid when verifying SEP-10 challenge transactions sent by clients. The first domain will be used to build SEP-10 challenge transactions if the client request does not contain a home_domain parameter. Polaris will reject client requests that contain a home_domain value not included in this list. The value will be read from the environment using environ.Env.list().

Defaults to a list containing the hostname of HOST_URL defined above if not specified.


SERVER_JWT_KEY : Required for SEP-10

A secret string used to sign the encoded SEP-10 JWT contents. This should not be checked into version control.

Ex. SERVER_JWT_KEY=supersecretstellarjwtsecret

SIGNING_SEED : Required for SEP-10

A Stellar secret key used to sign challenge transactions before returning them to clients. This should not be checked into version control.



The string identifying the Stellar network to use.

Defaults to Test SDF Network ; September 2015.

Ex. STELLAR_NETWORK_PASSPHRASE="Public Global Stellar Network ; September 2015"


An integer for the number of seconds to wait before canceling a server-side callback request to Transaction.on_change_callback if present. Only used for SEP-6 and SEP-24. Polaris makes server-side requests to Transaction.on_change_callback from CLI commands such as process_pending_deposits and execute_outgoing_transactions. Server-side callbacks requests are not made from the API server.

Defaults to 3 seconds.


A list of home domains to check before accepting an on_change_callback parameter in SEP-6 and SEP-24 requests. This setting can be useful when a client is providing a callback URL that consistently reaches the CALLBACK_REQUEST_TIMEOUT limit, slowing down the rate at which transactions are processed. Requests containing denied callback URLs will not be rejected, but the URLs will not be saved to Transaction.on_change_callback and requests will not be made.

A boolean value indicating whether or not to provide the more_info_url response attribute in SEP-6 GET /transaction(s) responses and make the sep6/transaction/more_info endpoint available.

Defaults to False.



A boolean value indicating whether or not fee amounts returned from the registered fee function should be added to Transaction.amount_in, the amount the user should send to the anchor. Only used for SEP-24 transactions, specifically when a TransactionForm is submitted. If this functionality is desired for SEP-6 or SEP-31 transactions, the anchor can implement the logic themselves in the provided integration functions.

Defaults to False. By default, fees are subtracted from the amount initially specified by the client application or user.



Add the Polaris endpoints in

import polaris.urls
from django.urls import path, include

urlpatterns = [
    path("", include(polaris.urls)),

Database Models

Polaris works with all Django-supported databases. Install your database driver and see the DATABASES setting docs for configuring the database connection. If you find Polaris attempts to make queries incompatible with your database, file an issue in the project’s github repository.

Once configured, run migrations to create these tables in your database.

python migrate

Now, create an Asset database object for each asset you intend to anchor. Get into your python shell, then run something like this:

from polaris.models import Asset
    issuer="<the issuer address>",
    distribution_seed="<distribution account secret key>",

The distribution_seed and channel_seed columns are encrypted at the database layer using Fernet symmetric encryption, and only decrypted when held in memory within an Asset object. It uses your Django project’s SECRET_KEY setting to generate the encryption key, so make sure its value is unguessable and kept a secret.

See the Asset documentation for more information on the fields used.

At this point, you should configure Polaris for one or more of the SEPs currently supported. Once configured, check out how to run the server as described in the next section.

Running the Web Server



Polaris should only be deployed using HTTPS in production. You should do this by using a HTTPS web server or running Polaris behind a HTTPS reverse proxy. The steps below outline the settings necessary to ensure your deployment is secure.

To redirect HTTP traffic to HTTPS, add the following to


If you’re running Polaris behind a HTTPS proxy:


This tells Django what header to check and what value it should be in order to consider the incoming request secure.

And finally, if you activate SEP-24, add the following setting:


Polaris requires this setting to be True for SEP-24 deployments if not in LOCAL_MODE.

Rate Limiting

It is highly encouraged to employ a rate limiting strategy when running Polaris to ensure the service remains available for all client applications. Many endpoints retrieve and create database records on each request, and some endpoints make outgoing web requests to Horizon or a client application’s callback endpoint.

Rate limiting can be particularly important for SEP-6 or SEP-24 deposit requests because the anchor is expected to poll their off-chain rails to detect if any of the funds from pending transactions initiated in these requests have arrived in the anchor’s account, which can be a resource-intensive process.

Rate limiting can be deployed using a number of strategies that often depend on the anchor’s deployment infrastructure. Optionally, the anchor could also implement a rate limiting policy using Django custom middleware support.

Local Development

Locally, Polaris can be run using Django’s HTTP development server

python runserver

If you’re using Polaris’ SEP-24 support, you also need to use the following environment variable:


This is necessary to disable SEP-24’s interactive flow authentication mechanism, which requires HTTPS. Do not use local mode in production.


To set up the development environment or run the SDF’s reference server, run follow the instructions below.

git clone
cd django-polaris

Then, add a .env file in the example directory. You’ll need to create a signing account on Stellar’s testnet and add it to your environment variables.

SIGNING_SEED=<your signing account seed>
STELLAR_NETWORK_PASSPHRASE="Test SDF Network ; September 2015"

Next, you’ll need to create an asset on the Stellar test network and setup a distribution account. Polaris offers a CLI command that allows developers to issue assets on testnet. See the CLI Commands documentation for more information.

Now you’re ready to add your asset to Polaris. Run the following commands:

$ docker-compose build
$ docker-compose up server

Use another process to run the following:

$ docker exec -it server python shell

Once you enter the python console, create the asset database object:

from polaris.models import Asset


Enter the code, issuer, and distribution seed for the asset. Enable the SEPs you want to test.

Finally, exit the python console, kill the current docker-compose process, and run a new one:

$ docker-compose up

This will run all processes, and you should now have a anchor server running on port 8000. When you make changes locally, the docker containers will restart with the updated code.


First, cd into the polaris directory and create an .env file just like you did for example. However, do not include LOCAL_MODE and make sure all URLs use HTTPS. This is done because Polaris tests functionality that is only run when LOCAL_MODE is not True. When not in local mode, Polaris expects it’s URLs to be HTTPS.

Once you’ve created your .env file, you can install the dependencies locally in a virtual environment:

pip install pipenv
pipenv install --dev
pipenv run pytest -c polaris/pytest.ini

Or, you can simply run the tests from inside the docker container. However, this may be slower.

docker exec -it server pytest -c polaris/pytest.ini

Submit a PR

After you’ve made your changes, push them to you a remote branch and make a Pull Request on the stellar/django-polaris repository’s master branch. Note that Polaris uses the black code formatter, so please format your code before requesting us to merge your changes.