Using python graphene with Django

How to write GraphQL compliant apis with Django


We will write a GraphQL compliant api for a Django project.

We will use two models through this post and expose the data for those models using GraphQL api.

  • We will use graphene library to create our GraphQL service.
  • The GraphQL service will interact with Django models.
  • We will expose this GraphQL service using Django.

This post builds on our last postwhich gives an introduction to Python graphene.


This post assumes that you have the project setup as described at

You must have a polls app in your project and the models Question and Choice.

# polls/
class Question(models.Model):
    question_text = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')

    def __str__(self):
        return self.question_text

class Choice(models.Model):
    question = models.ForeignKey(Question, on_delete=models.CASCADE)
    choice_text = models.CharField(max_length=200)
    votes = models.IntegerField(default=0)

    def __str__(self):
        return self.choice_text


Create a file called mysite/ This assumes that your project name is mysite created using django-admin startproject mysite.

# mysite/

from graphene import Schema, ObjectType, Field, String, List, Int

from polls.models import Question

class QuestionType(ObjectType):

    question_text = String()
    pub_date = String()

    def resolve_question_text(question, info):
        return question.question_text

    def resolve_pub_date(question, info):
        return question.pub_date.strftime('%Y-%m-%d')

class Query(ObjectType):
    questions = List(QuestionType)
    question = Field(QuestionType, id=Int())

    def resolve_questions(root, info):
        return Question.objects.all()

    def resolve_question(root, info, id):
        return Question.objects.get(id=id)

schema = Schema(query=Query)

We have named our root object type as Query. It has two fields called questions and question.

We will use questions to get list of all questions. We will use question to get detail of a particular question.


Let’s make some queries from shell.

Get question_text and id of all questions.

In [5]: schema.execute('{ questions{ID questionText} }').data
              [OrderedDict([('ID', 56),
                            ('questionText', 'Is the color of sky blue')]),
               OrderedDict([('ID', 57),
                             'Is Samsung more reliable than iPhone?')]),
               OrderedDict([('ID', 61),
                             'Is the color of sky yellow')])])])

Get question_text and pub_date of all questions.

In [6]: schema.execute('{ questions{questionText pubDate} }').data
              [OrderedDict([('questionText', 'Is the color of sky blue'),
                            ('pubDate', '2019-05-15')]),
                             'Is Samsung more reliable than iPhone?'),
                            ('pubDate', '2019-07-03')]),
               OrderedDict([('questionText', 'Is the color of sky yellow'),
                            ('pubDate', '2019-08-13')])])])

Get question_text and pub_date of question with id 56.

In [7]: schema.execute('{ question(id:56){questionText pubDate} }').data
              OrderedDict([('questionText', 'Is the color of sky blue'),
                           ('pubDate', '2019-05-15')]))])


Let’s setup the api endpoint /graphql. Create a view and a urlpattern.

# mysite/
from django.views import View
from django.http import JsonResponse

from .graphql import schema

class GraphQLView(View):

    def get(self, request, *args, **kwargs):
        search = request.GET.get('search')
        result = schema.execute(search)
        return JsonResponse(, safe=False)

Urlpattern would look like:

# mysite/

from . import views

urlpatterns = [
    path('graphql/', views.GraphQLView.as_view()),

Start the server

python runserver

With this setup, the following queries, which we tried on shell, should work.

http://localhost:8000/graphql/?search={ questions{ID questionText} }
http://localhost:8000/graphql/?search={ questions{questionText pubDate} }
http://localhost:8000/graphql/?search={ question(id:56){questionText pubDate} }


We can use Graphql aliases and get question detail for two different questions in a single api call.

http://localhost:8000/graphql/?search={second: question(id:57){questionText pubDate} first: question(id:56){questionText pubDate}}

This would have required two api calls in a classic REST architecture.

Nested fields

Let’s modify our GraphQL service so clients can get question related choices too along with question. This would need created a ChoiceType.

class ChoiceType(ObjectType):
    choice_text = String()
    votes = Int()

    def resolve_choice_text(choice, info):
        return choice.choice_text

    def resolve_votes(choice, info):
        return choice.votes

Let’s add ChoiceType to QuestionType.

class QuestionType(ObjectType):

    choices = List(ChoiceType)

    def resolve_choices(question, info):
        return question.choice_set.all()

I have skipped other fields ID, pub_date and question_text here for brevity sake. Do not remove those fields and their resolver functions. Just add a choices and resolve_choices as done above.

Let’s restart the shell and query for a question detail and ask for choice_text of associated choices too.

In [7]: search = '{question(id:56){questionText pubDate choices{choiceText}}}'

In [8]: schema.execute(search).data
              OrderedDict([('questionText', 'Is the color of sky blue'),
                           ('pubDate', '2019-05-15'),
                            [OrderedDict([('choiceText', 'maybe')]),
                             OrderedDict([('choiceText', 'yes')]),
                             OrderedDict([('choiceText', 'no')])])]))])

