Tooldata Academia
Lección 20 de 33•Automatizaciones de Marketing

Content repurposing automático

Reutiliza contenido automáticamente adaptándolo a diferentes plataformas.

15 minutos

El content repurposing es la estrategia de tomar un contenido y transformarlo en múltiples formatos para diferentes plataformas. Con automatización, puedes convertir un blog post en 20+ piezas de contenido sin esfuerzo manual.

Por qué repurposing es esencial

El problema:

  • Crear contenido original es costoso y lento
  • Cada plataforma tiene formatos diferentes
  • Tu audiencia está distribuida en múltiples canales
  • El contenido tiene vida útil limitada

La solución:

  • Un contenido = múltiples formatos
  • Automatizar la transformación
  • Maximizar el ROI de cada pieza
1 Blog Post puede convertirse en:
├── 1 Thread de Twitter (5-10 tweets)
├── 3-5 Posts de LinkedIn
├── 5-10 Tweets individuales
├── 1 Newsletter
├── 1 Video corto (script)
├── 5 Instagram stories
├── 1 Infografía (outline)
├── 1 Episodio de podcast (guión)
└── Múltiples respuestas en Quora/Reddit

Total: 20-30 piezas de contenido

Blog → Tweet Thread

Zap: Artículo a hilo de Twitter automático

Trigger: WordPress - New Post Action 1: Formatter - Extract key sections Action 2: Code - Create thread structure Action 3: Airtable - Save thread drafts Action 4: Slack - Notify for review

// Código para crear thread desde artículo

const title = inputData.title;
const content = inputData.content;
const url = inputData.url;
const author = inputData.author || 'Academia Tooldata';

// Limpiar HTML y dividir en secciones
const cleanContent = content.replace(/<[^>]*>/g, '');
const sections = cleanContent.split(/\n\n+/).filter(s => s.length > 30);

const thread = [];

// Tweet 1: Hook con promesa de valor
thread.push({
  number: 1,
  text: `🧵 ${title}

Te explico los puntos más importantes en este hilo:

↓`,
  type: 'hook'
});

// Tweets de contenido (máximo 8)
const contentTweets = sections.slice(0, 8);
contentTweets.forEach((section, index) => {
  // Truncar a 250 chars para dejar espacio
  let tweetText = section.substring(0, 250);

  // Agregar emoji relevante
  const emojis = ['💡', '📊', '🎯', '✅', '🔑', '📈', '⚡', '🚀'];
  tweetText = `${emojis[index % emojis.length]} ${tweetText}`;

  if (section.length > 250) {
    tweetText += '...';
  }

  thread.push({
    number: index + 2,
    text: tweetText,
    type: 'content'
  });
});

// Tweet final: CTA
thread.push({
  number: thread.length + 1,
  text: `📝 Si te fue útil este hilo:

1. Dale RT al primer tweet para ayudar a otros
2. Sígueme para más contenido de este tipo
3. Lee el artículo completo aquí: ${url}

¿Preguntas? Déjalas en los comentarios 👇`,
  type: 'cta'
});

return {
  threadJson: JSON.stringify(thread),
  tweetCount: thread.length,
  title: title
};

Airtable como gestor de threads

Estructura de tabla "Tweet Threads":

| Thread ID | Source URL | Title | Tweet # | Content | Status | Scheduled |
|-----------|------------|-------|---------|---------|--------|-----------|
| THR001    | /blog/...  | Title | 1       | Hook... | Draft  | -         |
| THR001    | /blog/...  | Title | 2       | Point 1 | Draft  | -         |
| THR001    | /blog/...  | Title | 3       | Point 2 | Draft  | -         |

Workflow:
1. Zap crea registros con Status = "Draft"
2. Editor revisa y ajusta en Airtable
3. Cambia Status a "Approved"
4. Otro Zap publica los aprobados

Video → Clips + Quotes

Zap: Video de YouTube a múltiples contenidos

Trigger: YouTube - New Video in Channel Action 1: Get transcript (via API service) Action 2: Code - Extract clips and quotes Action 3: Create social posts Action 4: Queue for editing

// Extraer contenido de video

const transcript = inputData.transcript;
const videoTitle = inputData.videoTitle;
const videoUrl = inputData.videoUrl;
const duration = inputData.duration; // en segundos

// Identificar momentos clave por palabras señal
const keyPhrases = [
  'lo más importante',
  'el secreto es',
  'mi consejo',
  'el error más común',
  'la clave está en',
  'te recomiendo',
  'en resumen'
];

