🔐 Python Nivel 3 – Parte 5: Consumo de APIs con Autenticación (Tokens, Headers)

 

🎯 ¿Qué aprenderás?

✅ Cómo consumir APIs que requieren autenticación
✅ Diferencias entre APIs con tokens, headers o claves API
✅ Uso de tokens tipo JWT
✅ Ejemplo real con la API de CoinCap
✅ Cómo automatizar consultas autenticadas

---

🌍 API real: CoinCap (criptomonedas)

🔗 Documentación: https://docs.coincap.io/

Esta API ofrece cotizaciones de criptomonedas. Algunas rutas requieren autenticación con API Key vía encabezado.

---

📦 Paso 1: Instala requests

pip install requests

---

🔐 Paso 2: Crea una cuenta y consigue tu API KEY

1. Ve a https://coincap.io/

2. Crea cuenta gratuita

3. Copia tu clave API

---

📄 Paso 3: Realiza consulta autenticada

import requests

# Tu API Key Pro
API_KEY = "TU_API_KEY"
# URL de CoinCap Pro v3
url = f"https://rest.coincap.io/v3/assets/bitcoin?apiKey={API_KEY}"

try:
    respuesta = requests.get(url)

    if respuesta.status_code == 200:
        datos = respuesta.json()
        # La estructura cambia en v3: datos dentro de "data"
        precio = float(datos['data']['priceUsd'])
        print(f"El precio actual de Bitcoin es: ${precio:.2f}")
    else:
        print("Error al obtener los datos de Bitcoin")
        print(f"Código de estado: {respuesta.status_code}")
        print(f"Mensaje de error: {respuesta.text}")

except Exception as e:
    print("❌ Error de conexión:", e)

---

🔁 Automatizar la consulta

Puedes ejecutar el script cada hora o guardar el valor en un .txt para seguimiento:

import time

while True:
    r = requests.get(url, headers=headers)
    if r.ok:
        precio = r.json()["data"]["priceUsd"]
        print(f"[Auto] BTC: ${float(precio):,.2f}")
    time.sleep(3600)  # cada hora

---

✅ ¿Y si la API usa JWT?

• Algunas APIs envían un token JWT al hacer POST con usuario/clave.

• Lo guardas y lo reutilizas en headers como:
  "Authorization": "Bearer TOKEN_JWT"

🔐 Recomendación: Usa variables de entorno o ficheros .env para guardar tus claves, no las pongas directo en el código.

---

🧠 Aplicaciones reales

✔️ Dashboards de precios en tiempo real
✔️ Integración con bots (Telegram, Discord, etc.)
✔️ Automatización de alertas económicas
✔️ Automatización de reportes o backups usando datos externos

---

📂 Código completo en GitHub:
github.com/josecodetech

🎥 Guía paso a paso en YouTube:
[Tu canal aquí]

👉 Autenticación de APIs en Flask con JWT (JSON Web Tokens)

Después de implementar autenticación con sesiones en Flask, es momento de aprender una alternativa moderna y escalable: JWT (JSON Web Tokens). Ideal para APIs RESTful.

En este post aprenderás:
✔️ Qué es JWT y para qué se usa
✔️ Cómo generar y verificar tokens en Flask
✔️ Proteger rutas con decoradores
✔️ Ejemplo práctico paso a paso

📌 JWT es ampliamente usado en APIs modernas por su seguridad y portabilidad.

---

1️⃣ ¿Qué es JWT?

JWT (JSON Web Token) es un estándar para transmitir información de forma segura entre dos partes.

📌 Se compone de 3 partes codificadas en base64:

• Header (tipo y algoritmo)

• Payload (datos del usuario)

• Signature (clave secreta)

✅ Es útil para autenticar usuarios sin necesidad de sesiones.

---

2️⃣ Instalar dependencias

pip install flask flask_sqlalchemy pyjwt

También usaremos werkzeug.security para manejar contraseñas:

from werkzeug.security import generate_password_hash, check_password_hash

---

3️⃣ Generar el token JWT al iniciar sesión

import jwt
from datetime import datetime, timedelta
from flask import Flask, request, jsonify

app = Flask(__name__)
app.config["SECRET_KEY"] = "clave_super_segura"

def generar_token(usuario_id):
    payload = {
        "usuario_id": usuario_id,
        "exp": datetime.utcnow() + timedelta(hours=1)
    }
    token = jwt.encode(payload, app.config["SECRET_KEY"], algorithm="HS256")
    return token

---

4️⃣ Ruta de Login para devolver un JWT

@app.route("/login", methods=["POST"])
def login():
    datos = request.json
    usuario = Usuario.query.filter_by(email=datos["email"]).first()
    
    if usuario and check_password_hash(usuario.password, datos["password"]):
        token = generar_token(usuario.id)
        return jsonify({"token": token})
    
    return jsonify({"error": "Credenciales inválidas"}), 401

📌 Salida esperada:

{
  "token": "eyJhbGciOiJIUzI1NiIsInR..."
}

---

5️⃣ Proteger rutas con un decorador personalizado

from functools import wraps

