Carga de contenido multimedia fragmentada

En esta guía aprenderás a cargar videos y archivos multimedia grandes mediante el flujo de trabajo de carga fragmentada. Para cargas de video o contenido multimedia de gran tamaño, debes:

INIT — Inicializar la carga y obtener un media_id
APPEND — Cargar cada fragmento del archivo
FINALIZE — Completar la carga
STATUS — (Si es necesario) Esperar a que finalice el procesamiento

Consulta este código de ejemplo para ver un ejemplo completo en Python.

Paso 1: Inicializar la carga (INIT)

Inicia la sesión de carga para obtener un media_id:

cURL

curl -X POST "https://api.x.com/2/media/upload" \
  -H "Authorization: Bearer $USER_ACCESS_TOKEN" \
  -H "Content-Type: multipart/form-data" \
  -F "command=INIT" \
  -F "media_type=video/mp4" \
  -F "total_bytes=1048576" \
  -F "media_category=amplify_video"

from xdk import Client

client = Client(bearer_token="YOUR_USER_ACCESS_TOKEN")

# Inicializar la carga en fragmentos
response = client.media.init_upload(
    media_type="video/mp4",
    total_bytes=1048576,
    media_category="amplify_video"
)

media_id = response.data.id
print(f"Media ID: {media_id}")

import { Client } from "@xdevplatform/xdk";

const client = new Client({ accessToken: "YOUR_USER_ACCESS_TOKEN" });

// Inicializar la carga en fragmentos
const response = await client.media.initUpload({
  mediaType: "video/mp4",
  totalBytes: 1048576,
  mediaCategory: "amplify_video",
});

const mediaId = response.data?.id;
console.log(`Media ID: {mediaId}`);

Respuesta:

{
  "data": {
    "id": "1880028106020515840",
    "media_key": "13_1880028106020515840",
    "expires_after_secs": 1295999
  }
}

Paso 2: Cargar fragmentos (APPEND)

Carga cada fragmento del archivo. Por ejemplo, divide un archivo de 3 MB en 3 fragmentos:

cURL

curl -X POST "https://api.x.com/2/media/upload" \
  -H "Authorization: Bearer $USER_ACCESS_TOKEN" \
  -H "Content-Type: multipart/form-data" \
  -F "command=APPEND" \
  -F "media_id=1880028106020515840" \
  -F "segment_index=0" \
  -F "media=@/path/to/chunk1.mp4"

from xdk import Client

client = Client(bearer_token="YOUR_USER_ACCESS_TOKEN")

# Cargar fragmentos
chunk_size = 1024 * 1024  # fragmentos de 1 MB

with open("video.mp4", "rb") as f:
    segment_index = 0
    while True:
        chunk = f.read(chunk_size)
        if not chunk:
            break
        
        client.media.append_upload(
            media_id=media_id,
            segment_index=segment_index,
            media=chunk
        )
        segment_index += 1
        print(f"Uploaded chunk {segment_index}")

import { Client } from "@xdevplatform/xdk";
import fs from "fs";

const client = new Client({ accessToken: "YOUR_USER_ACCESS_TOKEN" });

// Cargar fragmentos
const chunkSize = 1024 * 1024; // fragmentos de 1 MB
const fileBuffer = fs.readFileSync("video.mp4");

let segmentIndex = 0;
for (let offset = 0; offset < fileBuffer.length; offset += chunkSize) {
  const chunk = fileBuffer.slice(offset, offset + chunkSize);
  
  await client.media.appendUpload({
    mediaId,
    segmentIndex,
    media: chunk,
  });
  
  console.log(`Uploaded chunk ${segmentIndex + 1}`);
  segmentIndex++;
}

Ventajas de usar fragmentos:

Mayor fiabilidad en redes lentas
Las cargas se pueden pausar y reanudar
Los fragmentos que fallen se pueden volver a intentar de forma individual

Paso 3: Finalizar la carga (FINALIZE)

Completa la carga después de enviar todos los fragmentos:

cURL

curl -X POST "https://api.x.com/2/media/upload" \
  -H "Authorization: Bearer $USER_ACCESS_TOKEN" \
  -H "Content-Type: multipart/form-data" \
  -F "command=FINALIZE" \
  -F "media_id=1880028106020515840"

from xdk import Client

client = Client(bearer_token="YOUR_USER_ACCESS_TOKEN")

# Finalizar la carga
response = client.media.finalize_upload(media_id=media_id)

print(f"Processing state: {response.data.processing_info.state}")

import { Client } from "@xdevplatform/xdk";

