Django End-of-Life Dates —
Official EOL Schedule for Every Version
Django 4.2 LTS reached end of life on April 7, 2026 — six weeks ago. If you're running 4.2 in production, you are no longer receiving security patches from the Django project. Django 5.1 reached EOL even earlier, in December 2025. Between those two versions, a significant portion of the production Django ecosystem is now running unsupported software.
This page is the single reference for Django end-of-life dates across every version — with EOL Risk Scores™, Django's LTS vs standard release explained, the Python compatibility matrix, and a plain-English upgrade guide.
Complete Django EOL Schedule
Django releases a new feature version approximately every eight months. Each version receives active support for eight months, then moves to security-only support for another eight months — a total of 16 months per standard release. LTS releases receive three full years of support, making them the right choice for most production deployments.
| Version | Type | Released | End of Life | Status | EOL Risk Score™ |
|---|---|---|---|---|---|
| Django 3.2 | LTS | Apr 6, 2021 | Apr 1, 2024 | EOL | 89 |
| Django 4.0 | Standard | Dec 7, 2021 | Aug 1, 2023 | EOL | 92 |
| Django 4.1 | Standard | Aug 3, 2022 | Dec 1, 2023 | EOL | 91 |
| Django 4.2 | LTS | Apr 3, 2023 | Apr 7, 2026 | EOL | 76 |
| Django 5.0 | Standard | Dec 4, 2023 | Apr 1, 2025 | EOL | 83 |
| Django 5.1 | Standard | Aug 7, 2024 | Dec 3, 2025 | EOL | 78 |
| Django 5.2 | LTS | Apr 2, 2025 | Apr 30, 2028 | Supported | 18 |
| Django 6.0 | Standard | Dec 2025 | Apr 30, 2027 | Latest | 12 |
LTS vs Standard Releases — What It Means for EOL
Django's release model creates two very different support timelines, and choosing the wrong track is the most common reason teams end up on EOL software unexpectedly.
Standard releases — Django 4.0, 4.1, 5.0, 5.1, 6.0 — receive 16 months of support total. Eight months of active development, then eight months of security-only patches. They move fast. Django 5.1 shipped in August 2024 and was EOL by December 2025 — 16 months later. If you're not actively tracking the release calendar, a standard release can slip past EOL before you notice.
LTS releases — Django 3.2, 4.2, 5.2, and the upcoming 7.2 — receive three full years of support. Eight months active, then 28 months of security-only patches. These are the versions production deployments should anchor to. The LTS release is always the third feature release in a major series — the x.2 release.
Django 4.2 LTS — EOL April 7, 2026
Django 4.2 was the LTS release that replaced Django 3.2 LTS. It introduced async-capable class-based views, a new db_default field option for database-level defaults, improved psycopg3 support, and a stricter template engine that catches more errors at startup. It became the dominant production Django version for the 2023–2026 period.
4.2 LTS officially supports Python 3.8 through 3.12 — which creates a compound EOL risk. Python 3.8 reached EOL in October 2024 and Python 3.9 reached EOL in October 2025. If your Django 4.2 deployment is running on Python 3.8 or 3.9, you have two layers of EOL exposure: the framework and the runtime.
The Django project has stopped issuing security advisories for 4.2. CVEs affecting 4.2 will be documented but not patched. The EOL Risk Score™ of 76 (Critical) will increase over time as the days-past-EOL factor grows.
Target version: Upgrade to Django 5.2 LTS — supported until April 2028. If you need more time, commercial extended support is available from specialist vendors for EOL Django versions including 4.2.
Django 5.1 — EOL December 3, 2025
Django 5.1 was a standard (non-LTS) release with a 16-month support window. It introduced LoginRequiredMiddleware, query set filtering improvements, and enhancements to async support. Released August 2024, it reached EOL December 3, 2025 — a short window that many teams didn't fully track.
If your team upgraded to 5.1 to access its features and hasn't moved to 5.2 or 6.0 yet, you've been running unsupported Django for over five months. Standard releases require active upgrade discipline — there's no long runway.
Target version: Upgrade to Django 5.2 LTS or 6.0. From 5.1, the path to 5.2 is straightforward with no major breaking changes.
Django 5.2 LTS — Supported Until April 2028
Django 5.2 is the current LTS release and the recommended upgrade target for teams coming from 4.2 or 5.1. It supports Python 3.10 through 3.13, bringing the supported Python versions fully into the current era. Support runs until April 30, 2028 — nearly two years of runway from today.
Notable additions in 5.2: composite primary keys, an improved {% include %} tag with variable resolution improvements, and enhanced ModelAdmin list display options. The upgrade from 4.2 requires attention to deprecated features removed in 5.x but is well-documented in the official release notes.
This is your target version if you're on 4.2 or 5.1. Stable, long-supported, and fully current.
Django 6.0 — Current Standard Release
Django 6.0 is the latest release and currently the most actively developed version. As a standard (non-LTS) release, it has a 16-month support window ending April 30, 2027. It's appropriate for teams that want access to the latest features and are committed to staying current with Django's release cadence.
For most production deployments, Django 5.2 LTS is the better choice — it has a longer support window and the ecosystem of third-party packages has had more time to fully support it.
Python Compatibility Matrix
Django and Python have intertwined EOL timelines. Running Django on an EOL Python version compounds your security exposure — you're getting two layers of unpatched CVE risk. This matrix shows which Python versions are supported by each Django version.
| Django Version | Python 3.8 EOL Oct 2024 |
Python 3.9 EOL Oct 2025 |
Python 3.10 | Python 3.11 | Python 3.12 | Python 3.13 |
|---|---|---|---|---|---|---|
| Django 4.2 LTS (EOL) | ✓ | ✓ | ✓ | ✓ | ✓ | — |
| Django 5.0 (EOL) | — | — | ✓ | ✓ | ✓ | — |
| Django 5.1 (EOL) | — | — | ✓ | ✓ | ✓ | ✓ |
| Django 5.2 LTS ✓ | — | — | ✓ | ✓ | ✓ | ✓ |
| Django 6.0 ✓ | — | — | — | ✓ | ✓ | ✓ |
python --version and cross-reference against the Python EOL guide.
How to Upgrade Safely
-
01Check your current version Run
python -m django --versionor check yourrequirements.txt/pyproject.toml. Also check your Python version withpython --version— you may need to upgrade Python alongside Django. -
02Read the release notes for every version between yours and the target Django maintains detailed release notes with explicit "deprecated features removed" sections. Going from 4.2 to 5.2 means reading the 5.0, 5.1, and 5.2 release notes. The Django project's notes are thorough — use them. Pay particular attention to removed features, changed default settings, and database migration behavior changes.
-
03Run Django's system checks After updating Django in your environment, run
python manage.py check --deploy. This surfaces deprecated API usage, security misconfigurations, and compatibility issues before they hit production. Address every warning before deploying. -
04Update third-party packages Your Django upgrade will often require updating
django-rest-framework,celery,django-allauth, and other ecosystem packages that declare Django version compatibility. Runpip list --outdatedand update packages that have dropped support for your current Django version. -
05Run your full test suite before and after Django upgrades are usually smooth but behavioral changes in the ORM, template engine, or middleware can surface in tests that wouldn't catch them in manual testing. If you don't have a test suite, this upgrade is the forcing function to start one.
-
06Upgrade Python if needed Django 5.2 LTS requires Python 3.10+. If you're on Python 3.8 or 3.9, you need to upgrade Python first. The safest sequence: upgrade Python to 3.12, validate your app, then upgrade Django to 5.2. Doing both simultaneously increases the blast radius if something breaks.
-
07Consider extended support if you need more time If your 4.2 migration will take longer than a few sprints, commercial extended support from specialist vendors provides continued security patches for EOL Django versions including 3.2, 4.0, 4.2, 5.0, and 5.1. This buys documented, auditable coverage while your migration is in progress.
Check your full Python stack for EOL exposure
Django is one layer. Check your Python runtime, OS, and other dependencies too — free, no signup required.
Scan your stack Check a version Risk Score methodology