🌐 Cómo crear servidor HTTP con Python: 2 métodos

Crear servidor HTTP con Python es una de las formas más sencillas de comenzar a entender cómo funciona realmente una aplicación web.

En este tutorial vamos a levantar nuestro propio servidor utilizando dos métodos diferentes. Primero utilizaremos http.server, una herramienta incluida con Python que resulta perfecta para servir HTML, CSS, JavaScript e imágenes. Una vez que entendamos cómo funciona nuestro servidor HTTP local, daremos el salto a Flask, donde Python comienza a formar parte de la lógica de la aplicación.

También veremos algo que muchas veces queda fuera de los tutoriales básicos: qué carpeta está sirviendo Python, por qué puede aparecer un listado de directorios, qué significan respuestas como 200 y 404, cómo observar las peticiones desde el navegador y qué diferencia existe entre trabajar en localhost, nuestra red local e Internet.

La idea no es aprender una colección de comandos de memoria. Queremos entender qué sucede cuando el navegador solicita una página y en qué momento una carpeta con HTML, CSS y JavaScript comienza a convertirse en una aplicación web.

🌐 ¿Qué es un servidor HTTP?

Antes de escribir código debemos entender qué estamos construyendo.

Un servidor HTTP es un programa capaz de recibir peticiones realizadas mediante HTTP y devolver una respuesta.

Cuando escribes la dirección de una página en el navegador, el navegador actúa como cliente. Solicita un recurso y espera que algún servidor responda.

El servidor puede devolver un documento HTML, una imagen, un archivo CSS, JavaScript, JSON o incluso contenido generado en ese mismo momento mediante un lenguaje como Python.

Podemos reducir el proceso a una conversación bastante sencilla:

NAVEGADOR
    |
    | Petición HTTP
    v
SERVIDOR
    |
    | Respuesta HTTP
    v
HTML / CSS / JS / DATOS

En una página real esta conversación ocurre muchas veces.

El navegador puede solicitar primero index.html y, después de leerlo, descubrir que también necesita una hoja CSS, archivos JavaScript, imágenes o fuentes.

Cada uno de esos recursos puede generar una nueva petición.

Por eso levantar un pequeño servidor HTTP resulta bastante más interesante que abrir nuestro archivo HTML mediante doble clic: comenzamos a trabajar de una manera mucho más parecida a como funciona una web real.

Durante el desarrollo ni siquiera necesitamos tener un servidor contratado. Nuestra propia computadora puede cumplir ese papel.

Si quieres profundizar en este concepto, MDN mantiene una excelente introducción al protocolo HTTP.

🏠 Localhost, 127.0.0.1 y puertos

Cuando desarrollamos una aplicación web no necesitamos publicar cada cambio en Internet.

Podemos ejecutar el servidor en nuestra propia computadora y acceder a él utilizando:

localhost
127.0.0.1

En este contexto, ambos nos permiten comunicarnos con servicios que se ejecutan en nuestra propia máquina.

Esto nos da un pequeño laboratorio privado: escribimos código, iniciamos el servidor, abrimos el navegador y comprobamos inmediatamente el resultado.

Pero todavía nos falta una pieza: el puerto.

Una computadora puede ejecutar muchos servicios al mismo tiempo. Los puertos permiten identificar con cuál queremos comunicarnos.

Por ejemplo:

127.0.0.1:8000
127.0.0.1:5000
127.0.0.1:8080

Podemos imaginar la dirección IP como la dirección de un edificio y el puerto como una de sus puertas.

En este tutorial utilizaremos principalmente el puerto 8000 para http.server y posteriormente el 5000 para Flask.

🚀 Crear un servidor HTTP con Python usando http.server

Vamos a comenzar por el método más sencillo.

Python incorpora el módulo http.server, por lo que para esta primera prueba no necesitamos instalar Flask ni ninguna librería adicional.

Vamos a crear una pequeña página formada por HTML, CSS y JavaScript.

Nuestra carpeta tendrá esta estructura:

servidor-python/
├── index.html
├── css/
│   └── style.css
└── js/
    └── app.js

Podemos crear rápidamente la estructura en Linux:

# Crear las carpetas
mkdir -p servidor-python/css servidor-python/js

# Entrar en nuestro proyecto
cd servidor-python

# Crear los archivos
touch index.html css/style.css js/app.js

