Potion Services

Servicios🤗

Guía paso a paso: conectar WordPress con la API de OpenAI para generar contenido

Guía paso a paso: conectar WordPress con la API de OpenAI para generar contenido

Si ya tienes un WordPress vivo (aunque medio abandonado) y estás cansado de copiar y pegar desde ChatGPT,
el siguiente paso lógico es claro: conectar tu web directamente con la API de OpenAI y dejar que la máquina
trabaje desde dentro.

En esta guía vas a ver, de forma práctica:

1. Qué opciones tienes realmente

No todos los enfoques sirven para lo mismo. Este resumen te sitúa:

Enfoque Ventaja Limitación Para quién
Plugin “IA para WordPress” Instalar, pegar API key y usar Flujo muy manual, difícil escalar Usuarios no técnicos
Código en PHP dentro de WordPress Control total de prompts y flujo Requiere tocar código y mantenerlo Desarrolladores / usuarios avanzados
Backend externo en Node.js Ideal para programmatic SEO y automatizaciones grandes Es un proyecto de desarrollo, no un apaño rápido Proyectos ambiciosos, agencias, nicheros serios

2. Primer paso obligatorio: conseguir y guardar tu API key de OpenAI

Sea cual sea la opción que elijas, necesitas una API key de OpenAI.

  1. Entra en la plataforma de OpenAI, en la sección de API.
  2. Crea una nueva API key.
  3. Guárdala en un lugar seguro (variable de entorno, configuración del servidor, etc.).

En un WordPress típico, una forma sencilla de usarla es definirla como constante en wp-config.php: 


define( 'OPENAI_API_KEY', 'TU_CLAVE_SECRETA_AQUI' );

Después podrás leer OPENAI_API_KEY desde tu plugin o snippet sin tener que pegar la clave
en cada archivo.

3. Opción plug-and-play: conectar WordPress con OpenAI usando plugins

Si quieres empezar sin tocar código, lo más fácil es usar plugins que ya integran la API de OpenAI.
Algunos ejemplos populares (pueden cambiar con el tiempo, pero la idea es esta):

El flujo típico es:

  1. Ir a Plugins > Añadir nuevo y buscar el plugin por su nombre.
  2. Instalar y activar.
  3. Entrar en el nuevo menú del plugin (por ejemplo, “AI Engine”, “AI Power”, “Easy GPT”).
  4. Pegar tu API key de OpenAI en el campo correspondiente y guardar.
  5. Activar los módulos de “Content writer”, “Bulk content”, “AI assistant”, etc., según el plugin.

Con eso ya puedes:

Está muy bien para darle superpoderes a tu WordPress, pero todo sigue siendo bastante
manual: tú haces clic, tú decides el prompt, tú revisas, tú publicas. Para un blog mediano es perfecto;
para proyectos grandes de contenido masivo se empieza a quedar pequeño.

4. Opción técnica 1: llamar a la API de OpenAI desde WordPress (PHP)

Si quieres más control, lo serio es crear tu propia integración en PHP. La idea es:

Este es un ejemplo simplificado de un plugin que añade un botón en el editor
y, al pulsarlo, genera contenido usando el título del post: 


<?php
/**
 * Plugin Name: WP OpenAI Demo
 */

// Añade metabox con botón en el editor de posts
add_action( 'add_meta_boxes', function() {
    add_meta_box(
        'wp_openai_box',
        'Generar contenido con OpenAI',
        'wp_openai_box_callback',
        'post',
        'side'
    );
} );

function wp_openai_box_callback( $post ) {
    ?>
    <p>
        <button type="button" class="button" id="wp-openai-generate">
            Generar con IA
        </button>
    </p>
    <script>
    document.addEventListener('DOMContentLoaded', function () {
      const btn = document.getElementById('wp-openai-generate');
      if (!btn) return;
      btn.addEventListener('click', async () => {
        btn.disabled = true;
        btn.innerText = 'Generando...';
        const response = await fetch(ajaxurl, {
          method: 'POST',
          headers: {'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'},
          body: new URLSearchParams({
            action: 'wp_openai_generate',
            post_id: '<?php echo esc_js( $post->ID ); ?>',
            _ajax_nonce: '<?php echo wp_create_nonce( 'wp_openai_generate' ); ?>'
          })
        });
        location.reload();
      });
    });
    </script>
    <?php
}

