Crear un bot de Discord#14¡Guarda tus datos! JSON vs SQLite (ejemplo en Python)

¡Hola! Soy Mojangcam 😎

En el #13 dejamos la administración del servidor por completo en manos del bot, automatizando roles y canales. Pero quedó una cosa pendiente. Igual que temp_channels del #13, los datos que solo guardas en variables desaparecen por completo en cuanto reinicias el bot.

Por eso, en este #14 le vamos a dar memoria al bot. Vamos a crear un bot de asistencia + puntos + ranking con dos métodos que ya vienen incluidos en Python, JSON y SQLite, y de paso dejaremos claro cuándo conviene usar cada uno.

Registro de asistencia, sistema de puntos (economía), niveles, acumulación de advertencias… todas las funciones populares de los servidores de comunidad necesitan un "bot que recuerde datos". ¡En cuanto superes este paso, la cantidad de funciones que puedes crear se dispara!

🧠 ¿Por qué hace falta guardar los datos?

Todas las variables de Python existen solo en la memoria (RAM). En cuanto reinicias el bot, se reinicia el VPS o el bot se cae por un error, los puntos y registros que había en las variables se borran sin dejar rastro. Por eso hay que dejar los datos en un archivo y volver a leerlos cuando el bot arranca. A esto se le llama, con una palabra más técnica, persistencia (Persistence).

🧩 JSON vs SQLite, ¿en qué se diferencian?

¡Vamos directo a la conclusión! Para datos pequeños y simples, como la configuración, usa JSON; para datos que se van acumulando y necesitan búsquedas o rankings, usa SQLite.

JSON es básicamente un dict de Python pasado a un archivo, así que es intuitivo, y su mayor ventaja es que puedes abrirlo con el Bloc de notas y revisarlo a simple vista. A cambio, como reescribe el archivo entero cada vez que guardas, se vuelve más lento a medida que crecen los datos. SQLite es una base de datos de verdad que funciona con un solo archivo y sin instalar ningún servidor, así que puedes leer solo los datos que necesitas y dejarle a SQL hasta el ordenamiento y los cálculos.

📌 Lo que necesitas

• Python 3.8 o superior
• discord.py 2.x (cualquier versión 2.x reciente sirve)
• Módulos json y sqlite3 — vienen integrados en Python, ¡así que no hay nada que instalar!

pip install -U discord.py

Como vamos a usar comandos con prefijo (!출석), tienes que activar Message Content Intent en el Discord Developer Portal → pestaña Bot. (Si es la primera vez que tocas este ajuste, ¡revisa los capítulos anteriores de la serie!)

📌 Paso 1 - Lo básico de guardar en JSON: las funciones load y save

La clave del método JSON son solo dos funciones: una que lee el dict desde el archivo y otra que guarda el dict en el archivo.

import json
import os

DATA_FILE = "points.json"

def load_data():
    """Si el archivo existe lo lee; si no, devuelve un dict vacío."""
    if not os.path.exists(DATA_FILE):
        return {}
    with open(DATA_FILE, "r", encoding="utf-8") as f:
        return json.load(f)

def save_data(data):
    """Guarda el dict completo en el archivo JSON."""
    with open(DATA_FILE, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)

Vamos a verlo parte por parte 💡

• json.load(f) : lee el contenido del archivo y lo convierte en un dict de Python.
• json.dump(data, f) : convierte el dict en texto con formato JSON y lo escribe en el archivo.
• encoding="utf-8" + ensure_ascii=False : es el combo para que los caracteres no ASCII (coreano, ñ, tildes…) no se rompan. Si quitas cualquiera de los dos, el texto se guarda en un idioma alienígena como \uD55C\uAE00.
• indent=2 : añade sangría para que el archivo quede fácil de leer para las personas.

¡Un detalle importante! Las claves (key) de JSON solo pueden ser cadenas. El ID de usuario en realidad es un número, pero lo más seguro es convertirlo siempre a cadena al guardarlo, como str(ctx.author.id).

📌 Paso 2 - Bot de asistencia y puntos completo en versión JSON

Si a esas dos funciones les sumas tres comandos (!출석 = asistencia, !포인트 = puntos, !랭킹 = ranking), ya está listo. Este código es la versión completa y puedes ejecutarlo tal cual.

# discord.py 2.x / Python 3.8+ / json viene integrado en Python
import json
import os
from datetime import date

import discord
from discord.ext import commands

TOKEN = "PON_AQUI_EL_TOKEN_DE_TU_BOT"
DATA_FILE = "points.json"

