A Django KeyError on request.POST['field_name'] means the form data dictionary does not contain the key you tried to read. The most common causes in 2026 are missing form fields in the template, missing CSRF token, and AJAX requests sent with the wrong content type.
The minimal reproducer
# views.py
def my_view(request):
username = request.POST['username'] # KeyError: 'username'
return HttpResponse(f"Hello, {username}")
The view crashes if the submitted form did not include a name="username" input field. Django raises KeyError at the bracket access, not a friendly form validation error.
Fix 1: Use .get() with a default value
# Safe access
username = request.POST.get('username', '')
if not username:
return HttpResponse("Username is required", status=400)
This is the simplest fix and works for any optional form field. The .get() method returns the default value (or None if no default) when the key is missing, instead of raising KeyError.
Fix 2: Use Django Forms for proper validation
# forms.py
from django import forms
class LoginForm(forms.Form):
username = forms.CharField(max_length=150)
password = forms.CharField(widget=forms.PasswordInput)
# views.py
def my_view(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
return HttpResponse(f"Hello, {username}")
return render(request, 'login.html', {'form': form})
Django Forms validate the entire form, return user-friendly error messages, and protect against missing or invalid fields automatically. Use this for any form with more than 2-3 fields.
Fix 3: Check your template for missing inputs and CSRF
<!-- template.html -->
<form method="post">
{% csrf_token %} <!-- REQUIRED for Django POST -->
<input type="text" name="username" required>
<input type="password" name="password" required>
<button type="submit">Login</button>
</form>
If your template is missing the name="username" attribute, the input never reaches request.POST. The {% csrf_token %} tag is also required, without it Django rejects the POST entirely with a 403 before your view runs.
When the request is AJAX
If you submit a form via JavaScript fetch() or jQuery.ajax(), you must set the correct Content-Type. Django parses JSON bodies differently from form-encoded bodies:
# JavaScript front-end
fetch('/api/login/', {
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'X-CSRFToken': getCsrfToken()
},
body: 'username=alice&password=secret'
})
# OR for JSON requests, parse in the view:
import json
def my_view(request):
if request.content_type == 'application/json':
data = json.loads(request.body)
username = data.get('username', '')
Quick reference
| Scenario | Use |
|---|---|
| Single optional field | request.POST.get(‘field’, ”) |
| Multi-field form, validation | forms.Form + form.is_valid() |
| Model-bound form | forms.ModelForm |
| JSON API endpoint | json.loads(request.body) |
| REST framework | DRF Serializer.is_valid() |
Frequently Asked Questions
Why does Django raise KeyError instead of a 400 Bad Request?
Django’s request.POST is a QueryDict, which behaves like a regular dict when you use bracket access. Bracket access on a missing key raises KeyError. To get a friendly 400 response, use Django Forms or DRF Serializers, which handle missing fields with validation errors instead of raising.
What is the difference between request.POST and request.GET?
request.POST contains form data sent via HTTP POST method (typically from a form submission). request.GET contains query string parameters from the URL (after the ? mark). Both are QueryDict objects and both raise KeyError on missing keys. Use .get() for safe access on either.
Why is request.POST empty when I submit from JavaScript fetch?
Most likely you sent JSON without the right Content-Type. Django only fills request.POST when the request body is form-encoded (application/x-www-form-urlencoded or multipart/form-data). For JSON bodies, parse manually with json.loads(request.body) or use Django REST Framework.
Do I need {% csrf_token %} for every Django form?
Yes for any POST form, unless you explicitly mark the view with @csrf_exempt (not recommended for security). Without the CSRF token, Django returns a 403 before your view runs, so you may see this as a 403 page rather than a KeyError. AJAX requests must include the X-CSRFToken header.
When should I use Django Forms vs request.POST.get?
Use request.POST.get() for very simple endpoints with 1-2 optional fields. Use Django Forms for anything with validation rules, multiple fields, or model integration. Forms also handle error rendering, file uploads, and ModelForm save() in one line, which is a big productivity win.