django.contrib.staticfiles collects static files from each of your
applications (and any other places you specify) into a single location that
can easily be served in production.

See also

For an introduction to the static files app and some usage examples, see
Managing static files (e.g. images, JavaScript, CSS). For guidelines on deploying static files,
see Deploying static files.

Management Commands¶

django.contrib.staticfiles exposes three management commands.


django-admin collectstatic

Collects the static files into STATIC_ROOT.

Duplicate file names are by default resolved in a similar way to how template
resolution works: the file that is first found in one of the specified
locations will be used. If you’re confused, the findstatic command
can help show you which files are found.

On subsequent collectstatic runs (if STATIC_ROOT isn’t empty), files
are copied only if they have a modified timestamp greater than the timestamp of
the file in STATIC_ROOT. Therefore if you remove an application from
INSTALLED_APPS, it’s a good idea to use the collectstatic
option in order to remove stale static files.

Files are searched by using the enabled finders. The default is to look in all locations defined in
STATICFILES_DIRS and in the 'static' directory of apps
specified by the INSTALLED_APPS setting.

The collectstatic management command calls the
method of the STATICFILES_STORAGE after each run and passes
a list of paths that have been found by the management command. It also
receives all command line options of collectstatic. This is used
by the CachedStaticFilesStorage
by default.

By default, collected files receive permissions from
FILE_UPLOAD_PERMISSIONS and collected directories receive permissions
from FILE_UPLOAD_DIRECTORY_PERMISSIONS. If you would like different
permissions for these files and/or directories, you can subclass either of the
static files storage classes and specify the
file_permissions_mode and/or directory_permissions_mode parameters,
respectively. For example:

from django.contrib.staticfiles import storage

class MyStaticFilesStorage(storage.StaticFilesStorage):
    def __init__(self, *args, **kwargs):
        kwargs['file_permissions_mode'] = 0o640
        kwargs['directory_permissions_mode'] = 0o760
        super().__init__(*args, **kwargs)

Then set the STATICFILES_STORAGE setting to

Some commonly used options are:

--noinput, --no-input

Do NOT prompt the user for input of any kind.

--ignore PATTERN, -i PATTERN

Ignore files or directories matching this glob-style pattern. Use multiple
times to ignore more.

--dry-run, -n

Do everything except modify the filesystem.

--clear, -c

Clear the existing files before trying to copy or link the original file.

Create a symbolic link to each file instead of copying.


Don’t call the
method of the configured STATICFILES_STORAGE storage backend.


Don’t ignore the common private glob-style patterns 'CVS', '.*'
and '*~'.

For a full list of options, refer to the commands own help by running:

$ python collectstatic --help

Customizing the ignored pattern list

The default ignored pattern list, ['CVS', '.*', '*~'], can be customized in
a more persistent way than providing the --ignore command option at each
collectstatic invocation. Provide a custom AppConfig
class, override the ignore_patterns attribute of this class and replace
'django.contrib.staticfiles' with that class path in your

from django.contrib.staticfiles.apps import StaticFilesConfig

class MyStaticFilesConfig(StaticFilesConfig):
    ignore_patterns = [...]  # your custom ignore list


django-admin findstatic staticfile [staticfile ...]

Searches for one or more relative paths with the enabled finders.

For example:

$ python findstatic css/base.css admin/js/core.js
Found 'css/base.css' here:
Found 'admin/js/core.js' here:
findstatic --first

By default, all matching locations are found. To only return the first match
for each relative path, use the --first option:

$ python findstatic css/base.css --first
Found 'css/base.css' here:

This is a debugging aid; it’ll show you exactly which static file will be
collected for a given path.

By setting the --verbosity flag to 0, you can suppress the extra output and
just get the path names:

$ python findstatic css/base.css --verbosity 0

On the other hand, by setting the --verbosity flag to 2, you can get all
the directories which were searched:

$ python findstatic css/base.css --verbosity 2
Found 'css/base.css' here:
Looking in the following locations:


django-admin runserver [addrport]

