Cómo crear tu plugin WordPress paso a paso

Crear un plugin de WordPress desde cero es más accesible de lo que parece. Necesitás solo un editor de código, conocimientos básicos de PHP y HTML, y entender cómo funcionan los hooks (acciones y filtros) de la plataforma. Con una carpeta, un archivo .php con cabecera estándar y el sistema de hooks, podés armar funcionalidad que se integre perfectamente con WordPress. En esta guía vamos a ver paso a paso cómo hacerlo, desde la estructura básica hasta publicarlo en WordPress.org.

Qué es un plugin de WordPress y cómo funciona

Un plugin WordPress es código PHP que extiende la funcionalidad del sitio sin tocar el código central de WordPress. En lugar de modificar los archivos del core (que se pierden con cada actualización), creás un archivo separado que WordPress carga automáticamente y que persiste incluso cuando actualizás la plataforma. La magia está en los hooks: WordPress tiene cientos de puntos donde dice “acá alguien puede meter código suyo” (actions) o “acá el código de otros puede cambiar este dato” (filters). Vos aprovechás esos puntos para inyectar lo que necesitás.

Requisitos previos: qué necesitas antes de empezar

Antes de crear tu primer plugin, tenés que tener algunas cosas listas. De conocimiento: PHP básico (variables, funciones, arrays), HTML y CSS a nivel mínimo, y al menos familiaridad pasada con WordPress como usuario (sabés qué es un post, una categoría, el panel de admin). De herramientas: un editor de código decente como VS Code (gratuito), un entorno local de WordPress (podés usar Local by Flywheel, XAMPP o un servidor con soporte WordPress para testing inicial). Necesitás acceso por FTP/SFTP o por el file manager si el hosting lo ofrece (acá es donde donweb.com viene bien, con acceso directo al servidor). Y obvio, tener WordPress instalado localmente o en un sitio de testing donde practiques sin romper nada en producción.

Paso 1: Crear la carpeta y archivo principal del plugin

Arrancamos por lo básico. Navegás a la carpeta wp-content/plugins de tu instalación WordPress (en local o por SFTP si estás en un servidor) y creás una carpeta nueva con un nombre descriptivo. Si vas a armar un plugin que cuenta palabras de los posts, le ponés algo como contador-palabras o word-counter-pro (evitá espacios y caracteres especiales, mejor guiones). Dentro de esa carpeta creás un archivo .php con el mismo nombre: contador-palabras.php.

Dentro del archivo .php, la primera cosa que metés es la cabecera estándar (obligatoria para que WordPress lo reconozca como plugin). Lucé así:

<?php
/*
Plugin Name: Contador de Palabras
Plugin URI: https://ejemplo.com/mi-plugin
Description: Cuenta las palabras de cada post y muestra el total
Version: 1.0.0
Author: Tu Nombre
Author URI: https://ejemplo.com
License: GPL2
Text Domain: contador-palabras
Domain Path: /languages
*/

Esos campos son la identidad del plugin. WordPress los lee automáticamente, así que tenés que incluirlos sí o sí. “Plugin Name” es lo que ves en el panel admin, “Description” es lo que aparece debajo, “Version” es importante para updates. Con eso, el archivo tiene suficiente para que WordPress lo detecte en la lista de plugins, y desde ahí podés activarlo. Complementá con agentes que funcionan sin APIs.

Paso 2: Estructura de carpetas recomendada (buenas prácticas)

Ponele que ya tenés el archivo principal funcionando. Ahora bien, si el plugin crece (y casi siempre crece), conviene que lo estructures para no terminar con 500 líneas en un solo archivo. La estructura profesional es así:

contador-palabras/
├── contador-palabras.php (archivo principal con cabecera)
├── admin/ (código del panel admin)
│ └── settings.php
├── public/ (código que ven los usuarios)
│ └── display.php
├── includes/ (funciones reutilizables)
│ ├── functions.php
│ └── class-contador.php
├── assets/
│ ├── css/
│ │ └── style.css
│ └── js/
│ └── script.js
├── languages/ (traducciones)
│ └── contador-palabras-es_ES.po
├── templates/ (HTML de frontend)
│ └── palabra-count.php
├── uninstall.php (limpieza si desactivan)
└── README.txt (documentación)

¿Por qué esta estructura? Porque cuando el plugin tenga 10 versiones, 3 desarrolladores, y el cliente pide cambios, vos necesitás saber dónde está cada cosa sin tener que leer el código completo. Las funciones van en includes, la lógica del panel admin en admin, lo que ven los usuarios en public, y los CSS/JS en assets. Es verdad que podés empezar con un solo archivo (ponele los primeros 200 líneas), pero una vez que pasa eso, reorganizar es un quilombo.

Paso 3: Entender y usar hooks: acciones y filtros

Los hooks son el corazón de WordPress, y si no los entendés, el plugin no va a funcionar. Hay dos tipos: actions y filters.

