CREAR APIS WEB CON DJANGO REST FRAMEWORK EN 2026

January 20, 2026

Introducción a la creación de APIs modernas con Django

La construcción de APIs web robustas se ha convertido en una habilidad esencial para desarrolladores backend en el ecosistema actual de microservicios y aplicaciones móviles. Django REST Framework ofrece herramientas potentes que facilitan la creación de interfaces programables seguras, escalables y bien documentadas. Este tutorial detalla el proceso completo desde la configuración inicial hasta la implementación de funcionalidades avanzadas, utilizando las versiones más recientes disponibles en enero de 2026: Django 6.0.1 como framework base y Django REST Framework en su serie 3.16 o superior para compatibilidad óptima.

El enfoque se centra en un proyecto práctico que gestiona una lista de tareas, permitiendo operaciones CRUD completas junto con características profesionales como autenticación, permisos y paginación. Cada paso incluye ejemplos claros que demuestran la implementación real.

Comienza creando un entorno virtual y un proyecto nuevo. Instala las dependencias principales para garantizar compatibilidad con Python 3.12 o superior.

python -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate
pip install django==6.0.1 djangorestframework
django-admin startproject todoproject
cd todoproject
python manage.py startapp tasks

Actualiza el archivo settings.py para registrar las aplicaciones necesarias.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'tasks',
]

Configura la base de datos predeterminada (SQLite para desarrollo) y establece el idioma y zona horaria según preferencias locales.

LANGUAGE_CODE = 'es'
TIME_ZONE = 'America/Chicago'
USE_I18N = True
USE_TZ = True

Ejecuta las migraciones iniciales para preparar el entorno.

python manage.py makemigrations
python manage.py migrate

Definición de modelos para la aplicación de tareas

Los modelos representan la estructura de datos principal. Crea un modelo sencillo Task con campos relevantes para una aplicación de gestión de tareas.

En tasks/models.py:

from django.db import models
from django.contrib.auth.models import User

class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField(blank=True)
    completed = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    owner = models.ForeignKey(User, on_delete=models.CASCADE, related_name='tasks')

    def __str__(self):
        return self.title

    class Meta:
        ordering = ['-created_at']

El campo owner vincula cada tarea a un usuario, permitiendo filtrado por propietario más adelante. Genera y aplica las migraciones.

python manage.py makemigrations tasks
python manage.py migrate

Configuración de serializadores en Django REST Framework

Los serializadores convierten instancias de modelos a formatos como JSON y viceversa. Crea un serializador básico para el modelo Task.

En tasks/serializers.py:

from rest_framework import serializers
from .models import Task

class TaskSerializer(serializers.ModelSerializer):
    class Meta:
        model = Task
        fields = ['id', 'title', 'description', 'completed', 'created_at', 'updated_at', 'owner']
        read_only_fields = ['owner', 'created_at', 'updated_at']

El atributo read_only_fields evita que el cliente modifique campos controlados por el servidor. Para mayor control, puedes definir campos explícitamente.

class TaskSerializer(serializers.ModelSerializer):
    owner = serializers.ReadOnlyField(source='owner.username')

    class Meta:
        model = Task
        fields = ['id', 'title', 'description', 'completed', 'created_at', 'updated_at', 'owner']

Esta versión muestra el nombre de usuario en lugar del ID, mejorando la legibilidad de las respuestas.

Implementación de vistas basadas en clases

Las vistas APIView ofrecen flexibilidad máxima. Crea una vista para listar y crear tareas.

En tasks/views.py:

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import Task
from .serializers import TaskSerializer

class TaskList(APIView):
    def get(self, request):
        tasks = Task.objects.filter(owner=request.user)
        serializer = TaskSerializer(tasks, many=True)
        return Response(serializer.data)

    def post(self, request):
        serializer = TaskSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save(owner=request.user)
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Asocia la vista en urls.py de la aplicación.

from django.urls import path
from .views import TaskList

urlpatterns = [
    path('tasks/', TaskList.as_view(), name='task-list'),
]