// Parsear transcript con timestamps (formato simplificado)
const lines = transcript.split('\n');
const moments = [];

lines.forEach((line, index) => {
  keyPhrases.forEach(phrase => {
    if (line.toLowerCase().includes(phrase)) {
      // Capturar contexto (líneas antes y después)
      const context = lines.slice(
        Math.max(0, index - 2),
        Math.min(lines.length, index + 3)
      ).join(' ');

      moments.push({
        timestamp: index * 10, // Aproximación
        phrase: phrase,
        content: context,
        type: 'key_moment'
      });
    }
  });
});

// Crear contenido para cada momento
const outputs = {
  clips: moments.slice(0, 5).map((m, i) => ({
    title: `Clip ${i + 1}: ${m.phrase}`,
    startTime: m.timestamp,
    suggestedDuration: 60,
    content: m.content
  })),
  quotes: moments.map(m => ({
    text: m.content.substring(0, 200),
    hashtags: ['tip', 'consejo', videoTitle.split(' ')[0].toLowerCase()]
  })),
  socialPosts: moments.slice(0, 3).map(m => ({
    platform: 'linkedin',
    text: `💡 De mi último video "${videoTitle}":

"${m.content.substring(0, 300)}"

Ver video completo: ${videoUrl}

#${videoTitle.split(' ')[0]}`
  }))
};

return {
  clipsJson: JSON.stringify(outputs.clips),
  quotesJson: JSON.stringify(outputs.quotes),
  postsJson: JSON.stringify(outputs.socialPosts),
  momentCount: moments.length
};

Workflow de producción de clips

1. VIDEO SUBIDO A YOUTUBE
   ↓
2. ZAPIER EXTRAE TRANSCRIPT
   ↓
3. IDENTIFICAR MOMENTOS CLAVE
   ↓
4. CREAR TAREAS EN NOTION/ASANA
   ├── Clip 1: [timestamp] "Frase clave"
   ├── Clip 2: [timestamp] "Frase clave"
   └── Clip 3: [timestamp] "Frase clave"
   ↓
5. EDITOR CREA CLIPS
   ↓
6. CLIPS APROBADOS → PROGRAMAR
   ├── TikTok
   ├── Instagram Reels
   ├── YouTube Shorts
   └── LinkedIn Video

Blog → LinkedIn Posts

Zap: Artículo a múltiples posts de LinkedIn

Trigger: RSS - New Item (Blog) Action 1: Code - Generate LinkedIn variations Action 2: Airtable - Save drafts Action 3: Buffer - Schedule posts

// Generar variaciones para LinkedIn

const title = inputData.title;
const content = inputData.content;
const url = inputData.url;

// Limpiar y extraer
const cleanContent = content.replace(/<[^>]*>/g, '');
const paragraphs = cleanContent.split('\n\n').filter(p => p.length > 50);
const keyPoints = paragraphs.slice(0, 5);

const linkedInPosts = [];

// Post 1: Announcement style
linkedInPosts.push({
  type: 'announcement',
  day: 0,
  content: `📝 Acabo de publicar: "${title}"

${keyPoints[0]?.substring(0, 200)}...

👉 Lee el artículo completo (link en comentarios)

¿Qué opinas? Me encantaría leer tu perspectiva.

#${title.split(' ')[0]} #contenido #aprendizaje`
});

// Post 2: Key insight
linkedInPosts.push({
  type: 'insight',
  day: 2,
  content: `💡 Aprendizaje clave de esta semana:

${keyPoints[1]?.substring(0, 300)}

Esto lo aprendí mientras escribía sobre ${title.toLowerCase()}.

¿Has experimentado algo similar?

👇 Cuéntame en los comentarios`
});

// Post 3: Question hook
linkedInPosts.push({
  type: 'question',
  day: 4,
  content: `¿Sabías que ${keyPoints[2]?.substring(0, 150).toLowerCase()}?

Esto es solo uno de los puntos que cubro en mi artículo reciente.

Otros temas incluyen:
• ${keyPoints[0]?.substring(0, 50)}...
• ${keyPoints[1]?.substring(0, 50)}...
• ${keyPoints[3]?.substring(0, 50)}...

Link en el primer comentario 📎`
});