Overrides the core runserver command if the staticfiles app
is installed and adds automatic serving of static
files. File serving doesn’t run through MIDDLEWARE.

The command adds these options:


Use the --nostatic option to disable serving of static files with the
staticfiles app entirely. This option is
only available if the staticfiles app is
in your project’s INSTALLED_APPS setting.

Example usage:

django-admin runserver --nostatic

Use the --insecure option to force serving of static files with the
staticfiles app even if the DEBUG
setting is False. By using this you acknowledge the fact that it’s
grossly inefficient and probably insecure. This is only intended for
local development, should never be used in production and is only
available if the staticfiles app is
in your project’s INSTALLED_APPS setting.

--insecure doesn’t work with
ManifestStaticFilesStorage or

Example usage:

django-admin runserver --insecure



class storage.StaticFilesStorage

A subclass of the FileSystemStorage
storage backend that uses the STATIC_ROOT setting as the base
file system location and the STATIC_URL setting respectively
as the base URL.

storage.StaticFilesStorage.post_process(paths, **options)

This method is called by the collectstatic management command
after each run and gets passed the local storages and paths of found
files as a dictionary, as well as the command line options.

The CachedStaticFilesStorage
uses this behind the scenes to replace the paths with their hashed
counterparts and update the cache appropriately.


class storage.ManifestStaticFilesStorage

A subclass of the StaticFilesStorage
storage backend which stores the file names it handles by appending the MD5
hash of the file’s content to the filename. For example, the file
css/styles.css would also be saved as css/styles.55e7cbb9ba48.css.

The purpose of this storage is to keep serving the old files in case some
pages still refer to those files, e.g. because they are cached by you or
a 3rd party proxy server. Additionally, it’s very helpful if you want to
apply far future Expires headers to the deployed files to speed up the
load time for subsequent page visits.

The storage backend automatically replaces the paths found in the saved
files matching other saved files with the path of the cached copy (using
the post_process()
method). The regular expressions used to find those paths
by default covers the @import rule and url() statement of Cascading
Style Sheets
. For example, the 'css/styles.css' file with the

@import url("../admin/css/base.css");

would be replaced by calling the url()
method of the ManifestStaticFilesStorage storage backend, ultimately
saving a 'css/styles.55e7cbb9ba48.css' file with the following

@import url("../admin/css/base.27e20196a850.css");

Since static files might reference other static files that need to have their
paths replaced, multiple passes of replacing paths may be needed until the file
hashes converge. To prevent an infinite loop due to hashes not converging (for
example, if 'foo.css' references 'bar.css' which references
'foo.css') there is a maximum number of passes before post-processing is
abandoned. In cases with a large number of references, a higher number of
passes might be needed. Increase the maximum number of passes by subclassing
ManifestStaticFilesStorage and setting the max_post_process_passes
attribute. It defaults to 5.

Changed in Django 1.11:

Previous versions didn’t make multiple passes to ensure file hashes
converged, so often times file hashes weren’t correct. The
max_post_process_passes attribute was added.

To enable the ManifestStaticFilesStorage you have to make sure the
following requirements are met:

  • the STATICFILES_STORAGE setting is set to
  • the DEBUG setting is set to False
  • you’ve collected all your static files by using the
    collectstatic management command

Since creating the MD5 hash can be a performance burden to your website
during runtime, staticfiles will automatically store the mapping with
hashed names for all processed files in a file called staticfiles.json.
This happens once when you run the collectstatic management


If a file isn’t found in the staticfiles.json manifest at runtime, a
ValueError is raised. This behavior can be disabled by subclassing
ManifestStaticFilesStorage and setting the manifest_strict attribute to
False — nonexistent paths will remain unchanged.

Changed in Django 1.11:

The manifest_strict attribute was added. In older versions, the
behavior is the same as manifest_strict=False.

Due to the requirement of running collectstatic, this storage
typically shouldn’t be used when running tests as collectstatic isn’t run
as part of the normal test setup. During testing, ensure that the
STATICFILES_STORAGE setting is set to something else like
'' (the default).

