> This page is for Camera to Cloud.

> 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.

# Instruções: Como fazer upload (básico)

## Introdução





Chegamos agora a um marco emocionante em nossa jornada de integração: o upload de recursos para o Frame.io.Este guia irá orientá-lo pelo processo básico de upload.





## Pré-requisitos

Caso ainda não tenha feito isso, revise o guia [Implementação do C2C: Configuração](./implementing-c2c-setting-up) antes de prosseguir.Você precisará do `access_token` obtido durante o [processo de autenticação e autorização](./implementing-c2c-authentication-and-authorization).Para este guia, usaremos um recurso de teste de exemplo disponível [neste link do Frame.io](https://f.io/Rq1q5CzB).Baixe este arquivo para acompanhar nossos exemplos, pois isso permitirá que você utilize os mesmos valores dos nossos comandos de exemplo.

## Etapa 1: criar um recurso

Vamos fazer o upload do [nosso arquivo de exemplo](https://f.io/Rq1q5CzB), que vamos supor que tenha sido criado há 10 segundos.Primeiro, precisamos criar uma referência de recurso no 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="Especificação do ponto de acesso da API">
  A documentação para `/v2/devices/assets` pode ser [encontrada aqui](/camera-to-cloud/api-reference/device-asset-create).Embora o ponto de acesso legado `/v2/assets` ainda funcione, recomendamos que novas integrações utilizem `/v2/devices/assets`.
</Info>

<Info title="Codificação JSON">
  Ao contrário dos pontos de acesso de autenticação que usamos anteriormente, este ponto de acesso aceita a codificação `application/json` em vez de `form/multipart`.Ele também aceita `application/x-www-form-urlencoded`.
</Info>

<Info title="Sintaxe do comando">
  Este exemplo usa [heredoc](https://linuxize.com/post/bash-heredoc/) para fornecer o conteúdo JSON ao `curl` em um formato legível de várias linhas.O parâmetro `--data-binary @-` instrui o `curl` a ler dados brutos do stdin.Saiba mais sobre essa abordagem [aqui](https://unix.stackexchange.com/questions/88490/how-do-you-use-output-redirection-in-combination-with-here-documents-and-cat).
</Info>


Vamos examinar os parâmetros do conteúdo JSON:

`name`: o nome do ativo exibido no Frame.io.Não é necessário que ele corresponda ao nome do arquivo no disco.`filetype`: o [tipo MIME](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types) do arquivo.A maioria das linguagens de programação oferece utilitários para detecção de tipo MIME (exemplos: [Go](https://golangcode.com/get-the-content-type-of-file/), [Python](https://docs.python.org/3/library/mimetypes.html)).`filesize`: o tamanho do arquivo em bytes.Nosso arquivo de exemplo tem aproximadamente 21,1 MB.`offset`: o número de segundos desde que o arquivo foi criado.O valor padrão é 0, caso seja omitido.Esse parâmetro deve ser fornecido, pois ajuda a determinar se os arquivos devem ser rejeitados devido à pausa do dispositivo.Abordaremos isso com mais detalhes no [guia avançado de upload](./how-to-advanced-uploads).

A resposta terá uma aparência semelhante a esta (com alguns 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]"
    ],
    ...
}
```





Neste momento, apenas informamos ao Frame.io nossa intenção de fazer o upload de um arquivo. Nenhum dado real do arquivo foi transferido.Se você verificar a pasta do seu dispositivo no projeto, verá um recurso provisório no estado &quot;em upload&quot;.

O campo `upload_urls` contém as URLs para onde faremos o upload dos blocos do nosso arquivo.Para o nosso arquivo de teste, devemos receber duas URLs de upload.

## Etapa 2: dividir o arquivo em blocos





A resposta continha várias URLs de upload.Ao fazer upload para o Frame.io, dividimos os arquivos em blocos e os enviamos separadamente, o que traz várias vantagens:




* **Maior confiabilidade**: se um bloco falhar, não precisamos reiniciar todo o upload
* **Uploads mais rápidos**: podemos enviar vários blocos em paralelo (conforme explicado no [guia de uploads avançados](./how-to-advanced-uploads))




Para determinar o tamanho ideal dos blocos, 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 nosso arquivo de exemplo, o cálculo é:





**`Python`**

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

Isso significa que cada bloco deve ter 10.568.125 bytes.Os tamanhos dos blocos geralmente giram em torno de 25 MB, com cálculos exatos abordados no [guia de uploads avançados](./how-to-advanced-uploads).
<Info title="Tamanho do último bloco">
  Como os tamanhos dos arquivos raramente se dividem uniformemente, o bloco final pode ser menor do que o `chunk_size` calculado.Sua implementação deve levar isso em consideração ao ler os blocos do arquivo.
</Info>
 Para esta demonstração, usaremos os comandos [head](https://man7.org/linux/man-pages/man1/head.1.html) e [tail](https://man7.org/linux/man-pages/man1/tail.1.html) para extrair os blocos do arquivo.

## Etapa 3: fazer upload dos blocos





Para fazer upload do primeiro bloco:





```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="Sintaxe do comando">
  O parâmetro `--data-binary @-` instrui o `curl` a usar dados brutos do stdin, que vêm do comando `head`.
</Info>


A solicitação requer estes cabeçalhos:

`content-type`: o mesmo valor de tipo MIME usado ao criar o ativo `x-amz-acl`: Para permissões do AWS S3, defina sempre como `private`

Um upload bem-sucedido retorna:





```text
HTTP/1.1 100 Continue

HTTP/1.1 200 OK
...
```





Da mesma forma, faça o upload do segundo bloco:





```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 @-
```





Após a conclusão de ambos os uploads, seu ativo deverá estar pronto para reprodução no Frame.io!🎉




<Warning title="Erros de upload">
  Ao fazer o upload de blocos, você está enviando dados diretamente para o AWS S3, e não para a API do Frame.io.As respostas de erro seguirão os formatos do AWS S3, em vez dos erros padrão do Frame.io.Abordaremos o tratamento de erros do S3 no [guia de tratamento de erros](/camera-to-cloud/how-to-handle-errors).
</Warning>

<Info title="Ordem dos blocos">
  


Embora seja conceitualmente mais simples fazer o upload dos blocos sequencialmente, na prática eles podem ser enviados em qualquer ordem.O sistema os montará corretamente, independentemente da sequência de envio.



</Info>


## Reunindo tudo





Aqui está um exemplo simplificado de pseudocódigo semelhante ao Python para o processo completo de upload:





**`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 exemplo demonstra o fluxo básico sem tratamento de erros ou uploads paralelos, que serão abordados nos guias de [tratamento de erros](/camera-to-cloud/how-to-handle-errors) e [uploads avançados](./how-to-advanced-uploads).

## Próximas etapas

Parabéns por ter realizado com sucesso o upload do seu primeiro recurso no Frame.io!O [guia de uploads avançados](./how-to-advanced-uploads) abordará técnicas mais sofisticadas e requisitos para implementações prontas para produção.Recomendamos que você entre em contato com nossa equipe caso tenha alguma dúvida e consulte o [guia de uploads em tempo real](./how-to-upload-realtime) para saber mais sobre como fazer o upload de recursos à medida que eles são criados.