def load_data():
    if not os.path.exists(DATA_FILE):
        return {}
    with open(DATA_FILE, "r", encoding="utf-8") as f:
        return json.load(f)

def save_data(data):
    with open(DATA_FILE, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)

intents = discord.Intents.default()
intents.message_content = True  # para comandos con prefijo

bot = commands.Bot(command_prefix="!", intents=intents)

@bot.event
async def on_ready():
    print(f"✅ ¡Sesión iniciada como {bot.user}!")

@bot.command(name="출석")
async def attend(ctx: commands.Context):
    data = load_data()
    uid = str(ctx.author.id)
    today = date.today().isoformat()   # ej.: '2026-07-30'

    user = data.get(uid, {"points": 0, "last_check": ""})
    if user["last_check"] == today:
        await ctx.send(f"{ctx.author.mention} ¡Hoy ya registraste tu asistencia! 😅")
        return

    user["points"] += 10
    user["last_check"] = today
    data[uid] = user
    save_data(data)
    await ctx.send(f"✅ {ctx.author.mention} ¡Asistencia registrada! +10P (total {user['points']}P)")

@bot.command(name="포인트")
async def my_points(ctx: commands.Context):
    data = load_data()
    user = data.get(str(ctx.author.id))
    total = user["points"] if user else 0
    await ctx.send(f"💰 Puntos de {ctx.author.mention}: {total}P")

@bot.command(name="랭킹")
async def ranking(ctx: commands.Context):
    data = load_data()
    if not data:
        await ctx.send("Todavía nadie ha registrado asistencia. ¡Tu oportunidad de ser el número 1! 🏃")
        return

    top = sorted(data.items(), key=lambda x: x[1]["points"], reverse=True)[:5]
    medals = ["🥇", "🥈", "🥉", "4️⃣", "5️⃣"]
    lines = [f"{medals[i]} <@{uid}> — {info['points']}P"
             for i, (uid, info) in enumerate(top)]
    embed = discord.Embed(title="🏆 Ranking de puntos TOP 5",
                          description="\n".join(lines),
                          color=0x5865F2)
    await ctx.send(embed=embed)

bot.run(TOKEN)

Vamos a verlo parte por parte 💡

• date.today().isoformat() : convierte la fecha de hoy en una cadena con el formato 2026-07-30. Al compararla con last_check, es la clave para permitir una sola asistencia al día.
• data.get(uid, valor por defecto) : si es la primera vez que el usuario registra asistencia, crea un dict por defecto que empieza con 0 puntos.
• sorted(..., reverse=True)[:5] : para sacar el ranking, cargamos todos los datos en Python y los ordenamos nosotros mismos. ¡Este es justo el límite del método JSON! Compáralo más adelante con SQLite.
• Mención <@ID_del_usuario> dentro del embed : las menciones dentro de un embed no envían notificación (ping), así que son perfectas para mostrar un ranking.

Cuando lo ejecutes y escribas !출석, se creará el archivo points.json en la carpeta del bot. Si lo abres con el Bloc de notas, se ve así.

{
  "123456789012345678": {
    "points": 30,
    "last_check": "2026-07-30"
  }
}

Para un servidor de unos 10 usuarios, con esto basta. Pero cuando hay cientos de usuarios y los registros se acumulan, empiezan los problemas. La estructura es así: con cada asistencia se reescribe el archivo entero, y con cada ranking se vuelve a leer todo. Además, si el bot se cierra a la fuerza mientras guarda, el archivo puede corromperse por completo. ¡Para estos casos necesitas SQLite!

📌 Paso 3 - Pasar el mismo bot a SQLite

SQLite se puede usar directamente con el módulo integrado sqlite3 de Python. Primero te conectas al archivo de la base de datos y creas una tabla.

import sqlite3

con = sqlite3.connect("points.db")   # ¡si el archivo no existe, se crea solo!
con.execute("""
CREATE TABLE IF NOT EXISTS points (
    user_id    TEXT PRIMARY KEY,
    points     INTEGER NOT NULL DEFAULT 0,
    last_check TEXT    NOT NULL DEFAULT ''
)
""")
con.commit()

El comando de asistencia queda así.

@bot.command(name="출석")
async def attend(ctx: commands.Context):
    uid = str(ctx.author.id)
    today = date.today().isoformat()

    row = con.execute(
        "SELECT last_check FROM points WHERE user_id = ?", (uid,)
    ).fetchone()
    if row is not None and row[0] == today:
        await ctx.send(f"{ctx.author.mention} ¡Hoy ya registraste tu asistencia! 😅")
        return

    con.execute("INSERT OR IGNORE INTO points (user_id) VALUES (?)", (uid,))
    con.execute(
        "UPDATE points SET points = points + 10, last_check = ? WHERE user_id = ?",
        (today, uid),
    )
    con.commit()

