Validation allows you to ensure that the data being submitted by the user is appropriate for storage. This can range from simple type checking on up to complex validation that compares different fields together.

If the data is valid, an empty dictionary is returned and processing continues as normal. If the data is invalid, a dictionary of error messages (keys being the field names, values being a list of error messages) is immediately returned to the user, serialized in the format they requested.


Using these classes is simple. Simply provide them (or your own class) as a Meta option to the Resource in question. For example:

from django.contrib.auth.models import User
from tastypie.validation import Validation
from tastypie.resources import ModelResource

class UserResource(ModelResource):
    class Meta:
        queryset = User.objects.all()
        resource_name = 'auth/user'
        excludes = ['email', 'password', 'is_superuser']
        # Add it here.
        validation = Validation()

Validation Options

Tastypie ships with the following Validation classes:


The no-op validation option, the data submitted is always considered to be valid.

This is the default class hooked up to Resource/ModelResource.


A more complex form of validation, this class accepts a form_class argument to its constructor. You supply a Django Form (or ModelForm, though save will never get called) and Tastypie will verify the data in the Bundle against the form.

This class DOES NOT alter the data sent, only verifies it. If you want to alter the data, please use the CleanedDataFormValidation class instead.


Data in the bundle must line up with the fieldnames in the Form. If they do not, you’ll need to either munge the data or change your form.

Usage looks like:

from django import forms

class NoteForm(forms.Form):
    title = forms.CharField(max_length=100)
    slug = forms.CharField(max_length=50)
    content = forms.CharField(required=False, widget=forms.Textarea)
    is_active = forms.BooleanField()

form = FormValidation(form_class=NoteForm)


Similar to the FormValidation class, this uses a Django Form to handle validation. However, it will use the form.cleaned_data to replace the bundle data sent by user! Usage is identical to FormValidation.

Implementing Your Own Validation

Implementing your own Validation classes is a simple process. The constructor can take whatever **kwargs it needs (if any). The only other method to implement is the is_valid method:

from tastypie.validation import Validation

class AwesomeValidation(Validation):
    def is_valid(self, bundle, request=None):
        if not
            return {'__all__': 'Not quite what I had in mind.'}

        errors = {}

        for key, value in
            if not isinstance(value, basestring):

            if not 'awesome' in value:
                errors[key] = ['NOT ENOUGH AWESOME. NEEDS MORE.']

        return errors

Under this validation, every field that’s a string is checked for the word ‘awesome’. If it’s not in the string, it’s an error.