• Home
• Tutorial
  • Quickstart
  • 1 - Serialization
  • 2 - Requests and responses
  • 3 - Class based views
  • 4 - Authentication and permissions
  • 5 - Relationships and hyperlinked APIs
  • 6 - Viewsets and routers
• API Guide
  • Requests
  • Responses
  • Views
  • Generic views
  • Viewsets
  • Routers
  • Parsers
  • Renderers
  • Serializers
  • Serializer fields
  • Serializer relations
  • Validators
  • Authentication
  • Permissions
  • Caching
  • Throttling
  • Filtering
  • Pagination
  • Versioning
  • Content negotiation
  • Metadata
  • Schemas
  • Format suffixes
  • Returning URLs
  • Exceptions
  • Status codes
  • Testing
  • Settings
• Topics
  • Documenting your API
  • Internationalization
  • AJAX, CSRF & CORS
  • HTML & Forms
  • Browser Enhancements
  • The Browsable API
  • REST, Hypermedia & HATEOAS
• Community
  • Tutorials and Resources
  • Third Party Packages
  • Contributing to REST framework
  • Project management
  • Release Notes
  • 3.16 Announcement
  • 3.15 Announcement
  • 3.14 Announcement
  • 3.13 Announcement
  • 3.12 Announcement
  • 3.11 Announcement
  • 3.10 Announcement
  • 3.9 Announcement
  • 3.8 Announcement
  • 3.7 Announcement
  • 3.6 Announcement
  • 3.5 Announcement
  • 3.4 Announcement
  • 3.3 Announcement
  • 3.2 Announcement
  • 3.1 Announcement
  • 3.0 Announcement
  • Kickstarter Announcement
  • Mozilla Grant
  • Funding
  • Jobs

Documentation search

Quickstart

We're going to create a simple API to allow admin users to view and edit the users and groups in the system.

Project setup

Create a new Django project namedtutorial, then start a new app calledquickstart.

# Create the project directorymkdir tutorialcd tutorial# Create a virtual environment to isolate our package dependencies locallypython3 -m venv envsource env/bin/activate  # On Windows use `env\Scripts\activate`# Install Django and Django REST framework into the virtual environmentpip install djangorestframework# Set up a new project with a single applicationdjango-admin startproject tutorial .  # Note the trailing '.' charactercd tutorialdjango-admin startapp quickstartcd ..

The project layout should look like:

$ pwd<some path>/tutorial$ find .../tutorial./tutorial/asgi.py./tutorial/__init__.py./tutorial/quickstart./tutorial/quickstart/migrations./tutorial/quickstart/migrations/__init__.py./tutorial/quickstart/models.py./tutorial/quickstart/__init__.py./tutorial/quickstart/apps.py./tutorial/quickstart/admin.py./tutorial/quickstart/tests.py./tutorial/quickstart/views.py./tutorial/settings.py./tutorial/urls.py./tutorial/wsgi.py./env./env/..../manage.py

It may look unusual that the application has been created within the project directory. Using the project's namespace avoids name clashes with external modules (a topic that goes outside the scope of the quickstart).

Now sync your database for the first time:

python manage.py migrate

We'll also create an initial user namedadmin with a password. We'll authenticate as that user later in our example.

python manage.py createsuperuser --username admin --email admin@example.com

Once you've set up a database and the initial user is created and ready to go, open up the app's directory and we'll get coding...

Serializers

First up we're going to define some serializers. Let's create a new module namedtutorial/quickstart/serializers.py that we'll use for our data representations.

from django.contrib.auth.models import Group, Userfrom rest_framework import serializersclass UserSerializer(serializers.HyperlinkedModelSerializer):    class Meta:        model = User        fields = ['url', 'username', 'email', 'groups']class GroupSerializer(serializers.HyperlinkedModelSerializer):    class Meta:        model = Group        fields = ['url', 'name']

Notice that we're using hyperlinked relations in this case withHyperlinkedModelSerializer. You can also use primary key and various other relationships, but hyperlinking is good RESTful design.

Views

Right, we'd better write some views then. Opentutorial/quickstart/views.py and get typing.

from django.contrib.auth.models import Group, Userfrom rest_framework import permissions, viewsetsfrom tutorial.quickstart.serializers import GroupSerializer, UserSerializerclass UserViewSet(viewsets.ModelViewSet):    """    API endpoint that allows users to be viewed or edited.    """    queryset = User.objects.all().order_by('-date_joined')    serializer_class = UserSerializer    permission_classes = [permissions.IsAuthenticated]class GroupViewSet(viewsets.ModelViewSet):    """    API endpoint that allows groups to be viewed or edited.    """    queryset = Group.objects.all().order_by('name')    serializer_class = GroupSerializer    permission_classes = [permissions.IsAuthenticated]

Rather than write multiple views we're grouping together all the common behavior into classes calledViewSets.

We can easily break these down into individual views if we need to, but using viewsets keeps the view logic nicely organized as well as being very concise.

URLs

Okay, now let's wire up the API URLs. On totutorial/urls.py...

from django.urls import include, pathfrom rest_framework import routersfrom tutorial.quickstart import viewsrouter = routers.DefaultRouter()router.register(r'users', views.UserViewSet)router.register(r'groups', views.GroupViewSet)# Wire up our API using automatic URL routing.# Additionally, we include login URLs for the browsable API.urlpatterns = [    path('', include(router.urls)),    path('api-auth/', include('rest_framework.urls', namespace='rest_framework'))]

Because we're using viewsets instead of views, we can automatically generate the URL conf for our API, by simply registering the viewsets with a router class.

Again, if we need more control over the API URLs we can simply drop down to using regular class-based views, and writing the URL conf explicitly.

Finally, we're including default login and logout views for use with the browsable API. That's optional, but useful if your API requires authentication and you want to use the browsable API.

Pagination

Pagination allows you to control how many objects per page are returned. To enable it add the following lines totutorial/settings.py

REST_FRAMEWORK = {    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',    'PAGE_SIZE': 10}

Settings

Add'rest_framework' toINSTALLED_APPS. The settings module will be intutorial/settings.py

INSTALLED_APPS = [    ...    'rest_framework',]

Okay, we're done.

Testing our API

We're now ready to test the API we've built. Let's fire up the server from the command line.

python manage.py runserver

We can now access our API, both from the command-line, using tools likecurl...

bash: curl -u admin -H 'Accept: application/json; indent=4' http://127.0.0.1:8000/users/Enter host password for user 'admin':{    "count": 1,    "next": null,    "previous": null,    "results": [        {            "url": "http://127.0.0.1:8000/users/1/",            "username": "admin",            "email": "admin@example.com",            "groups": []        }    ]}

Or using thehttpie, command line tool...

bash: http -a admin http://127.0.0.1:8000/users/http: password for admin@127.0.0.1:8000:: $HTTP/1.1 200 OK...{    "count": 1,    "next": null,    "previous": null,    "results": [        {            "email": "admin@example.com",            "groups": [],            "url": "http://127.0.0.1:8000/users/1/",            "username": "admin"        }    ]}

Or directly through the browser, by going to the URLhttp://127.0.0.1:8000/users/...

If you're working through the browser, make sure to login using the control in the top right corner.

Great, that was easy!

If you want to get a more in depth understanding of how REST framework fits together head on over tothe tutorial, or start browsing theAPI guide.