// Post 4: List format
linkedInPosts.push({
  type: 'list',
  day: 7,
  content: `5 cosas que aprendí sobre ${title.split(':')[0]}:

1️⃣ ${keyPoints[0]?.substring(0, 80)}
2️⃣ ${keyPoints[1]?.substring(0, 80)}
3️⃣ ${keyPoints[2]?.substring(0, 80)}
4️⃣ ${keyPoints[3]?.substring(0, 80)}
5️⃣ ${keyPoints[4]?.substring(0, 80) || 'La práctica es clave'}

¿Cuál te resonó más?

Profundizo en cada punto aquí: [link]`
});

// Post 5: Story format
linkedInPosts.push({
  type: 'story',
  day: 10,
  content: `La semana pasada compartí un artículo sobre ${title.toLowerCase()}.

La respuesta fue increíble.

Pero un comentario me hizo reflexionar:

"${keyPoints[0]?.substring(0, 100)}"

Esto me recordó por qué empecé a escribir sobre estos temas.

A veces el contenido que crees "básico" es exactamente lo que alguien necesita escuchar.

¿Qué contenido has creado que tuvo impacto inesperado?`
});

return {
  postsJson: JSON.stringify(linkedInPosts),
  postCount: linkedInPosts.length
};

Newsletter automática

Zap: Contenido de la semana → Newsletter

Trigger: Schedule - Every Friday at 2pm Action 1: Airtable - Get published content this week Action 2: Code - Compile newsletter Action 3: Mailchimp - Create Campaign Draft

// Compilar newsletter semanal

const posts = JSON.parse(inputData.postsJson);
const articles = JSON.parse(inputData.articlesJson);
const videos = JSON.parse(inputData.videosJson);

const currentDate = new Date();
const weekNumber = Math.ceil(currentDate.getDate() / 7);
const month = currentDate.toLocaleString('es', { month: 'long' });

const newsletter = {
  subject: `📬 Lo mejor de la semana ${weekNumber} de ${month}`,
  preheader: `${articles.length} artículos, ${videos.length} videos y más contenido para ti`,
  sections: []
};

// Sección: Artículo destacado
if (articles.length > 0) {
  newsletter.sections.push({
    title: '📝 Artículo de la semana',
    content: `<h3>${articles[0].title}</h3>
<p>${articles[0].excerpt}</p>
<a href="${articles[0].url}">Leer artículo completo →</a>`
  });
}

// Sección: Video destacado
if (videos.length > 0) {
  newsletter.sections.push({
    title: '🎬 Video destacado',
    content: `<h3>${videos[0].title}</h3>
<p>${videos[0].description}</p>
<a href="${videos[0].url}">Ver video →</a>`
  });
}

// Sección: Quick tips
newsletter.sections.push({
  title: '💡 Tips rápidos',
  content: posts.slice(0, 3).map(p =>
    `<li>${p.content.substring(0, 100)}...</li>`
  ).join('')
});

// Sección: Lo que viene
newsletter.sections.push({
  title: '🔮 La próxima semana',
  content: `<p>Estoy preparando contenido sobre [tema].
  ¿Hay algo específico que te gustaría que cubra?
  Responde a este email.</p>`
});

return {
  newsletterJson: JSON.stringify(newsletter),
  subject: newsletter.subject,
  preheader: newsletter.preheader
};

Distribución automatizada

Sistema completo de distribución

CONTENIDO ORIGINAL
     │
     ▼
┌────────────────┐
│  PROCESAMIENTO │
│                │
│ • Extraer key  │
│   points       │
│ • Generar      │
│   variaciones  │
│ • Crear assets │
└───────┬────────┘
        │
        ▼
┌────────────────────────────────────────────┐
│           DISTRIBUCIÓN POR CANAL           │
├────────────┬────────────┬────────────┬─────┤
│  Twitter   │  LinkedIn  │  Email     │ YT  │
├────────────┼────────────┼────────────┼─────┤
│ Thread     │ Post largo │ Newsletter │Short│
│ Tweets x10 │ Posts x5   │ Semanal    │Clips│
│ Quote card │ Carousel   │            │     │
└────────────┴────────────┴────────────┴─────┘
        │
        ▼
┌────────────────┐
│  PROGRAMACIÓN  │
│                │
│ Día 0: Announce│
│ Día 1: Thread  │
│ Día 2: LinkedIn│
│ Día 3: Tips    │
│ Día 5: Insight │
│ Día 7: Recap   │
└────────────────┘

Zap maestro: Content amplification

