Can I access constants in from templates in Django?

Can I access constants in from templates in Django?

I have some stuff in that I'd like to be able to access from a template, but I can't figure out how to do it. I already tried

but that doesn't seem to work. Is this possible?


Answer 1:

Django provides access to certain, frequently-used settings constants to the template such as settings.MEDIA_URL and some of the language settings if you use django’s built in generic views or pass in a context instance keyword argument in the render_to_response shortcut function. Here’s an example of each case:

from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.generic.simple import direct_to_template

def my_generic_view(request, template='my_template.html'):
    return direct_to_template(request, template)

def more_custom_view(request, template='my_template.html'):
    return render_to_response(template, {}, context_instance=RequestContext(request))

These views will both have several frequently used settings like settings.MEDIA_URL available to the template as {{ MEDIA_URL }}, etc.

If you’re looking for access to other constants in the settings, then simply unpack the constants you want and add them to the context dictionary you’re using in your view function, like so:

from django.conf import settings
from django.shortcuts import render_to_response

def my_view_function(request, template='my_template.html'):
    context = {'favorite_color': settings.FAVORITE_COLOR}
    return render_to_response(template, context)

Now you can access settings.FAVORITE_COLOR on your template as {{ favorite_color }}.

Answer 2:

If it’s a value you’d like to have for every request & template, using a context processor is more appropriate.

