Late API: Programa tu Contenido en Redes Sociales con Código Real
Aprende a integrar Late API en tus proyectos con TypeScript. Scheduling automatizado, pipelines con AI y ejemplos de código reales para Instagram y TikTok.
Sigues Abriendo el Dashboard a Mano. En 2026.
Tienes un pipeline de contenido. Generas posts con AI, los revisas, y luego... los pegas manualmente en Late.
Eso no es automatización. Es trabajo manual con pasos extra.
*El problema real no es Late. Es que nunca has integrado su API en tu stack.*
Late es una herramienta de scheduling para Instagram, TikTok, Pinterest y LinkedIn. Pero tiene una API REST que te permite publicar, programar y gestionar contenido directamente desde tu código. Sin dashboards. Sin copy-paste. Sin contexto switching.
Este artículo te muestra cómo construir una integración real con Late API, desde la autenticación hasta el scheduling automatizado.
---
Por Qué los Developers Ignoran Late API
La narrativa habitual es que herramientas como Late son para marketers, no para developers.
Eso es un error de categorización que te cuesta tiempo cada semana.
Si estás construyendo un SaaS, un newsletter, un proyecto de contenido o un AI agent que genera assets visuales — *necesitas una capa de distribución programática*. Late API es esa capa para social media visual.
El flujo sin API:
❌ Generas imagen con Replicate → la descargas → abres Late → subes manualmente → escribes caption → programas → repites x20 posts
El flujo con API:
✅ Generas imagen con Replicate → llamas a Late API → programas con caption, hashtags y hora → next
La diferencia no es comodidad. Es la diferencia entre un sistema que escala y uno que te encadena.
---
Autenticación: El Primer Obstáculo
Late API usa OAuth 2.0 para autenticación. El flujo estándar te genera un `access_token` que usas en cada request.
Lo más práctico para uso server-side es generar un token personal desde el dashboard de Late y usarlo directamente en tus variables de entorno.
```bash
.env
LATE_API_TOKEN=tu_token_aqui
LATE_PROFILE_ID=id_de_tu_perfil
```
Nunca hardcodees el token en el código. Usa siempre variables de entorno, especialmente si haces deploy en Vercel, Railway o cualquier plataforma cloud.
---
Estructura Básica de un Request a Late API
Todos los requests van a `https://api.late.so/v1/`. El header de autenticación es siempre el mismo:
```typescript
const LATE_BASE_URL = 'https://api.late.so/v1';
const headers = {
'Authorization': `Bearer ${process.env.LATE_API_TOKEN}`,
'Content-Type': 'application/json',
};
```
Simple. Sin librerías extra. Sin SDKs que mantener. Un fetch wrapper es suficiente para el 90% de los casos.
---
Implementa: Scheduling Automatizado de Posts
1. Crea un Post Programado
Este es el endpoint más importante. Te permite subir una imagen, escribir un caption y definir cuándo se publica:
```typescript
interface LatePost {
profileId: string;
caption: string;
mediaUrl: string;
scheduledAt: string; // ISO 8601
hashtags?: string[];
}
async function schedulePost(post: LatePost): Promise<{ id: string; status: string }> {
const response = await fetch(`${LATE_BASE_URL}/posts`, {
method: 'POST',
headers,
body: JSON.stringify({
profile_id: post.profileId,
caption: post.caption,
media_url: post.mediaUrl,
scheduled_at: post.scheduledAt,
hashtags: post.hashtags ?? [],
}),
});
if (!response.ok) {
const error = await response.json();
throw new Error(`Late API error: ${error.message}`);
}
return response.json();
}
// Uso real
const result = await schedulePost({
profileId: process.env.LATE_PROFILE_ID!,
caption: 'Nuevo tutorial sobre Late API 🚀',
mediaUrl: 'https://tu-cdn.com/imagen.jpg',
scheduledAt: new Date(Date.now() + 24 60 60 * 1000).toISOString(), // mañana
hashtags: ['#developer', '#api', '#automation'],
});
console.log('Post programado:', result.id);
```
Fíjate en el manejo de errores. Late API devuelve mensajes descriptivos. Captúralos siempre.
2. Consulta Posts Programados
Necesitas saber qué tienes en cola antes de añadir más contenido. Este endpoint te devuelve todos los posts pendientes:
```typescript
async function getScheduledPosts(profileId: string) {
const params = new URLSearchParams({
profile_id: profileId,
status: 'scheduled',
});
const response = await fetch(`${LATE_BASE_URL}/posts?${params}`, { headers });
if (!response.ok) throw new Error('Error fetching posts');
const data = await response.json();
return data.posts as Array<{
id: string;
caption: string;
scheduled_at: string;
status: string;
}>;
}
```
Usa esto para detectar huecos en tu calendario editorial antes de programar el siguiente batch.
---
El Pattern Real: AI + Late API
El caso de uso que más valor genera es conectar un modelo de AI con Late API en un pipeline completo.
Este es el flujo que puedes construir con Claude, Replicate y Late:
```typescript
import Anthropic from '@anthropic-ai/sdk';
async function generateAndSchedulePost(topic: string, scheduleDate: Date) {
const client = new Anthropic();
// Step 1: Genera el caption con Claude
const message = await client.messages.create({
model: 'claude-opus-4-5',
max_tokens: 300,
messages: [{
role: 'user',
content: `Escribe un caption para Instagram sobre: ${topic}.
Máximo 150 caracteres. Tono directo y sin fluff.
Incluye 3 hashtags relevantes al final.`,
}],
});
const caption = message.content[0].type === 'text'
? message.content[0].text
: '';
// Step 2: Aquí conectarías Replicate para generar la imagen
// const imageUrl = await generateImage(topic);
const imageUrl = 'https://tu-cdn.com/generated-image.jpg'; // placeholder
// Step 3: Programa en Late
const post = await schedulePost({
profileId: process.env.LATE_PROFILE_ID!,
caption,
mediaUrl: imageUrl,
scheduledAt: scheduleDate.toISOString(),
});
return post;
}
// Programa 7 posts de una vez
const topics = [
'TypeScript tips para producción',
'Cómo estructurar un monorepo',
'Edge Functions vs serverless clásico',
'Testing de AI agents',
'Database migrations sin downtime',
'Rate limiting en APIs REST',
'Monitoring con OpenTelemetry',
];
const startDate = new Date();
startDate.setHours(9, 0, 0, 0); // 9am
for (let i = 0; i < topics.length; i++) {
const scheduleDate = new Date(startDate);
scheduleDate.setDate(startDate.getDate() + i);
await generateAndSchedulePost(topics[i], scheduleDate);
console.log(`✅ Post ${i + 1}/7 programado para ${scheduleDate.toLocaleDateString('es-ES')}`);
}
```
En 30 líneas de código tienes una semana de contenido generado y programado automáticamente.
Eso es lo que significa construir un sistema. No abrir un dashboard.
---
Errores Comunes con Late API
❌ No validar el formato de imagen antes de enviar
Late tiene restricciones por red social. Instagram requiere ratios específicos. Valida dimensiones antes del request.
✅ Usa sharp en Node.js para verificar y redimensionar antes de subir
❌ Programar sin respetar las ventanas horarias de la plataforma
Instagram penaliza posting en horas de baja actividad. Consulta tu analytics antes de definir `scheduled_at`.
✅ Usa los datos de Late Analytics API para encontrar el mejor horario de tu audiencia
❌ Ignorar rate limits
Late API tiene límites por plan. Si haces bulk scheduling, añade un delay entre requests.
✅ Implementa un `sleep` de 200ms entre requests en loops
```typescript
const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
for (const topic of topics) {
await generateAndSchedulePost(topic, date);
await sleep(200); // Respeta el rate limit
}
```
---
Deploy en Producción: Dónde Ejecutar Este Pipeline
Este pipeline puede vivir en varios sitios según tu arquitectura:
→ Vercel Cron Jobs: Si ya tienes un proyecto Next.js, añade un endpoint `/api/cron/schedule-posts` y configura el cron en `vercel.json`. Ideal para scheduling semanal.
→ Supabase Edge Functions + pg_cron: Si tu contenido viene de base de datos, ejecuta el pipeline directamente desde Supabase con triggers o cron jobs nativos.
→ Railway + Node.js: Para pipelines más complejos con múltiples pasos y logging detallado. Más control, más mantenimiento.
La elección depende de dónde vive ya tu stack. *No añadas infraestructura nueva para algo que puede vivir dentro de lo que ya tienes.*
---
Takeaways
→ Late API es una herramienta de automatización real, no solo un dashboard de marketing
→ El flujo completo (generación AI → imagen → scheduling) cabe en menos de 50 líneas de TypeScript
→ Autenticación con Bearer token en variables de entorno — nunca hardcodeado
→ Valida imágenes, respeta rate limits, captura errores descriptivos
→ El mejor lugar para desplegar este pipeline es dentro de tu infraestructura existente
El contenido no escalable no es un problema de creatividad. Es un problema de arquitectura.
Conéctalo una vez. Que corra solo.
Lee el artículo completo en brianmenagomez.com
Más sobre mis servicios en brianmenagomez.com
Herramientas: Conversor IAE CNAE · Gestorias cerca de ti · Calculadora IRPF