Trigger: Notion - Page Status Changed to "Published" Multi-step workflow:

Paso 1: Identificar tipo de contenido
  └── Code: Analizar page properties

Paso 2: Generar todos los formatos
  ├── Thread de Twitter (Code)
  ├── Posts de LinkedIn (Code)
  ├── Tweets individuales (Code)
  └── Snippets para email (Code)

Paso 3: Guardar en sistema de gestión
  └── Airtable: Crear registros para cada pieza

Paso 4: Programar distribución
  ├── Buffer: Agregar a cola
  └── Mailchimp: Agregar a draft de newsletter

Paso 5: Notificar equipo
  └── Slack: "Contenido procesado y programado"

Paso 6: Tracking
  └── Google Sheets: Registrar para métricas

Automatización de assets visuales

Zap: Crear imágenes con Canva

Trigger: Airtable - New Record (Quote approved) Action: Canva - Create Design from Template Action: Airtable - Update with image URL

Templates de Canva:

• Quote card (1080x1080) - Instagram
• Quote card (1200x628) - LinkedIn/Twitter
• Story template (1080x1920) - Instagram Stories
• Thumbnail (1280x720) - YouTube

Datos dinámicos:
• Texto de la quote
• Nombre del autor
• URL del contenido original
• Colores de marca

Métricas de repurposing

Dashboard de performance

Métricas a trackear:

POR CONTENIDO ORIGINAL:
• Total de piezas derivadas
• Alcance total combinado
• Engagement total
• Tráfico generado al original

POR FORMATO:
• Threads: Engagement rate
• Posts LinkedIn: Impresiones
• Tweets: Retweets/Likes
• Newsletter: Open rate

POR CANAL:
• Twitter: Followers ganados
• LinkedIn: Conexiones nuevas
• Email: Suscriptores nuevos

Zap: Reporte mensual de repurposing

Contenido del reporte:

📊 *Reporte de Content Repurposing - {{Mes}}*

*Contenido producido*
• Piezas originales: {{original_count}}
• Piezas derivadas: {{repurposed_count}}
• Ratio de multiplicación: {{ratio}}x

*Por tipo*
• Threads: {{threads_count}}
• Posts LinkedIn: {{linkedin_count}}
• Tweets: {{tweets_count}}
• Newsletter mentions: {{email_count}}

*Performance*
• Total alcance: {{total_reach}}
• Total engagement: {{total_engagement}}
• Tráfico a originales: {{traffic_to_original}}

*Top contenido repurposeado*
1. "{{top1_title}}" - {{top1_engagement}} interactions
2. "{{top2_title}}" - {{top2_engagement}} interactions
3. "{{top3_title}}" - {{top3_engagement}} interactions

*ROI de repurposing*
Horas ahorradas estimadas: {{hours_saved}}
Valor equivalente: ${{value_saved}}

Ejercicio práctico

Implementa tu sistema de content repurposing:

  1. Toma un blog post existente y manualmente identifica:

    • 5-10 puntos clave para un thread
    • 3-5 variaciones para LinkedIn
    • 10 tweets individuales

  2. Crea un Zap que:

    • Se dispare con nuevo contenido (RSS o Notion)
    • Genere al menos un formato (thread o posts)
    • Guarde los resultados en Airtable o Sheets

  3. Configura programación automática:

    • Conecta con Buffer o Hootsuite
    • Distribuye el contenido a lo largo de 2 semanas

  4. Crea un reporte básico:

    • Trackea cuántas piezas se generan
    • Mide engagement por formato

Tiempo estimado: 45-60 minutos

Resumen

En esta lección aprendiste a:

  • Transformar un blog post en thread de Twitter automáticamente
  • Extraer clips y quotes de videos para redes sociales
  • Generar múltiples posts de LinkedIn desde un artículo
  • Compilar newsletters automáticas con contenido de la semana
  • Distribuir contenido automáticamente en múltiples canales
  • Medir el ROI del content repurposing

El content repurposing automatizado te permite maximizar el valor de cada pieza de contenido que creas, llegando a más audiencia con menos esfuerzo.

Siguiente módulo: Proyecto Final - Aplicarás todo lo aprendido para construir un sistema completo de automatización para tu negocio.

¿Completaste esta lección?

Marca esta lección como completada. Tu progreso se guardará en tu navegador.

Anterior
Social Media: Publicación programada
Siguiente
Conectar ChatGPT a tus Zaps