Actions ejecutan tu código en momentos específicos del ciclo de WordPress. Ejemplos reales: cuando se guarda un post (hook save_post), cuando se renderiza el footer (hook wp_footer), cuando WordPress arranca (hook init), cuando se activa tu plugin (hook activate_nombretulugin). Vos engangas una función tuya al hook con add_action('save_post', 'tu_funcion'), y cada vez que se dispara el evento, WordPress ejecuta tu función.

Filters modifican datos antes de que WordPress los muestre. Ejemplo: el hook the_title se dispara antes de mostrar el título del post, el hook the_content antes de mostrar el contenido. Vos engangas una función con add_filter('the_content', 'tu_funcion'), tu función recibe el contenido original, lo modifica (le agrega el contador de palabras, por ejemplo), y lo devuelve. Lo explicamos a fondo en estándares de seguridad y privacidad.

Ejemplo mínimo de action:

function mi_plugin_al_iniciar() {
 // Tu código aquí
 echo "Plugin cargado";
}
add_action('init', 'mi_plugin_al_iniciar');

Ejemplo mínimo de filter:

function mi_plugin_contar_palabras($contenido) {
 $palabras = str_word_count($contenido);
 return $contenido . "<p>Este post tiene " . $palabras . " palabras</p>";
}
add_filter('the_content', 'mi_plugin_contar_palabras');

La prioridad es otro concepto: cuando engancha múltiples plugins al mismo hook, necesitan un orden. Usás add_action('hook', 'funcion', 10) — ese 10 es la prioridad (menor número = corre primero). Por defecto es 10, así que si no especificás nada, todos comparten prioridad y se ejecutan en orden de carga.

Paso 4: Agregar funcionalidad: cómo codificar tu plugin

Acá es donde metes la lógica real del plugin. El consejo de oro: usá un prefijo único en todas tus funciones y variables. Si tu plugin se llama “contador-palabras”, todas las funciones arrancan con contador_palabras_. ¿Por qué? Porque si otro plugin tiene una función llamada igual, WordPress explota. Con el prefijo te asegurás que no hay colisiones.

Cuando enganches estilos CSS o JavaScript, no los metás inline en el HTML. Usás wp_enqueue_script() y wp_enqueue_style() en el hook wp_enqueue_scripts (para frontend) o admin_enqueue_scripts (para admin). WordPress maneja las dependencias, los versioning, y evita duplicados automáticamente:

function contador_palabras_cargar_assets() {
 wp_enqueue_style('contador-css', plugin_dir_url(__FILE__) . 'assets/css/style.css', array(), '1.0.0');
 wp_enqueue_script('contador-js', plugin_dir_url(__FILE__) . 'assets/js/script.js', array('jquery'), '1.0.0', true);
}
add_action('wp_enqueue_scripts', 'contador_palabras_cargar_assets');

Otra cosa crítica: sanitización y validación de datos. Si el usuario de tu plugin (otro admin, o alguien que lo modificó) mete datos en formularios, no los uses directamente. Sanitizá con funciones como sanitize_text_field(), absint(), wp_kses_post(). Validá con sanitize_key() o verificaciones propias. Si no lo hacés, abrís huecos de seguridad que hacen que no te acepten en WordPress.org.

Paso 5: Crear página de administración (opcional pero recomendado)

La mayoría de plugins necesitan un lugar donde el admin configure opciones. Usás add_menu_page() para crear un menú en el panel admin, add_submenu_page() para sub-menús. Luego creás un formulario que guarda las opciones con update_option() y las recupera con get_option(): Te puede servir nuestra cobertura de herramientas de inteligencia artificial.

function contador_palabras_agregar_menu() {
 add_menu_page(
 'Contador de Palabras',
 'Contador',
 'manage_options',
 'contador-palabras',
 'contador_palabras_pagina_admin'
 );
}
add_action('admin_menu', 'contador_palabras_agregar_menu');

function contador_palabras_pagina_admin() {
 if (!current_user_can('manage_options')) {
 return;
 }
 // Aquí va tu HTML del formulario
}

El parámetro 'manage_options' es el permiso requerido para ver la página (solo admins). current_user_can() verifica permisos del usuario actual, siempre usalo para proteger acciones sensibles.

Paso 6: Publicar tu plugin en WordPress.org

Si creaste algo que crees que otros necesitan, WordPress.org aloja plugins gratuitos que la comunidad puede descargar. El proceso tiene requisitos que no son complejos pero son obligatorios. Primero, creás una cuenta en WordPress.org (WordPress.org user). Luego, preparás:

• README.txt: documentación en formato específico que explica qué hace, cómo instalarlo, cambios de versión, y compatibilidad mínima (qué versión de WordPress necesita, qué versión de PHP)
• uninstall.php: script que corre cuando el usuario desactiva y borra el plugin, donde limpias cualquier dato que hayas guardado en la BD o en opciones
• Cumplir directrices de seguridad: sanitización, validación, verificación de permisos, nonce tokens en formularios
• Capturas de pantalla en formato estándar (mínimo 1, ideal 2-3)

El versionado debe ser semántico: 1.0.0 (major.minor.patch). Cada release en WordPress.org, mandás un commit con el tag v1.0.0, y el sistema detecta automáticamente que hay una versión nueva. Si un usuario descargó la 1.0.0, WordPress le avisa que hay 1.1.0 disponible si la información de versión coincide.