Here’s how:

  1. Make a file in your app directory. Let’s say I want to have the ADMIN_PREFIX_VALUE value in every context:

    from django.conf import settings # import the settings file
    def admin_media(request):
        # return the value you want as a dictionnary. you may add multiple values in there.
        return {'ADMIN_MEDIA_URL': settings.ADMIN_MEDIA_PREFIX}
  2. add your context processor to your file:

    TEMPLATES = [{
        # whatever comes before
        'OPTIONS': {
            'context_processors': [
                # whatever comes before
  3. Use RequestContext in your view to add your context processors in your template. The render shortcut does this automatically:

    from django.shortcuts import render
    def my_view(request):
        return render(request, "index.html")
  4. and finally, in your template:

    <a href="{{ ADMIN_MEDIA_URL }}">path to admin media</a>

Answer 3:

I find the simplest approach being a single custom template tag:

from django import template
from django.conf import settings

register = template.Library()

# settings value
def settings_value(name):
    return getattr(settings, name, "")


{% settings_value "LANGUAGE_CODE" %}

Answer 4:

Check out django-settings-export (disclaimer: I’m the author of this project).

For example…

$ pip install django-settings-export

        'OPTIONS': {
            'context_processors': [

MY_CHEESE = 'Camembert';



<script>var MY_CHEESE = '{{ settings.MY_CHEESE }}';</script>

Answer 5:

Another way to do this is to create a custom template tag which can let you fish values out of the settings.

def value_from_settings(parser, token):
        # split_contents() knows not to split quoted strings.
        tag_name, var = token.split_contents()
    except ValueError:
        raise template.TemplateSyntaxError, "%r tag requires a single argument" % token.contents.split()[0]
    return ValueFromSettings(var)

class ValueFromSettings(template.Node):
    def __init__(self, var):
        self.arg = template.Variable(var)
    def render(self, context):        
        return settings.__getattr__(str(self.arg))

You can then use:

{% value_from_settings "FQDN" %}

to print it on any page, without jumping through context-processor hoops.

Answer 6:

I like Berislav’s solution, because on simple sites, it is clean and effective. What I do NOT like is exposing all the settings constants willy-nilly. So what I ended up doing was this:

from django import template
from django.conf import settings

register = template.Library()


# settings value
def settings_value(name):
    if name in ALLOWABLE_VALUES:
        return getattr(settings, name, '')
    return ''


{% settings_value "CONSTANT_NAME_1" %}

This protects any constants that you have not named from use in the template, and if you wanted to get really fancy, you could set a tuple in the settings, and create more than one template tag for different pages, apps or areas, and simply combine a local tuple with the settings tuple as needed, then do the list comprehension to see if the value is acceptable.
I agree, on a complex site, this is a bit simplistic, but there are values that would be nice to have universally in templates, and this seems to work nicely.
Thanks to Berislav for the original idea!

Answer 7:

I improved chrisdew’s answer (to create your own tag) a little bit.

First, create the file yourapp/templatetags/ in which you define your own new tag value_from_settings:

from django.template import TemplateSyntaxError, Variable, Node, Variable, Library
from yourapp import settings

register = Library()
# I found some tricks in URLNode and url from
def value_from_settings(parser, token):
  bits = token.split_contents()
  if len(bits) < 2:
    raise TemplateSyntaxError("'%s' takes at least one " \
      "argument (settings constant to retrieve)" % bits[0])
  settingsvar = bits[1]
  settingsvar = settingsvar[1:-1] if settingsvar[0] == '"' else settingsvar
  asvar = None
  bits = bits[2:]
  if len(bits) >= 2 and bits[-2] == 'as':
    asvar = bits[-1]
    bits = bits[:-2]
  if len(bits):
    raise TemplateSyntaxError("'value_from_settings' didn't recognise " \
      "the arguments '%s'" % ", ".join(bits))
  return ValueFromSettings(settingsvar, asvar)

class ValueFromSettings(Node):
  def __init__(self, settingsvar, asvar):
    self.arg = Variable(settingsvar)
    self.asvar = asvar
  def render(self, context):
    ret_val = getattr(settings,str(self.arg))
    if self.asvar:
      context[self.asvar] = ret_val
      return ''
      return ret_val

You can use this tag in your Template via:

{% load value_from_settings %}
{% value_from_settings "FQDN" %}

or via

{% load value_from_settings %}
{% value_from_settings "FQDN" as my_fqdn %}

The advantage of the as ... notation is that this makes it easy to use in blocktrans blocks via a simple {{my_fqdn}}.

Answer 8:

Adding an answer with complete instructions for creating a custom template tag that solves this, with Django 2.0+

In your app-folder, create a folder called templatetags. In it, create and

Custom tags folder structure

In the create a custom tag function that provides access to an arbitrary key in the settings constant:

from django import template
from django.conf import settings

register = template.Library()

def get_setting(name):
    return getattr(settings, name, "")

To understand this code I recommend reading the section on simple tags in the Django docs.

Then, you need to make Django aware of this (and any additional) custom tag by loading this file in any template where you will use it. Just like you need to load the built in static tag:

{% load custom_tags %}

With it loaded it can be used just like any other tag, just supply the specific setting you need returned. So if you have a BUILD_VERSION variable in your settings:

{% get_setting "BUILD_VERSION" %}

This solution will not work with arrays, but if you need that you might be putting to much logic in your templates.

Note: A more clean and failsafe solution would probably be to make a custom context processor where you add the settings you need to a context available to all templates. This way you reduce the risk of outputting sensitive settings in your templates by mistake.

Answer 9:

The example above from bchhun is nice except that you need to explicitly build your context dictionary from Below is an UNTESTED example of how you could auto-build the context dictionary from all upper-case attributes of (re: “^[A-Z0-9_]+$”).

At the end of

_context = {} 
local_context = locals()
for (k,v) in local_context.items():
        _context[k] = str(v)

def settings_context(context):
    return _context


Answer 10:

If someone finds this question like I did, then I’ll post my solution which works on Django 2.0:

This tag assigns some variable value to template’s variable:

Usage: {% get_settings_value template_var "SETTINGS_VAR" %}


from django import template
from django.conf import settings

register = template.Library()

class AssignNode(template.Node):
    def __init__(self, name, value): = name
        self.value = value

    def render(self, context):
        context[] = getattr(settings, self.value.resolve(context, True), "")
        return ''

def do_assign(parser, token):
    bits = token.split_contents()
    if len(bits) != 3:
        raise template.TemplateSyntaxError("'%s' tag takes two arguments" % bits[0])
    value = parser.compile_filter(bits[2])
    return AssignNode(bits[1], value)

Your template:

{% load my_custom_tags %}

# Set local template variable:
{% get_settings_value settings_debug "DEBUG" %}

# Output settings_debug variable:
{{ settings_debug }}

# Use variable in if statement:
{% if settings_debug %}
... do something ...
{% else %}
... do other stuff ...
{% endif %}

See Django’s documentation how to create custom template tags here:

Answer 11:

Add this code to a file called

from django.conf import settings as django_settings

def settings(request):
    return {
        'settings': django_settings,

And then, in your settings file, include a path such as 'speedy.core.base.context_processors.settings' (with your app name and path) in the 'context_processors' settings in TEMPLATES.

(You can see for example and

Answer 12:

If using a class-based view:

# in
YOUR_CUSTOM_SETTING = 'some value'

# in
from django.conf import settings #for getting settings vars

class YourView(DetailView): #assuming DetailView; whatever though

    # ...

    def get_context_data(self, **kwargs):

        context = super(YourView, self).get_context_data(**kwargs)
        context['YOUR_CUSTOM_SETTING'] = settings.YOUR_CUSTOM_SETTING

        return context

# in your_template.html, reference the setting like any other context variable

Answer 13:

I found this to be the simplest approach for Django 1.3:


    from local_settings import BASE_URL
    def root(request):
        return render_to_response('hero.html', {'BASE_URL': BASE_URL})
  2. hero.html

    var BASE_URL = '{{ JS_BASE_URL }}';

Answer 14:

Both IanSR and bchhun suggested overriding TEMPLATE_CONTEXT_PROCESSORS in the settings. Be aware that this setting has a default that can cause some screwy things if you override it without re-setting the defaults. The defaults have also changed in recent versions of Django.


TEMPLATE_CONTEXT_PROCESSORS = ("django.contrib.auth.context_processors.auth",