# Comprobar la estructura
find . -maxdepth 2 -type f

Ahora vamos a añadir contenido.

Nuestro index.html:

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>Servidor HTTP con Python</title>

    <link rel="stylesheet" href="css/style.css">
</head>

<body>

    <main class="contenedor">

        <span>PYTHONES.NET</span>

        <h1>¡Hola desde Python! 🐍</h1>

        <p>
            Nuestro servidor HTTP está funcionando.
        </p>

        <button id="probar">
            Probar JavaScript
        </button>

        <p id="resultado"></p>

    </main>

    <script src="js/app.js"></script>

</body>
</html>

Dentro de css/style.css:

body {
    margin: 0;
    min-height: 100vh;
    display: grid;
    place-items: center;
    background: #0a0a0a;
    color: #ffffff;
    font-family: Arial, sans-serif;
}

.contenedor {
    width: min(600px, 85%);
    padding: 40px;
    border: 1px solid #333333;
    border-radius: 12px;
    text-align: center;
}

.contenedor span {
    color: #5cff7a;
    font-weight: bold;
}

button {
    padding: 12px 18px;
    cursor: pointer;
}

Y dentro de js/app.js:

const boton = document.querySelector("#probar");
const resultado = document.querySelector("#resultado");

boton.addEventListener("click", () => {
    resultado.textContent =
        "JavaScript también fue servido correctamente 🚀";
});

Los tres archivos nos permitirán comprobar algo interesante: el navegador no solamente solicitará nuestro HTML. También realizará nuevas peticiones para descargar el CSS y JavaScript.

📁 ¿Desde qué carpeta debemos iniciar el servidor?

Esta parte es importante.

Cuando utilizamos el comando básico de http.server, Python sirve el contenido del directorio desde el que iniciamos el servidor.

Si tenemos:

servidor-python/          ← terminal aquí
│
├── index.html            ← página principal
│
├── css/
│   └── style.css
│
└── js/
    └── app.js

debemos estar dentro de servidor-python/:

cd servidor-python

y desde allí ejecutar:

python -m http.server 8000 --bind 127.0.0.1

Después abrimos:

http://localhost:8000

Python encontrará index.html y lo utilizará como página principal.

📂 ¿Por qué aparece «Directory listing for /»?

Si abrimos localhost:8000 y en lugar de nuestra página aparece un listado de archivos y carpetas, no significa necesariamente que el servidor esté roto.

De hecho, normalmente significa que el servidor sí está funcionando, pero estamos sirviendo otro directorio o no existe un archivo índice en la ubicación esperada.

Por ejemplo, si iniciamos http.server desde una carpeta que contiene:

Documentos/
├── proyectos/
├── imágenes/
└── notas/

Python puede mostrar ese directorio en el navegador.

Lo solucionamos entrando en la carpeta correcta:

cd servidor-python
python -m http.server 8000 --bind 127.0.0.1

También podemos evitar depender del directorio actual utilizando --directory:

python -m http.server 8000 --bind 127.0.0.1 --directory servidor-python

Con esta opción le indicamos explícitamente a Python qué carpeta queremos servir.

▶️ Iniciar nuestro servidor HTTP

Ahora que sabemos qué carpeta estamos sirviendo, podemos iniciar nuestra prueba.

Según nuestro sistema podemos utilizar:

# Linux / macOS / instalaciones habituales
python -m http.server 8000 --bind 127.0.0.1

# Algunas distribuciones utilizan python3
python3 -m http.server 8000 --bind 127.0.0.1

# En Windows también podemos encontrar el launcher py
py -m http.server 8000 --bind 127.0.0.1

# Abrir en el navegador:
# http://localhost:8000
# http://127.0.0.1:8000

# Para detener el servidor:
# CTRL + C

Si todo salió bien veremos nuestra página (en este caso inicié en el puerto 8001):

¡Perfecto!

Acabamos de crear un servidor HTTP con Python.

Nuestro navegador ya no está abriendo simplemente un archivo del disco. Está realizando una petición HTTP al puerto 8000 y Python está respondiendo.

Además, nuestro HTML está solicitando al servidor otros dos recursos: style.css y app.js.

🔎 Peticiones HTTP: GET, 200 y 404

Mira nuevamente la terminal después de actualizar la página.

Python puede mostrar líneas similares a:

