> This page is for De cámara a la nube.

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://next.developer.frame.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://next.developer.frame.io/_mcp/server.

# Cómo realizar cargas (conceptos básicos)

## Introducción





Hemos llegado a un punto emocionante en nuestro proceso de integración: cargar activos en Frame.io. En esta guía se explica el proceso básico de carga.





## Requisitos previos

Si aún no lo ha hecho, revise la guía [Implementar C2C: Configuración](./implementing-c2c-setting-up) antes de continuar. Necesitará el `access_token` que se obtiene durante el [proceso de autenticación y autorización](./implementing-c2c-authentication-and-authorization). Para esta guía, usaremos un activo de muestra disponible en [este enlace de Frame.io](https://f.io/Rq1q5CzB). Descargue este archivo para seguir nuestros ejemplos, ya que le permitirá hacer coincidir los valores de nuestros comandos de muestra.

## Paso 1: Crear un activo

Carguemos [nuestro archivo de muestra](https://f.io/Rq1q5CzB), que asumiremos que se creó hace 10 segundos. Primero, debemos crear una referencia de activo en Frame.io:

```shell
{
curl -X POST https://api.frame.io/v2/devices/assets \
    --header 'Authorization: Bearer [access_token]' \
    --header 'Content-Type: application/json' \
    --header 'x-client-version: 2.0.0' \
    --data-binary @- <<'__JSON__' 
        {
            "name": "C2C_TEST_CLIP.mp4", 
            "filetype": "video/mp4", 
            "filesize": 21136250,
            "offset": 10
        }
__JSON__
} | python -m json.tool
```




<Info title="Especificación del punto final de la API">
  La documentación para `/v2/devices/assets` está disponible [aquí](/camera-to-cloud/api-reference/device-asset-create). Aunque el punto final heredado `/v2/assets` aún funciona, recomendamos que las nuevas integraciones utilicen `/v2/devices/assets`.
</Info>

<Info title="Codificación JSON">
  A diferencia de los puntos finales de autenticación que hemos utilizado anteriormente, este punto final acepta codificación `application/json` en lugar de `form/multipart`. También acepta `application/x-www-form-urlencoded`.
</Info>

<Info title="Sintaxis de comandos">
  Este ejemplo utiliza [heredoc](https://linuxize.com/post/bash-heredoc/) para proporcionar la carga útil JSON a `curl` en un formato multilínea legible. El parámetro `--data-binary @-` indica a `curl` que lea datos sin procesar de stdin. Puede obtener más información sobre este enfoque [aquí](https://unix.stackexchange.com/questions/88490/how-do-you-use-output-redirection-in-combination-with-here-documents-and-cat).
</Info>


Examinemos los parámetros de la carga útil JSON:

`name`: El nombre del activo que se muestra en Frame.io. No es necesario que coincida con el nombre del archivo en el disco. `filetype`: El [tipo MIME](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types) del archivo. La mayoría de los lenguajes de programación proporcionan utilidades para detectar los tipos MIME (ejemplos: [Go](https://golangcode.com/get-the-content-type-of-file/), [Python](https://docs.python.org/3/library/mimetypes.html)). `filesize`: El tamaño del archivo en bytes. Nuestro archivo de muestra ocupa aproximadamente 21,1 MB. `offset`: El número de segundos transcurridos desde la creación del archivo. El valor predeterminado es 0 si se omite. Es necesario proporcionar este parámetro, ya que ayuda a determinar si los archivos deben rechazarse si el dispositivo se pone en pausa. Trataremos esto con más detalle en la [guía avanzada sobre las cargas](./how-to-advanced-uploads).

La respuesta tendrá un aspecto similar a este (con algunos campos omitidos):





```json
{
    "_type": "file",
    ...
    "id": "9a280f99-8f4f-46b0-a4b4-ec4c2f95138e",
    ...
    "upload_urls": [
        "https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_01_path]",
        "https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_02_path]"
    ],
    ...
}
```





Llegados a este punto, solo hemos informado a Frame.io de nuestra intención de cargar un archivo; no se han transferido datos de archivo reales. Si revisa la carpeta del dispositivo en su proyecto, verá un marcador de posición del activo en el estado &quot;uploading&quot;.

El campo `upload_urls` contiene las URL en las que cargaremos nuestros fragmentos de archivo. Para nuestro archivo de prueba, deberíamos recibir dos URL de carga.

## Paso 2: Dividir el archivo en fragmentos





La respuesta contenía varias URL de carga. Al cargar en Frame.io, dividimos los archivos en fragmentos y los cargamos por separado, lo que ofrece varias ventajas:




* **Más fiabilidad**: Si un fragmento falla, no hace falta reiniciar toda la carga
* **Cargas más rápidas**: Podemos cargar varios fragmentos en paralelo (se trata en la [guía sobre las cargas avanzadas](./how-to-advanced-uploads))




Para determinar el tamaño óptimo de los fragmentos, use esta fórmula:





**`Python`**

```python title="Python"
# We use math.ceil() to ensure we get the upper bound in the division
chunk_size = math.ceil(float(file.size) / float(len(response.upload_urls)))
```





Para nuestro archivo de muestra, el cálculo es:





**`Python`**

```python title="Python"
math.ceil(21136250 / 2)
# 10568125
```

Esto significa que cada fragmento debe ocupar 10 568 125 bytes. Los tamaños de fragmento suelen rondar los 25 MB, y puede obtener información sobre los cálculos exactos en la [guía avanzada sobre las cargas](./how-to-advanced-uploads).
<Info title="Tamaño del último fragmento">
  Dado que los tamaños de archivo raramente se dividen uniformemente, puede que el fragmento final sea menor que el `chunk_size` calculado. Su implementación debe tener esto en cuenta al leer fragmentos de archivo.
</Info>
 Para esta demostración, usaremos los comandos [head](https://man7.org/linux/man-pages/man1/head.1.html) y [tail](https://man7.org/linux/man-pages/man1/tail.1.html) para extraer los fragmentos de archivo.

## Paso 3: Cargar los fragmentos





Para cargar el primer fragmento:





```shell
head -c 10568125 ~/Downloads/C2C_TEST_CLIP.mp4 | \
curl -X PUT https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_01_path] \
        --include \
        --header 'content-type: video/mp4' \
        --header 'x-amz-acl: private' \
        --data-binary @-
```




<Info title="Sintaxis de comandos">
  El parámetro `--data-binary @-` indica a `curl` que use datos sin procesar de stdin, que provienen del comando `head`.
</Info>


La solicitud necesita estos encabezados:

`content-type`: El mismo valor del tipo MIME utilizado al crear el activo `x-amz-acl`: Para los permisos de AWS S3, se debe establecer siempre en `private`

Una carga correcta devuelve:





```text
HTTP/1.1 100 Continue

HTTP/1.1 200 OK
...
```





De manera similar, cargue el segundo fragmento:





```shell
tail -c 10568125 ~/Downloads/C2C_TEST_CLIP.mp4 | \
curl -X PUT https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_02_path] \
        --include \
        --header 'content-type: video/mp4' \
        --header 'x-amz-acl: private' \
        --data-binary @-
```





Cuando ambas cargas se hayan completado, su activo debería poder reproducirse en Frame.io. 🎉




<Warning title="Errores de carga">
  Al cargar fragmentos, envía datos directamente a AWS S3, no a la API de Frame.io. Las respuestas de error seguirán los formatos de AWS S3 en lugar de los errores estándar de Frame.io. Trataremos la gestión de errores de S3 en la [guía sobre la gestión de errores](/camera-to-cloud/how-to-handle-errors).
</Warning>

<Info title="Orden de los fragmentos">
  


Aunque en teoría es más fácil cargar fragmentos de manera secuencial, en realidad pueden cargarse en cualquier orden. El sistema los ensamblará correctamente independientemente de la secuencia de carga.



</Info>


## Unión de todos los pasos





A continuación, se muestra un ejemplo de pseudocódigo simplificado similar a Python para el proceso de carga completo:





**`Python`**

```python title="Python"
file = open("~/Downloads/C2C_TEST_CLIP.mp4")
mimetype = mimetypes.for_file("~/Downloads/C2C_TEST_CLIP.mp4")[0]
created_at = time.ctime(file.stat.ST_CTIME)

asset = c2c.asset_create(
    name="C2C_TEST_CLIP.mp4", 
    filetype=mimetype, 
    filesize=file.size,
    offset=datetime.now() - created_at,
    channel=0,
)

chunk_size = math.ceil(float(file.size) / float(len(asset.upload_urls)))

for chunk_url in asset.upload_urls:
   chunk = file.read(bytes=chunk_size)
   c2c.upload_chunk(chunk, chunk_url, mimetype)
```

Este ejemplo demuestra el flujo básico sin gestión de errores o cargas paralelas, aspectos que se tratarán en la [guía sobre la gestión de errores](/camera-to-cloud/how-to-handle-errors) y la [guía avanzada sobre las cargas](./how-to-advanced-uploads).

## Próximos pasos

Enhorabuena por cargar correctamente su primer activo en Frame.io. La [guía avanzada sobre las cargas](./how-to-advanced-uploads) tratará los requisitos y las técnicas más sofisticados para preparar las implementaciones para producción. Le recomendamos que se ponga en contacto con nuestro equipo si tiene alguna pregunta y a continuar con la [guía sobre las cargas en tiempo real](./how-to-upload-realtime) para obtener más información sobre cómo cargar activos mientras se están creando.