// Acción AJAX que llama a OpenAI y guarda el contenido en el post
add_action( 'wp_ajax_wp_openai_generate', function() {
    check_ajax_referer( 'wp_openai_generate' );

    $post_id = intval( $_POST['post_id'] ?? 0 );
    if ( ! $post_id ) {
        wp_send_json_error( 'ID de post no válido' );
    }

    $title = get_the_title( $post_id );

    $prompt = "Eres un redactor profesional. Escribe un artículo de 1.000 palabras "
            . "para un blog, con el título: \\"$title\\". Usa encabezados (H2, H3), "
            . "tono cercano y estructura clara.";

    $request_body = [
        'model' => 'gpt-4.1-mini', // ajusta al modelo que uses
        'input' => [
            [
                'role'    => 'user',
                'content' => $prompt,
            ],
        ],
    ];

    $response = wp_remote_post(
        'https://api.openai.com/v1/responses',
        [
            'headers' => [
                'Authorization' => 'Bearer ' . OPENAI_API_KEY,
                'Content-Type'  => 'application/json',
            ],
            'body'    => wp_json_encode( $request_body ),
            'timeout' => 60,
        ]
    );

    if ( is_wp_error( $response ) ) {
        wp_send_json_error( $response->get_error_message() );
    }

    $data = json_decode( wp_remote_retrieve_body( $response ), true );

    // Adaptar según el formato devuelto por el modelo
    $generated = $data['output'][0]['content'][0]['text'] ?? '';

    if ( ! $generated ) {
        wp_send_json_error( 'No se recibió texto de la IA.' );
    }

    // Guardar el contenido generado en el post
    wp_update_post( [
        'ID'           => $post_id,
        'post_content' => wp_kses_post( $generated ),
    ] );

    wp_send_json_success( 'Contenido generado.' );
} );

Con algo así ya puedes crear tu propio flujo de generación: defines el prompt, usas el título u otros datos
del post, llamas a la API y rellenas el contenido con un clic.

A partir de aquí, lo lógico es ir añadiendo:

5. Opción técnica 2: backend en Node.js que genera contenido y lo envía a WordPress

Cuando ya quieres hacer programmatic SEO serio (cientos o miles de posts, uso de bases de datos,
varias webs), lo más limpio suele ser tener un pequeño backend externo, por ejemplo en Node.js.

La idea es:

  1. Tener una base de datos o un CSV con todo lo que quieres generar (títulos, ciudades, productos, etc.).
  2. Un script en Node.js que recorra esa lista, llame a OpenAI y genere contenido para cada fila.
  3. Crear el post en WordPress usando la REST API o WP-CLI.

Ejemplo mínimo en Node.js usando el SDK oficial de OpenAI:


npm install openai node-fetch


// archivo: generate-post.js
import OpenAI from "openai";
import fetch from "node-fetch";

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

async function generarArticulo(titulo) {
  const prompt = `
Eres un redactor experto en SEO. Escribe un artículo de 1.200 palabras
para un blog con el título: "${titulo}".
Usa encabezados (H2, H3), listas y un tono cercano y profesional.
No repitas ideas y no inventes datos delicados.`;

  const response = await client.responses.create({
    model: "gpt-4.1-mini",
    input: [
      { role: "user", content: prompt }
    ],
  });

  const texto =
    response.output?.[0]?.content?.[0]?.text ??
    JSON.stringify(response, null, 2);

  return texto;
}

async function crearPostEnWordPress(titulo, contenido) {
  const wpUser = process.env.WP_USER;
  const wpPass = process.env.WP_PASSWORD;
  const wpUrl  = process.env.WP_URL; // p.ej. "https://tusitio.com/wp-json/wp/v2/posts"

  const auth = Buffer.from(`${wpUser}:${wpPass}`).toString("base64");

  const res = await fetch(wpUrl, {
    method: "POST",
    headers: {
      "Authorization": `Basic ${auth}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      title:   titulo,
      content: contenido,
      status:  "draft" // o "publish" si quieres publicarlo directamente
    }),
  });

  if (!res.ok) {
    const errText = await res.text();
    throw new Error(`Error al crear post: ${res.status} - ${errText}`);
  }

  const data = await res.json();
  console.log("Post creado con ID:", data.id);
}

async function main() {
  const titulo = "Ejemplo: Guía para visitar Sevilla en 3 días";
  const contenido = await generarArticulo(titulo);
  await crearPostEnWordPress(titulo, contenido);
}

main().catch(console.error);

A partir de este esqueleto, puedes leer títulos de una base de datos, iterar, generar diez, cien o mil posts
y dejarlos todos creados como borrador en WordPress para revisarlos.

6. Buenas prácticas para no romper nada

Algunas reglas básicas para no estrellarte al integrar IA en WordPress:

7. Hasta dónde llegas tú… y dónde entra PotionServices

Con todo lo anterior puedes:

Es decir, puedes dejar de ser “el que copia y pega desde ChatGPT” y pasar a tener integraciones reales
entre tu web y la IA.

Pero cuando quieres:

Ahí ya no hablamos de un “truco con la API”, sino de un motor diseñado para hacer contenido masivo
de forma seria. Eso es lo que usamos en PotionServices: Plantilla + Publicador, bases de datos, IA
y conexión directa con la API de WordPress para publicar a escala.

Si quieres experimentar por tu cuenta, con esta guía tienes para jugar durante un buen rato.
Si lo que quieres es ir directamente a contenido masivo bien planteado, puedes ver nuestro servicio aquí:


Textos masivos usando IA – PotionServices

Ption Services

Los mejores servicios web

VER

Recibe nuestros artículos donde quieras: