REST vs GraphQL: Guía de decisión
Dos formas de construir APIs, cada una con sus ventajas. Esta guía te da criterios claros para elegir en tu próximo proyecto.
REST: Lo que ya conoces
GET /api/users/123 → Un usuario
GET /api/users/123/posts → Posts del usuario
GET /api/posts/456/comments → Comentarios del post
Problema: 3 requests para mostrar un perfil con posts y comentarios (over-fetching + under-fetching).
GraphQL: Pide exactamente lo que necesitas
query {
user(id: 123) {
name
email
posts(limit: 5) {
title
createdAt
comments(limit: 3) {
content
author { name }
}
}
}
}
Un solo request, solo los campos que necesitas. Nada más, nada menos.
Comparativa detallada
| Aspecto | REST | GraphQL |
|---|
| Endpoints | Múltiples (/users, /posts, etc.) | Uno solo (/graphql) |
| Over-fetching | Común (recibes campos que no usas) | No existe (pides solo lo que necesitas) |
| Under-fetching | Común (necesitas múltiples requests) | No existe (anidas relaciones) |
| Caching | HTTP nativo (CDN, browser, ETags) | Requiere librerías (Apollo) |
| Versionado | /api/v1/, /api/v2/ | No necesario (deprecas campos) |
| Upload de archivos | Nativo (multipart/form-data) | Complejo (spec separada) |
| Documentación | OpenAPI/Swagger | Introspection + Playground |
| Curva de aprendizaje | Baja | Media-alta |
Ejemplo en Python: REST (FastAPI)
from fastapi import FastAPI
app = FastAPI()
@app.get("/api/users/{user_id}")
async def get_user(user_id: int):
user = await User.get(user_id)
return {"id": user.id, "name": user.name, "email": user.email}
@app.get("/api/users/{user_id}/posts")
async def get_user_posts(user_id: int, limit: int = 10):
posts = await Post.filter(author_id=user_id).limit(limit)
return posts
Ejemplo en Python: GraphQL (Strawberry)
import strawberry
from strawberry.fastapi import GraphQLRouter
@strawberry.type
class UserType:
id: int
name: str
email: str
@strawberry.field
async def posts(self, limit: int = 10) -> list["PostType"]:
return await Post.filter(author_id=self.id).limit(limit)
@strawberry.type
class Query:
@strawberry.field
async def user(self, id: int) -> UserType:
return await User.get(id)
schema = strawberry.Schema(query=Query)
graphql_app = GraphQLRouter(schema)
Cuándo usar REST
- APIs públicas (más estandarizado, más herramientas)
- CRUD simple sin relaciones profundas
- Necesitas HTTP caching (CDN, browser cache)
- Microservicios internos
- Tu equipo ya domina REST
Cuándo usar GraphQL
- Frontend con datos anidados y complejos
- Múltiples clientes (web, mobile, TV) con necesidades diferentes
- Over-fetching/under-fetching es un problema real y medido
- Equipos frontend y backend trabajan a velocidades diferentes
La respuesta pragmática
Para el 90% de los proyectos, REST es suficiente y más simple. Usa GraphQL cuando el frontend genuinamente lo necesite por la complejidad de los datos, no porque esté de moda.