Vamos a verlo parte por parte 💡

• sqlite3.connect("points.db") : se conecta al archivo de la base de datos. Si el archivo no existe, lo crea por ti.
• CREATE TABLE IF NOT EXISTS : crea la tabla solo si no existe. Por eso es seguro reiniciar el bot las veces que quieras.
• PRIMARY KEY : es la clave principal que impide que user_id se repita.
• Marcador de posición con signo de interrogación (?) : pasa los valores de forma segura sin pegarlos directamente en la sentencia SQL. Si armas el SQL con f-strings, quedas expuesto a ataques de inyección SQL, ¡así que usa siempre ?!
• INSERT OR IGNORE → UPDATE : primero "si no existe, lo crea; si existe, lo deja como está", y después suma los puntos. Es el patrón con el que menos se equivocan los principiantes.
• con.commit() : confirma los cambios en el archivo. ¡Si te lo saltas, no se guarda nada!

¿Y el ranking? Con JSON cargábamos todo y lo ordenábamos en Python, pero con SQLite basta una línea de SQL.

rows = con.execute(
    "SELECT user_id, points FROM points ORDER BY points DESC LIMIT 5"
).fetchall()

ORDER BY points DESC LIMIT 5 — significa "ordena por puntos de mayor a menor y dame solo los 5 primeros". Aunque haya 100.000 usuarios, la base de datos los selecciona sola. ¡Ese es el poder de una base de datos! 💪

📌 Código completo (listo para copiar y pegar)

Esta es la versión completa con SQLite. Solo cambia TOKEN y funciona al instante. (Para la versión completa con JSON, usa tal cual el código del Paso 2 de arriba).

# discord.py 2.x / Python 3.8+ / sqlite3 viene integrado en Python
import sqlite3
from datetime import date

import discord
from discord.ext import commands

TOKEN = "PON_AQUI_EL_TOKEN_DE_TU_BOT"
DB_FILE = "points.db"

# ── Preparar la base de datos ──────────────────────────
con = sqlite3.connect(DB_FILE)
con.execute("""
CREATE TABLE IF NOT EXISTS points (
    user_id    TEXT PRIMARY KEY,
    points     INTEGER NOT NULL DEFAULT 0,
    last_check TEXT    NOT NULL DEFAULT ''
)
""")
con.commit()

intents = discord.Intents.default()
intents.message_content = True  # para comandos con prefijo

bot = commands.Bot(command_prefix="!", intents=intents)

@bot.event
async def on_ready():
    print(f"✅ ¡Sesión iniciada como {bot.user}!")

@bot.command(name="출석")
async def attend(ctx: commands.Context):
    uid = str(ctx.author.id)
    today = date.today().isoformat()

    row = con.execute(
        "SELECT last_check FROM points WHERE user_id = ?", (uid,)
    ).fetchone()
    if row is not None and row[0] == today:
        await ctx.send(f"{ctx.author.mention} ¡Hoy ya registraste tu asistencia! 😅")
        return

    con.execute("INSERT OR IGNORE INTO points (user_id) VALUES (?)", (uid,))
    con.execute(
        "UPDATE points SET points = points + 10, last_check = ? WHERE user_id = ?",
        (today, uid),
    )
    con.commit()

    total = con.execute(
        "SELECT points FROM points WHERE user_id = ?", (uid,)
    ).fetchone()[0]
    await ctx.send(f"✅ {ctx.author.mention} ¡Asistencia registrada! +10P (total {total}P)")

@bot.command(name="포인트")
async def my_points(ctx: commands.Context):
    row = con.execute(
        "SELECT points FROM points WHERE user_id = ?", (str(ctx.author.id),)
    ).fetchone()
    total = row[0] if row else 0
    await ctx.send(f"💰 Puntos de {ctx.author.mention}: {total}P")

@bot.command(name="랭킹")
async def ranking(ctx: commands.Context):
    rows = con.execute(
        "SELECT user_id, points FROM points ORDER BY points DESC LIMIT 5"
    ).fetchall()
    if not rows:
        await ctx.send("Todavía nadie ha registrado asistencia. ¡Tu oportunidad de ser el número 1! 🏃")
        return

    medals = ["🥇", "🥈", "🥉", "4️⃣", "5️⃣"]
    lines = [f"{medals[i]} <@{uid}> — {pts}P"
             for i, (uid, pts) in enumerate(rows)]
    embed = discord.Embed(title="🏆 Ranking de puntos TOP 5",
                          description="\n".join(lines),
                          color=0x5865F2)
    await ctx.send(embed=embed)