Errores comunes que deberías evitar

Conflictos de nombres de funciones. Creás una función mirar_datos() sin prefijo, luego instalas otro plugin que también tiene mirar_datos(), y WordPress se cae con fatal error. Solución: siempre prefijo único, algo como contador_palabras_mirar_datos().

Cargar assets sin dependencias. Metés jQuery en tu plugin sin decirle a WordPress que lo necesitás, y si otro plugin también carga jQuery diferente, terminás con dos versiones. Usá wp_enqueue_script() con el array de dependencias: wp_enqueue_script('mi-script', 'url', array('jquery'), '1.0') le dice a WordPress “cargá mi-script solo si jQuery ya está cargado”. Tema relacionado: elegir la plataforma correcta.

No validar/sanitizar inputs. Un usuario mete una comilla simple en un formulario, y tu SQL query se rompe. Peor aún, otro usuario mete JavaScript, y ese código se ejecuta en el admin de todos. Siempre: $datos = sanitize_text_field($_POST['campo']) antes de guardar, y echo wp_kses_post($datos) antes de mostrar.

Preguntas Frecuentes

¿Cómo creo un plugin de WordPress desde cero?

Creás una carpeta en wp-content/plugins con un archivo .php que contiene la cabecera estándar (Plugin Name, Description, Version, Author, License). Ese archivo es el núcleo del plugin. Enganchás funciones a los hooks de WordPress con add_action() y add_filter() para que WordPress ejecute tu código en momentos específicos. Con eso, WordPress lo detecta automáticamente en el panel de plugins y podés activarlo.

¿Qué son los hooks y filtros en WordPress?

Los hooks son puntos que WordPress dispone donde tu código se puede enganchar. Actions (acciones) ejecutan tu código en eventos específicos como guardar un post (save_post) o renderizar el footer (wp_footer). Filters (filtros) modifican datos antes de mostrarlos, como el contenido del post (the_content) o el título (the_title). Engancha con add_action('hook_name', 'tu_funcion') o add_filter('hook_name', 'tu_funcion').

¿Cuáles son los pasos básicos para crear un plugin?

Los pasos son: 1) crear una carpeta descriptiva en wp-content/plugins, 2) crear un archivo .php con la cabecera estándar (Plugin Name, Description, etc.), 3) escribir funciones PHP que hagan lo que necesitás, 4) enganchar esas funciones a hooks de WordPress, 5) si es complejo, organizar el código en subcarpetas (admin, public, includes, assets), 6) probar en local, 7) si querés publicarlo, seguir las directrices de seguridad y documentación de WordPress.org.

¿Cómo publico mi plugin en WordPress.org?

Creás una cuenta en WordPress.org, preparás un README.txt con documentación clara, un uninstall.php que limpia datos al desinstalar, siguiendo las directrices de seguridad (sanitización, validación, nonces). Luego enviás el plugin al repositorio de WordPress.org. El equipo de revisión verifica que cumpla con los estándares. Si aprueban, tu plugin está disponible para que cualquiera lo descargue desde el panel de WordPress, y manejarás las actualizaciones con versionado semántico.

¿Qué diferencia hay entre crear un plugin propio y contratar a alguien?

Si necesitás algo simple (agregar un campo custom, cambiar CSS, meter un shortcode básico), crear el plugin vos mismo es relativamente rápido y barato (gratis). Si necesitás algo complejo (sistema de suscripción, integración con APIs externas, lógica de negocio específica), probablemente convenga contratar un desarrollador o usar un plugin existente que ya resuelva tu problema. El tiempo que invertís en aprender PHP y hooks podría valer más que el costo de delegar.

Conclusión

Crear un plugin WordPress no es brujería, es lógica pura: entendés qué hooks existen (hay cientos), enganchás tu código ahí, y WordPress hace el resto. La verdad es que podés empezar con un archivo .php de 50 líneas y hacerlo crecer. Lo importante es que aprendas a pensar en hooks (dónde quiero que se ejecute mi código), a usar prefijos para evitar conflictos, y a sanitizar cualquier dato que entre de formularios o URLs.

Si el plugin es solo para tu sitio, no necesitás publicarlo en WordPress.org. Pero si querés que otros lo usen, vale la pena seguir las directrices de seguridad desde el inicio: escritura limpia, documentación clara, actualización regular. Los plugins que vemos en WordPress.org con miles de instalaciones empezaron exactamente así, como un archivo .php en una carpeta.

Fuentes

• Codex WordPress.org — Escribiendo un Plugin — documentación oficial de WordPress sobre estructura y funciones básicas
• Developer Handbook — Plugins — guía completa para desarrolladores sobre hooks, seguridad y mejores prácticas
• Hostinger — Crear un Plugin WordPress desde Cero — tutorial paso a paso con ejemplos prácticos
• ARSYS — Hooks WordPress: Cómo Utilizarlos en un Plugin — explicación detallada de acciones y filtros