127.0.0.1 - - "GET / HTTP/1.1" 200 -
127.0.0.1 - - "GET /css/style.css HTTP/1.1" 200 -
127.0.0.1 - - "GET /js/app.js HTTP/1.1" 200 -

Ahora podemos empezar a leer lo que está sucediendo.

GET / indica que el navegador está solicitando la página principal.

Después de recibir el HTML, encuentra:

css/style.css
js/app.js

y realiza dos peticiones adicionales.

El código 200 nos indica que el recurso solicitado fue encontrado y la petición pudo procesarse correctamente.

Durante nuestras pruebas también podemos encontrarnos con:

200 → El recurso fue encontrado y la petición salió bien.
404 → El recurso solicitado no fue encontrado.

Por ejemplo, si nuestro HTML intenta cargar:

<script src="js/no-existe.js"></script>

Python no encontrará ese archivo y podremos observar una respuesta 404.

Ahora esos códigos HTTP comienzan a tener mucho más sentido: estamos viendo directamente la conversación entre nuestro navegador y Python.

/             200
style.css     200
app.js        200

📂 Servir HTML, CSS, JavaScript y otros archivos

Nuestro ejemplo utiliza solamente tres archivos, pero http.server puede servir muchos tipos de recursos estáticos:

• HTML.
• CSS.
• JavaScript.
• Imágenes.
• JSON.
• Documentos.
• Fuentes.
• Otros archivos estáticos.

Por ejemplo:

mi-web/
├── index.html
├── contacto.html
├── css/
│   └── style.css
├── js/
│   └── app.js
└── img/
    └── python.png

Podemos entrar en mi-web/ y ejecutar el servidor allí:

cd mi-web
python -m http.server 8000 --bind 127.0.0.1

o indicarle directamente qué directorio queremos servir:

python -m http.server 8000 --bind 127.0.0.1 --directory mi-web

JavaScript seguirá ejecutándose normalmente en el navegador.

Podemos desarrollar una landing page con HTML, CSS y JavaScript, utilizar animaciones o consumir APIs desde el navegador y servir esos archivos mediante nuestro pequeño servidor.

Sin embargo, http.server no convierte automáticamente esas peticiones en lógica de aplicación escrita en Python.

Esa diferencia será importante cuando lleguemos a Flask.

Puedes revisar todas las opciones disponibles en la documentación oficial de http.server.

🌍 Abrir nuestro servidor desde otro dispositivo

Hasta ahora hemos utilizado:

python -m http.server 8000 --bind 127.0.0.1

Así limitamos el servidor a nuestra propia computadora.

Ahora podemos realizar otra prueba: abrir nuestra página desde el teléfono.

Si el teléfono y la computadora están conectados a la misma red, podemos permitir que Python escuche mediante las interfaces IPv4 disponibles.

En Linux:

# 1 - Iniciar el servidor para nuestra red local
python -m http.server 8000 --bind 0.0.0.0

# 2 - Consultar nuestra IP privada
hostname -I

# También podemos utilizar:
# ip addr

# Supongamos que obtenemos:
# 192.168.1.35

# 3 - Desde otro dispositivo de la misma red:
# http://192.168.1.35:8000

# 4 - Cuando terminemos:
# CTRL + C

Si nuestra red y firewall permiten la conexión, aparecerá la misma web en el teléfono.

Una dirección privada como 192.168.x.x normalmente no es accesible directamente desde Internet.

Entre un usuario externo y nuestra computadora existen otros componentes:

INTERNET
   |
   v
IP PÚBLICA
   |
   v
ROUTER / FIREWALL
   |
   v
RED LOCAL
   |
   v
SERVIDOR

Hacer llegar conexiones externas hasta nuestra computadora puede implicar NAT, redirección de puertos, firewall y nuestra IP pública.

No necesitamos convertir este tutorial en un curso de redes.

Lo importante es entender que compartir un servidor dentro de nuestra red local y publicar un servicio en Internet son cosas diferentes.

🔐 http.server no es un servidor de producción

Llegados a este punto ya conseguimos:

HTML + CSS + JavaScript
          |
          v
     http.server
          |
          v
       HTTP local
          |
          v
       Navegador

Incluso conseguimos acceder desde otro dispositivo.

Pero esto no significa que debamos abrir nuestro servidor directamente a Internet.

Para una página estática pública normalmente utilizaremos un alojamiento preparado para contenido web.