bot.run(TOKEN)

📌 Resultado

Enciende el bot y prueba los comandos uno por uno en tu servidor.

1. Escribe !출석 → responde "✅ ¡Asistencia registrada! +10P (total 10P)". Si lo vuelves a escribir el mismo día: "¡Hoy ya registraste tu asistencia! 😅"
2. Escribe !포인트 → muestra tus puntos acumulados.
3. Escribe !랭킹 → aparece un embed con el TOP 5 y las medallas 🥇🥈🥉.
4. ¡Y aquí viene lo mejor! Apaga el bot y vuelve a encenderlo. Si escribes !포인트, tus puntos siguen ahí. Es gracias a que la memoria quedó guardada en el archivo points.db (o points.json) de la carpeta del bot. 🎉

📌 Errores comunes

1. json.decoder.JSONDecodeError: Expecting value: line 1 column 1 Causa: points.json está vacío, o el bot se cerró a la fuerza mientras guardaba y el archivo se corrompió. Solución: borra el archivo y vuelve a ejecutar el bot; se creará uno nuevo. Si no quieres perder los datos, ábrelo con el Bloc de notas y arregla la parte dañada. Para prevenirlo, apaga el bot con un solo Ctrl+C cuando no esté guardando, para que se cierre de forma normal.

2. El texto se guarda en un idioma alienígena como \uc548\ub155 Causa: olvidaste poner ensure_ascii=False en json.dump. Solución: json.dump(data, f, ensure_ascii=False, indent=2) — y al abrir el archivo, no olvides añadir encoding="utf-8".

3. sqlite3.OperationalError: no such table: points Causa: hiciste un SELECT antes de ejecutar CREATE TABLE, o ejecutaste el bot desde otra carpeta y se creó un archivo de base de datos vacío en otro lugar. Solución: comprueba que el código que prepara la base de datos (CREATE TABLE) se ejecute antes de bot.run(), y entra a la carpeta del bot con cd en la terminal antes de ejecutarlo.

4. sqlite3.OperationalError: database is locked Causa: un programa visor de bases de datos tiene abierto points.db, u otra conexión sin commit() tiene el archivo bloqueado. Solución: cierra el visor y acostúmbrate a poner siempre con.commit() después del código que modifica datos.

💡 Consejos extra

• Evita el spam de asistencia : además del límite de una vez al día, si le pones el cooldown del #12, bloqueas también el spam por completo.
• Para hacer una copia de seguridad, basta con copiar un archivo : ¡copia solo points.db y listo! Si lo tienes funcionando 24 horas en un VPS, ten en cuenta que la fecha de asistencia se basa en la hora del servidor, así que en un VPS en el extranjero ajusta la zona horaria a Seúl (Asia/Seoul).
• Si los datos crecen muchísimo : sqlite3 funciona de forma síncrona, así que con operaciones muy grandes el bot puede quedarse congelado un momento. A escala de principiante no se nota, ¡pero más adelante en la serie veremos cómo pasar a la librería asíncrona aiosqlite!

📌 Para terminar

Hoy aprendimos a guardar datos para darle memoria al bot. Para datos pequeños y simples, JSON; para datos que se van acumulando y necesitan búsquedas o rankings, SQLite — con recordar solo este criterio es suficiente. Ya creamos el bot de asistencia, puntos y ranking con los dos métodos, así que ahora puedes aplicarlo a lo que quieras, ¡ya sea un sistema de niveles o un contador de advertencias!

En el próximo capítulo veremos los grupos de comandos slash (Group), que sirven para ordenar un bot con muchos comandos. ¡No te lo pierdas! 🙌

📚 Serie Crear un bot de Discord

• #5 - Interacciones con botones (Button)
• #6 - Menús desplegables (Select Menu)
• #7 - Pedir datos con un modal (Modal)
• #8 - Decorar embeds (Embed)
• #9 - Integración con IA (API de Claude y ChatGPT)
• #10 - Soporte multilingüe (i18n)
• #11 - Panel web con Flask
• #12 - Gestión de cooldowns y permisos de comandos
• #13 - Automatización de roles y canales
• #14 - Guardar datos (JSON vs SQLite) ← ¡estás leyendo este!