const client = new Client({ accessToken: "YOUR_USER_ACCESS_TOKEN" });

// Finalizar la carga
const response = await client.media.finalizeUpload({ mediaId });

console.log(`Processing state: ${response.data?.processing_info?.state}`);

Respuesta:

{
  "data": {
    "id": "1880028106020515840",
    "media_key": "13_1880028106020515840",
    "size": 1048576,
    "expires_after_secs": 86400,
    "processing_info": {
      "state": "pending",
      "check_after_secs": 1
    }
  }
}

Si se devuelve processing_info, continúa con el Paso 4 para esperar a que finalice el procesamiento. Si no, el contenido multimedia está listo para usarse.

Paso 4: Comprobar el estado (STATUS)

Si se devolvió processing_info, realiza consultas periódicas hasta que finalice el procesamiento:

cURL

curl "https://api.x.com/2/media/upload?command=STATUS&media_id=1880028106020515840" \
  -H "Authorization: Bearer $USER_ACCESS_TOKEN"

from xdk import Client
import time

client = Client(bearer_token="YOUR_USER_ACCESS_TOKEN")

# Espera a que finalice el procesamiento
while True:
    response = client.media.get_status(media_id=media_id)
    state = response.data.processing_info.state
    
    if state == "succeeded":
        print("¡Contenido multimedia listo!")
        break
    elif state == "failed":
        print("El procesamiento falló")
        break
    else:
        check_after = response.data.processing_info.check_after_secs
        print(f"Procesando... se volverá a comprobar en {check_after}s")
        time.sleep(check_after)

import { Client } from "@xdevplatform/xdk";

const client = new Client({ accessToken: "YOUR_USER_ACCESS_TOKEN" });

// Espera a que finalice el procesamiento
while (true) {
  const response = await client.media.getStatus({ mediaId });
  const state = response.data?.processing_info?.state;
  
  if (state === "succeeded") {
    console.log("¡Contenido multimedia listo!");
    break;
  } else if (state === "failed") {
    console.log("El procesamiento falló");
    break;
  } else {
    const checkAfter = response.data?.processing_info?.check_after_secs ?? 1;
    console.log(`Procesando... se volverá a comprobar en ${checkAfter}s`);
    await new Promise((r) => setTimeout(r, checkAfter * 1000));
  }
}

Estados de procesamiento: pending → in_progress → succeeded o failed

Paso 5: Crea una Publicación con contenido multimedia

Cuando haya finalizado el procesamiento, crea una Publicación con el contenido multimedia:

cURL

curl -X POST "https://api.x.com/2/tweets" \
  -H "Authorization: Bearer $USER_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Check out this video!",
    "media": {
      "media_ids": ["1880028106020515840"]
    }
  }'

from xdk import Client

client = Client(bearer_token="YOUR_USER_ACCESS_TOKEN")

# Crear Publicación con contenido multimedia
response = client.posts.create(
    text="Check out this video!",
    media={"media_ids": [media_id]}
)

print(f"Posted: {response.data.id}")

import { Client } from "@xdevplatform/xdk";

const client = new Client({ accessToken: "YOUR_USER_ACCESS_TOKEN" });

// Crear Publicación con contenido multimedia
const response = await client.posts.create({
  text: "Check out this video!",
  media: { mediaIds: [mediaId] },
});

console.log(`Posted: ${response.data?.id}`);

Categorías de medios

Categoría	Descripción
`tweet_image`	Imagen para una Publicación
`tweet_gif`	GIF animado para una Publicación
`tweet_video`	Video para una Publicación
`amplify_video`	Video de Amplify

Próximos pasos

Mejores prácticas

Requisitos y limitaciones de archivos

Crear Publicaciones

Publicación con contenido multimedia

Referencia de la API

Documentación completa del endpoint

Descripción general

Publicaciones

Usuarios

Mensajes directos

Me gusta

Listas

Spaces

Comunidades

Notas de la comunidad

Tendencias

Noticias

Contenido multimedia

Actividad en X

Uso

Conexiones de streaming

Cumplimiento

Enterprise v2

Flujos de Me gusta

GNIP 2.0

Carga de contenido multimedia fragmentada

Paso 1: Inicializar la carga (INIT)

Paso 2: Cargar fragmentos (APPEND)

Paso 3: Finalizar la carga (FINALIZE)

Paso 4: Comprobar el estado (STATUS)

Paso 5: Crea una Publicación con contenido multimedia

Categorías de medios

Próximos pasos

Mejores prácticas

Crear Publicaciones

Referencia de la API