def token_requerido(f):
    @wraps(f)
    def decorador(*args, **kwargs):
        token = request.headers.get("Authorization")
        if not token:
            return jsonify({"error": "Token requerido"}), 403
        
        try:
            datos = jwt.decode(token, app.config["SECRET_KEY"], algorithms=["HS256"])
            usuario = Usuario.query.get(datos["usuario_id"])
        except:
            return jsonify({"error": "Token inválido o expirado"}), 403
        
        return f(usuario, *args, **kwargs)
    return decorador

---

6️⃣ Ruta protegida usando el token

@app.route("/perfil")
@token_requerido
def perfil(usuario):
    return jsonify({
        "usuario": usuario.username,
        "email": usuario.email
    })

✅ Si el token es válido, se accede al perfil del usuario autenticado.

---

7️⃣ Cómo enviar el token desde el cliente

📌 En las peticiones protegidas, se debe incluir el token:

GET /perfil HTTP/1.1  
Authorization: eyJhbGciOiJIUzI1NiIsInR...

✅ Esto permite que el backend valide al usuario sin usar cookies ni sesiones.

---

🚀 Conclusión

✅ JWT es ideal para autenticar usuarios en APIs REST.
✅ Protege tus rutas con decoradores y claves secretas.
✅ A diferencia de Flask-Login, JWT es stateless, perfecto para microservicios.

📌 Próximo post: Cómo refrescar tokens JWT y controlar expiración.

📂 Código en GitHub: github.com/josecodetech
🎥 Tutorial en YouTube: https://www.youtube.com/@josecodetech/

💬 ¿Ya usaste JWT? ¿Prefieres sesiones o tokens? Cuéntamelo 👇

👉 Autenticación de Usuarios en Flask con PostgreSQL y SQLAlchemy

En este post aprenderás a crear un sistema de autenticación de usuarios en Flask usando PostgreSQL como base de datos.

Vamos a implementar:
✔️ Registro de nuevos usuarios
✔️ Login con verificación de credenciales
✔️ Hashing de contraseñas con Werkzeug
✔️ Mantenimiento de sesión con Flask
✔️ Ejemplo práctico con rutas protegidas

📌 Este es el primer paso para construir aplicaciones web seguras.

---

1️⃣ Instalar las dependencias necesarias

Asegúrate de tener Flask y PostgreSQL ya configurados. Luego, instala:

pip install flask flask_sqlalchemy psycopg2-binary flask_bcrypt flask_login

---

2️⃣ Configurar la app y la base de datos

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from flask_login import LoginManager

app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "postgresql://mi_usuario:mi_clave@localhost/mi_app"
app.config["SECRET_KEY"] = "clave_secreta_super_segura"

db = SQLAlchemy(app)
bcrypt = Bcrypt(app)
login_manager = LoginManager(app)

---

3️⃣ Modelo de Usuario con contraseña encriptada

from flask_login import UserMixin

class Usuario(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(50), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password = db.Column(db.String(128), nullable=False)

📌 Creamos la tabla con:

with app.app_context():
    db.create_all()

---

4️⃣ Registro de nuevos usuarios con contraseña encriptada

from flask import request, jsonify

@app.route("/registro", methods=["POST"])
def registro():
    datos = request.json
    hashed_password = bcrypt.generate_password_hash(datos["password"]).decode("utf-8")
    nuevo_usuario = Usuario(username=datos["username"], email=datos["email"], password=hashed_password)

    db.session.add(nuevo_usuario)
    db.session.commit()

    return jsonify({"mensaje": "Usuario registrado con éxito"}), 201

📌 JSON esperado:

{
  "username": "jose",
  "email": "jose@example.com",
  "password": "123456"
}

---

5️⃣ Inicio de sesión y validación de contraseña

from flask_login import login_user

@app.route("/login", methods=["POST"])
def login():
    datos = request.json
    usuario = Usuario.query.filter_by(email=datos["email"]).first()

    if usuario and bcrypt.check_password_hash(usuario.password, datos["password"]):
        login_user(usuario)
        return jsonify({"mensaje": "Login exitoso"}), 200
    return jsonify({"error": "Credenciales incorrectas"}), 401

---

6️⃣ Rutas protegidas para usuarios logueados

from flask_login import login_required, current_user

@app.route("/perfil")
@login_required
def perfil():
    return jsonify({
        "usuario": current_user.username,
        "email": current_user.email
    })

✅ Esta ruta solo puede ser accedida si el usuario está autenticado.

---

7️⃣ Cerrar sesión

from flask_login import logout_user

@app.route("/logout")
@login_required
def logout():
    logout_user()
    return jsonify({"mensaje": "Sesión cerrada"})

---

🚀 Conclusión

✅ Hemos creado un sistema de registro, login y sesión en Flask.
✅ Las contraseñas se almacenan encriptadas con Bcrypt.
✅ Flask-Login facilita la autenticación y la protección de rutas.

📌 Próximo post: Cómo integrar JWT para APIs seguras en Flask.

📂 Código en GitHub: github.com/josecodetech
🎥 Tutorial en YouTube: https://www.youtube.com/@josecodetech

💬 ¿Qué tipo de autenticación sueles usar en tus proyectos Flask?