Incluye las urls de la app en el proyecto principal.

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('tasks.urls')),
]

Uso de vistas genéricas para mayor eficiencia

Las vistas genéricas reducen código repetitivo. Importa las clases necesarias.

from rest_framework import generics
from .models import Task
from .serializers import TaskSerializer

Define vistas para lista y detalle.

class TaskListCreate(generics.ListCreateAPIView):
    serializer_class = TaskSerializer

    def get_queryset(self):
        return Task.objects.filter(owner=self.request.user)

    def perform_create(self, serializer):
        serializer.save(owner=self.request.user)


class TaskDetail(generics.RetrieveUpdateDestroyAPIView):
    serializer_class = TaskSerializer
    lookup_field = 'pk'

    def get_queryset(self):
        return Task.objects.filter(owner=self.request.user)

Actualiza las urls.

urlpatterns = [
    path('tasks/', TaskListCreate.as_view(), name='task-list-create'),
    path('tasks/<int:pk>/', TaskDetail.as_view(), name='task-detail'),
]

Configuración avanzada con viewsets y routers

Los ViewSet combinan operaciones CRUD en una sola clase. Usa ModelViewSet para máxima automatización.

from rest_framework import viewsets

class TaskViewSet(viewsets.ModelViewSet):
    serializer_class = TaskSerializer

    def get_queryset(self):
        return Task.objects.filter(owner=self.request.user)

    def perform_create(self, serializer):
        serializer.save(owner=self.request.user)

Configura el router para generar urls automáticamente.

from rest_framework.routers import DefaultRouter
from .views import TaskViewSet

router = DefaultRouter()
router.register(r'tasks', TaskViewSet)

urlpatterns = router.urls

Incluye en el proyecto principal.

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('tasks.urls')),
]

Esta aproximación genera endpoints como /api/tasks/ y /api/tasks/1/ automáticamente.

Autenticación y permisos para proteger la API

La autenticación básica es útil para pruebas, pero en producción se prefieren tokens. Configura en settings.py.

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.BasicAuthentication',
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.TokenAuthentication',
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ]
}

Instala tokens.

pip install djangorestframework-simplejwt

Agrega a INSTALLED_APPS ‘rest_framework.authtoken’ y configura SimpleJWT si deseas JWT.

Para permisos personalizados, crea una clase.

from rest_framework import permissions

class IsOwnerOrReadOnly(permissions.BasePermission):
    def has_object_permission(self, request, view, obj):
        if request.method in permissions.SAFE_METHODS:
            return True
        return obj.owner == request.user

Aplica en el ViewSet.

permission_classes = [permissions.IsAuthenticated, IsOwnerOrReadOnly]

Paginación y filtrado para APIs escalables

Configura paginación global.

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

Para filtrado, agrega django-filter.

pip install django-filter

Registra ‘django_filters’ en INSTALLED_APPS y configura.

REST_FRAMEWORK = {
    'DEFAULT_FILTER_BACKENDS': ['django_filters.rest_framework.DjangoFilterBackend']
}

En el ViewSet:

filterset_fields = ['completed', 'title']

Los clientes pueden filtrar con ?completed=true&title=trabajo

Pruebas y documentación automática

Usa el navegador de APIs integrado. Agrega urls para obtener tokens.

Crea superusuario y prueba endpoints.

python manage.py createsuperuser

Visita http://127.0.0.1:8000/api/tasks/ después de iniciar el servidor.

python manage.py runserver

La interfaz HTML permite interactuar directamente con la API.

Conclusiones

La implementación de APIs con Django REST Framework proporciona una base sólida para aplicaciones modernas. Desde modelos simples hasta viewsets con routers, autenticación segura y paginación, el framework cubre necesidades reales de producción. Las prácticas mostradas aseguran código mantenible y escalable. Continúa explorando características avanzadas como throttling, versioning y documentación con drf-spectacular para proyectos más complejos. Con estas herramientas, los desarrolladores pueden entregar servicios web eficientes que integran fácilmente con frontend y aplicaciones móviles en entornos actuales de 2026.