The api call would look like:

http://localhost:8000/graphql/?search={question(id:56){questionText pubDate choices{choiceText}}}


We want to provide a way to create Question. The way to do that with GraphQL is mutations.

Let’s write a mutation called CreateQuestion. Model Question has fields question_text and pub_date. So mutation will need arguments question_text and pub_date.

Any Mutation we write with python-graphene needs to have a method called mutate. This is synonymous to how resolver functions are needed for query objecttypes.

Basic strucutre of a Mutation looks like:

class CreateQuestion(Mutation):
    class Arguments:

    def mutate(root, info, *args):

Let’s write actual code of CreateQuestion.

class CreateQuestion(Mutation):
    class Arguments:
        question_text = String()
        pub_date = String()

    question = Field(QuestionType)

    def mutate(root, info, question_text, pub_date):
        pub_date = datetime.datetime.strptime(pub_date, '%Y-%m-%d')
        question = Question.objects.create(question_text=question_text, pub_date=pub_date)
        return CreateQuestion(question=question)

We will have to add this mutation on schema so that our GraphQL service understands that this mutation is an entry point.

class MyMutations(ObjectType):
    create_question = CreateQuestion.Field()

schema = Schema(query=Query, mutation=MyMutations)

Mutation CreateQuestion needs arguments question_text and pub_date to create a Question. These arguments will be passed to the mutate function. That’s why you can see question_text and pub_date in function signature too. question is the output field of our mutation. So the created Question instance is returned once the mutation resolves.

Let’s create some questions:

In [7]: from bombardill.graphql import schema

In [8]: mutation = """
   ...: mutation {
   ...:     createQuestion(questionText: "Do you like rabbits?", pubDate: "2019-10-22") {
   ...:         question {
   ...:             questionText
   ...:             pubDate
   ...:         }
   ...:     }
   ...: }
   ...: """

In [9]: schema.execute(mutation).data
                                          'Do you like rabbits?'),
                                         ('pubDate', '2019-10-22')]))]))])

We sent a mutation and asked for questionText and pubDate fields of created question.

Let’s create one more question but only ask for questionText field once the mutation resolves.

In [10]: mutation = """
    ...: mutation {
    ...:     createQuestion(questionText: "Do you like hobbits?", pubDate: "2019-10-22") {
    ...:         question {
    ...:             questionText
    ...:         }
    ...:     }
    ...: }
    ...: """

In [11]: schema.execute(mutation).data
                                          'Do you like hobbits?')]))]))])

Create choice

Let’s similarly add one more Mutation called CreateChoice and it on MyMutations.

class CreateChoice(Mutation):
    class Arguments:
        question_id = Int()
        choice_text = String()

    choice = Field(ChoiceType)

    def mutate(root, info, question_id, choice_text):
        question = Question.objects.get(id=question_id)
        choice = Choice.objects.create(question=question, choice_text=choice_text)
        return CreateChoice(choice)

class MyMutations(ObjectType):
    create_question = CreateQuestion.Field()
    create_choice = CreateChoice.Field()

Let’s execute a query to create choice.

In [2]: from bombardill.graphql import schema

In [3]: mutation = """
   ...: mutation {
   ...:     createChoice(choiceText: "yes", questionId: 56) {
   ...:         choice {
   ...:             choiceText
   ...:         }
   ...:     }
   ...: }
   ...: """

In [4]: schema.execute(mutation).data
                            OrderedDict([('choiceText', 'yes')]))]))])

Similarly we can write mutations to update a question or delete a question.

Thank you for reading the Agiliq blog. This article was written by Akshar on Sep 14, 2019 in GraphQLAPIpythondjango .

You can subscribe ⚛ to our blog.

We love building amazing apps for web and mobile for our clients. If you are looking for development help, contact us today ✉.

Would you like to download 10+ free Django and Python books? Get them here