Y si necesitamos que Python procese información, usuarios, formularios o bases de datos, ya estamos entrando en otro terreno.

Ahí comienza a tener sentido Flask.

⚔️ http.server vs Flask: ¿cuándo necesitamos algo más?

Hasta ahora conseguimos servir una web completa con HTML, CSS y JavaScript.

Pero todavía no tenemos necesariamente una aplicación web escrita en Python.

Una aplicación puede necesitar:

• Procesar formularios.
• Ejecutar lógica de negocio.
• Crear usuarios.
• Mantener sesiones.
• Consultar bases de datos.
• Generar HTML dinámicamente.
• Crear una API.
• Validar información.
• Definir diferentes rutas y comportamientos.

Con http.server, Python nos permitió entregar archivos.

Con Flask podemos decidir mediante Python qué debe suceder cuando llega una petición.

En pocas palabras: utiliza http.server cuando necesites servir archivos rápidamente y Flask cuando Python deba participar en la lógica de la aplicación.

🌶️ Crear un servidor web con Python y Flask

Ahora sí podemos dar el siguiente paso.

Flask es un framework web para Python que nos permite asociar URLs con funciones y comenzar a desarrollar aplicaciones.

Creamos otro proyecto:

# 1 - Crear nuestro proyecto
mkdir servidor-flask
cd servidor-flask

# 2 - Crear un entorno virtual
python -m venv venv

# 3 - Activarlo en Linux / macOS
source venv/bin/activate

# Windows CMD:
# venv\Scripts\activate.bat

# Windows PowerShell:
# .\venv\Scripts\Activate.ps1

# 4 - Instalar Flask
python -m pip install flask

¿Por qué utilizamos un entorno virtual?

Porque nuestro proyecto puede instalar Flask y otras librerías sin mezclar innecesariamente sus dependencias con las de otros proyectos Python.

Ahora creamos:

app.py

y escribimos:

from flask import Flask

app = Flask(__name__)


@app.route("/")
def inicio():
    return "<h1>Mi servidor Flask funciona 🐍</h1>"


if __name__ == "__main__":
    app.run(
        host="127.0.0.1",
        port=5000,
        debug=True
    )

Ejecutamos:

python app.py

# Abrir:
# http://127.0.0.1:5000

Ahora ocurre algo diferente.

Cuando visitamos /, Flask busca qué función está asociada con esa ruta, ejecuta nuestro código Python y utiliza el resultado para construir la respuesta HTTP.

Ya no estamos limitándonos a entregar un archivo existente.

Python está decidiendo qué respuesta recibe el navegador.

Puedes ampliar esta parte en la documentación oficial de Flask.

🛣️ Rutas, Python y arquitectura MVC

Una de las primeras cosas que podemos hacer con Flask es crear diferentes rutas.

Por ejemplo:

from flask import Flask

app = Flask(__name__)


@app.route("/")
def inicio():
    return "<h1>Inicio</h1>"


@app.route("/contacto")
def contacto():
    return "<h1>Contacto</h1>"


@app.route("/acerca")
def acerca():
    return "<h1>Acerca de nosotros</h1>"


if __name__ == "__main__":
    app.run(
        host="127.0.0.1",
        port=5000,
        debug=True
    )

Ahora nuestra aplicación entiende tres direcciones:

Esta diferencia es importante.

No necesitamos necesariamente un archivo físico llamado contacto.html para que exista /contacto.

Flask recibe la petición, encuentra la función correspondiente y ejecuta nuestro código.

A medida que el proyecto crece podemos comenzar a separar responsabilidades:

mi-aplicacion/
│
├── app.py
│
├── templates/
│   ├── index.html
│   └── contacto.html
│
├── static/
│   ├── css/
│   ├── js/
│   └── img/
│
└── models/
    └── datos.py

Aquí los conceptos que aprendemos en Python comienzan a conectarse con el desarrollo web.

Podemos utilizar clases, funciones, módulos, objetos, librerías y bases de datos dentro de una aplicación que responde a usuarios mediante HTTP.

También podemos comenzar a aplicar una organización inspirada en MVC: Modelo, Vista y Controlador.

Flask no obliga a utilizar MVC, pero podemos estructurar nuestros proyectos siguiendo principios similares.

En Pythones tenemos un tutorial de Flask desde cero para continuar desarrollando estos conceptos.