storage.ManifestStaticFilesStorage.file_hash(name, content=None)

The method that is used when creating the hashed name of a file.
Needs to return a hash for the given file name and content.
By default it calculates a MD5 hash from the content’s chunks as
mentioned above. Feel free to override this method to use your own
hashing algorithm.


class storage.CachedStaticFilesStorage

CachedStaticFilesStorage is a similar class like the
ManifestStaticFilesStorage class
but uses Django’s caching framework for storing the
hashed names of processed files instead of a static manifest file called
staticfiles.json. This is mostly useful for situations in which you don’t
have access to the file system.

If you want to override certain options of the cache backend the storage uses,
simply specify a custom entry in the CACHES setting named
'staticfiles'. It falls back to using the 'default' cache backend.


CachedStaticFilesStorage isn’t recommended — in almost all cases
ManifestStaticFilesStorage is a better choice. There are several
performance penalties when using CachedStaticFilesStorage since a cache
miss requires hashing files at runtime. Remote file storage require several
round-trips to hash a file on a cache miss, as several file accesses are
required to ensure that the file hash is correct in the case of nested file

Finders Module¶

staticfiles finders has a searched_locations attribute which is a list
of directory paths in which the finders searched. Example usage:

from django.contrib.staticfiles import finders

result = finders.find('css/base.css')
searched_locations = finders.searched_locations

Other Helpers¶

There are a few other helpers outside of the
staticfiles app to work with static

Static file development view¶

The static files tools are mostly designed to help with getting static files
successfully deployed into production. This usually means a separate,
dedicated static file server, which is a lot of overhead to mess with when
developing locally. Thus, the staticfiles app ships with a
quick and dirty helper view that you can use to serve files locally in

views.serve(request, path)

This view function serves static files in development.


This view will only work if DEBUG is True.

That’s because this view is grossly inefficient and probably
insecure. This is only intended for local development, and should
never be used in production.


To guess the served files’ content types, this view relies on the
mimetypes module from the Python standard library, which itself
relies on the underlying platform’s map files. If you find that this view
doesn’t return proper content types for certain files, it is most likely
that the platform’s map files need to be updated. This can be achieved, for
example, by installing or updating the mailcap package on a Red Hat
distribution, or mime-support on a Debian distribution.

This view is automatically enabled by runserver (with a
DEBUG setting set to True). To use the view with a different
local development server, add the following snippet to the end of your
primary URL configuration:

from django.conf import settings
from django.contrib.staticfiles import views
from django.urls import re_path

if settings.DEBUG:
    urlpatterns += [
        re_path(r'^static/(?P<path>.*)$', views.serve),

Note, the beginning of the pattern (r'^static/') should be your
STATIC_URL setting.

Since this is a bit finicky, there’s also a helper function that’ll do this for


This will return the proper URL pattern for serving static files to your
already defined pattern list. Use it like this:

from django.contrib.staticfiles.urls import staticfiles_urlpatterns

# ... the rest of your URLconf here ...

urlpatterns += staticfiles_urlpatterns()

This will inspect your STATIC_URL setting and wire up the view
to serve static files accordingly. Don’t forget to set the
STATICFILES_DIRS setting appropriately to let
django.contrib.staticfiles know where to look for files in addition to
files in app directories.


This helper function will only work if DEBUG is True
and your STATIC_URL setting is neither empty nor a full
URL such as

That’s because this view is grossly inefficient and probably
insecure. This is only intended for local development, and should
never be used in production.

Specialized test case to support ‘live testing’¶

class testing.StaticLiveServerTestCase

This unittest TestCase subclass extends django.test.LiveServerTestCase.

Just like its parent, you can use it to write tests that involve running the
code under test and consuming it with testing tools through HTTP (e.g. Selenium,
PhantomJS, etc.), because of which it’s needed that the static assets are also

But given the fact that it makes use of the
django.contrib.staticfiles.views.serve() view described above, it can
transparently overlay at test execution-time the assets provided by the
staticfiles finders. This means you don’t need to run
collectstatic before or as a part of your tests setup.