🧠 Errores comunes y preguntas frecuentes

¿Python puede funcionar como servidor web?

Sí. Python incluye herramientas como http.server y dispone de frameworks como Flask para desarrollar aplicaciones web mucho más completas.

¿Cuál es la forma más rápida de crear un servidor HTTP con Python?

Desde la carpeta de nuestro proyecto:

python -m http.server 8000 --bind 127.0.0.1

Después entramos en http://localhost:8000.

¿Por qué aparece Directory listing for /?

Porque Python está sirviendo un directorio pero no encontró un archivo índice que pueda utilizar como página principal, o iniciamos el servidor desde una carpeta diferente a la que pensábamos.

¿Puedo servir otra carpeta sin entrar en ella?

Sí:

python -m http.server 8000 --bind 127.0.0.1 --directory servidor-python

¿Puedo abrir la página desde mi teléfono?

Sí. Si ambos dispositivos están en una red que permite la comunicación entre ellos, podemos escuchar mediante 0.0.0.0 y utilizar la IP privada de nuestra computadora.

¿Puedo hacer público http.server?

Técnicamente un servicio puede configurarse para aceptar conexiones externas, pero http.server no está recomendado como servidor de producción. Para publicar un proyecto debemos utilizar una solución apropiada.

¿Necesito XAMPP para Flask?

No. Flask dispone de su propio servidor de desarrollo. Si posteriormente nuestra aplicación necesita MySQL, MariaDB u otro sistema de base de datos, podemos incorporarlo según las necesidades del proyecto.

¿Cuál debería aprender primero?

Si estás comenzando, prueba primero http.server. Entiende qué carpeta estás sirviendo, qué es una petición HTTP, un puerto y localhost.

Después Flask tendrá muchísimo más sentido.

🏁 Conclusión: de http.server a Flask

Comenzamos con una carpeta que contenía HTML, CSS y JavaScript.

Aprendimos que no alcanza con ejecutar un comando al azar: debemos saber qué directorio está sirviendo Python.

Vimos qué ocurre cuando falta index.html, cómo interpretar el listado de directorios y cómo indicar explícitamente otra carpeta mediante --directory.

Después observamos peticiones reales para:

/
css/style.css
js/app.js

y comenzamos a entender respuestas como 200 y 404.

Incluso convertimos nuestro teléfono en otro cliente de la red.

Solo después de comprender ese recorrido dimos el salto a Flask.

Ahí Python dejó de limitarse a entregar archivos y comenzó a ejecutar funciones en respuesta a diferentes rutas.

No hace falta aprender servidores, Flask, MVC, bases de datos y deployment durante el mismo fin de semana.

Primero consigue que tu servidor funcione.

Rompe algo.

Cambia el puerto.

Añade CSS.

Prueba JavaScript.

Mira qué sucede en Network.

Ábrelo desde el teléfono.

Después crea tu primera ruta con Flask.

Cuando esos conceptos comienzan a conectarse, dejamos de memorizar comandos y empezamos a comprender cómo funciona realmente una aplicación web.

📚 Fuentes y recursos recomendados

No necesitas leer toda la documentación de una sola vez. Guarda estos enlaces como referencia y vuelve a ellos cuando aparezca una duda concreta durante tus proyectos.

🐍 Python — http.server
Referencia oficial del módulo utilizado en este tutorial, incluyendo opciones como --bind y --directory.
Documentación oficial de http.server →

🌐 MDN — HTTP
Referencia para comprender peticiones, respuestas, métodos, cabeceras y códigos de estado.
Aprender HTTP en MDN →

🔄 MDN — Cliente y servidor
Útil para comprender qué código se ejecuta en el navegador y cuál se ejecuta en el servidor.
Modelo cliente-servidor →

📦 Python — entornos virtuales
Los entornos virtuales se convertirán en una herramienta habitual cuando comiences a trabajar con Flask y otras librerías.
Entornos virtuales y paquetes →

🌶️ Flask
Documentación oficial del framework utilizado en la segunda parte del tutorial.
Documentación oficial de Flask →

🚀 Flask — Deployment
Una referencia para cuando nuestras aplicaciones dejen de ser pruebas locales y queramos comenzar a estudiar producción.
Desplegar aplicaciones Flask →

📅 Última actualización: octubre 18, 2026