Upload de arquivos de mídia grandes

Para uploads de arquivos maiores que 10 MB, obtenha uma URL pré-assinada para fazer o upload

GET /media/uploadUrl

cURL

curl \
-H "Authorization: Bearer [API Key]" \
-X GET https://api.ayrshare.com/api/media/uploadUrl?fileName=test.mov&contentType=mov

const API_KEY = "Your API Key";

fetch("https://api.ayrshare.com/api/media/uploadUrl?fileName=test.mov&contentType=mov", {
      method: "GET",
      headers: {
        "Authorization": `Bearer ${API_KEY}`
      }
    })
      .then((res) => res.json())
      .then((json) => console.log(json))
      .catch(console.error);

import requests

headers = {'Authorization': 'Bearer [API_KEY]'}

r = requests.get('https://api.ayrshare.com/api/media/uploadUrl?fileName=test.mov&contentType=mov', headers=headers)

print(r.json())

<?php
require 'vendor/autoload.php';    // Composer auto-loader using Guzzle. See .../guzzlephp.org/en/stable/overview.html

$client = new GuzzleHttp\Client();
$res = $client->request(
    'GET',
    'https://api.ayrshare.com/api/media/uploadUrl?fileName=test.mov&contentType=mov',
    [
        'headers' => [
            'Content-Type'      => 'application/json',
            'Authorization'     => 'Bearer API_KEY'
        ]
    ]
);

echo json_encode(json_decode($res->getBody()), JSON_PRETTY_PRINT);

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web;

namespace MediaUploadUrlGETRequest_csharp
{
    class MediaUploadUrl
    {
        static async Task Main(string[] args)
        {
            string API_KEY = "API_KEY";
            string baseUrl = "https://api.ayrshare.com/api/media/uploadUrl";

            // Build URL with query parameters
            var uriBuilder = new UriBuilder(baseUrl);
            var query = HttpUtility.ParseQueryString(string.Empty);
            query["fileName"] = "test.mov";
            query["contentType"] = "mov";
            uriBuilder.Query = query.ToString();

            using (var client = new HttpClient())
            {
                client.DefaultRequestHeaders.Add("Authorization", "Bearer " + API_KEY);

                try
                {
                    HttpResponseMessage response = await client.GetAsync(uriBuilder.Uri);
                    response.EnsureSuccessStatusCode();
                    string responseBody = await response.Content.ReadAsStringAsync();
                    Console.WriteLine(responseBody);
                }
                catch (HttpRequestException e)
                {
                    Console.WriteLine($"Error: {e.Message}");
                }
            }
        }
    }
}

200: An upload URL and access URL

{
    "accessUrl": "https://media.ayrshare.com/Aswmfs3dIEbwLSdhTlV2/test.mp4",
    "contentType": "video/mp4",
    "uploadUrl": "https://storage.googleapis.com/..."
}

{
  "action": "upload",
  "status": "error",
  "code": 301,
  "message": "The provided content-type 'movd' is not recognized."
}

Para uploads de arquivos maiores que 10 MB, obtenha uma URL pré-assinada para fazer o upload de um arquivo.

• Tamanho máximo de upload: 5 GB.
• URL pré-assinada de upload válida por 30 minutos após ser gerada.

• URL de acesso disponível por 30 dias após o upload. Todas as publicações já publicadas não são afetadas nas redes sociais. Publicações agendadas além desse período resultarão em erros no momento da publicação.

Se você já tem sua mídia acessível por uma URL externa, como um bucket S3, é possível pular o upload dos arquivos para a Ayrshare. Basta fazer um POST para o endpoint /post com sua URL acessível externamente no parâmetro mediaURLs do corpo e o arquivo será enviado automaticamente.

​

Parâmetros do header

​

Parâmetros de query

fileName · string

Se o contentType não estiver presente, então um nome de arquivo completo com extensão é obrigatório.

Nome do arquivo a ser enviado. Deve incluir uma extensão como .png, .jpg, .mov, .mp4, etc.

contentType · string

O content-type da mídia que está sendo enviada. Formatos válidos incluem: mp4, mov, png, jpg ou jpeg.

Por exemplo, se o arquivo for um Quicktime .mov, então o contentType deve ser mov.

Se não estiver presente, será utilizado application/octet-stream.

cURL

curl \
-H "Authorization: Bearer [API Key]" \
-X GET https://api.ayrshare.com/api/media/uploadUrl?fileName=test.mov&contentType=mov

const API_KEY = "Your API Key";

fetch("https://api.ayrshare.com/api/media/uploadUrl?fileName=test.mov&contentType=mov", {
      method: "GET",
      headers: {
        "Authorization": `Bearer ${API_KEY}`
      }
    })
      .then((res) => res.json())
      .then((json) => console.log(json))
      .catch(console.error);

import requests

headers = {'Authorization': 'Bearer [API_KEY]'}

r = requests.get('https://api.ayrshare.com/api/media/uploadUrl?fileName=test.mov&contentType=mov', headers=headers)

print(r.json())

<?php
require 'vendor/autoload.php';    // Composer auto-loader using Guzzle. See .../guzzlephp.org/en/stable/overview.html

$client = new GuzzleHttp\Client();
$res = $client->request(
    'GET',
    'https://api.ayrshare.com/api/media/uploadUrl?fileName=test.mov&contentType=mov',
    [
        'headers' => [
            'Content-Type'      => 'application/json',
            'Authorization'     => 'Bearer API_KEY'
        ]
    ]
);

echo json_encode(json_decode($res->getBody()), JSON_PRETTY_PRINT);

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web;

namespace MediaUploadUrlGETRequest_csharp
{
    class MediaUploadUrl
    {
        static async Task Main(string[] args)
        {
            string API_KEY = "API_KEY";
            string baseUrl = "https://api.ayrshare.com/api/media/uploadUrl";

            // Build URL with query parameters
            var uriBuilder = new UriBuilder(baseUrl);
            var query = HttpUtility.ParseQueryString(string.Empty);
            query["fileName"] = "test.mov";
            query["contentType"] = "mov";
            uriBuilder.Query = query.ToString();

            using (var client = new HttpClient())
            {
                client.DefaultRequestHeaders.Add("Authorization", "Bearer " + API_KEY);

                try
                {
                    HttpResponseMessage response = await client.GetAsync(uriBuilder.Uri);
                    response.EnsureSuccessStatusCode();
                    string responseBody = await response.Content.ReadAsStringAsync();
                    Console.WriteLine(responseBody);
                }
                catch (HttpRequestException e)
                {
                    Console.WriteLine($"Error: {e.Message}");
                }
            }
        }
    }
}

​

Detalhes da resposta

• accessUrl é a URL para acessar o arquivo de mídia após o upload.

• contentType é o content-type definido para a mídia que está sendo enviada. Use-o no header Content-Type ao fazer o upload da mídia.

• uploadUrl é a URL usada para fazer o PUT do arquivo de mídia. Veja abaixo.

​

Exemplos adicionais de endpoint

O processo para fazer upload de arquivos maiores:

• Obtenha uma uploadURL e accessURL pelo endpoint /media/uploadUrl. Veja acima.

• Faça o upload do arquivo via um PUT com Content-Type definido como o contentType retornado.
• Faça o upload da mídia usando --upload-file com um arquivo de mídia e a uploadUrl.
• Em um upload bem-sucedido, será retornada uma resposta 200.

• Após fazer o upload do arquivo de mídia, faça um POST para o endpoint /post com a accessUrl no parâmetro mediaUrls do corpo.

• A URL de upload pré-assinada só pode receber upload uma única vez. Se você enviou um arquivo incorreto, precisará criar uma nova URL de upload. Nenhuma resposta de erro ocorrerá se o arquivo não for enviado com sucesso. Veja abaixo como verificar se a URL existe.

cURL

curl -X PUT \
-H 'Content-Type: video/mp4' \
--upload-file LOCAL_FILE_PATH uploadUrl

const fs = require("fs").promises;
const uploadFileToSignedUrl = async (signedUrl, filePath) => {
    try {
      const fileBuffer = await fs.readFile(filePath);
      const response = await fetch(signedUrl, {
        method: "PUT",
        body: fileBuffer,
        headers: {
          "Content-Type": "video/mp4"
        }
      });

      if (response.ok) {
        console.log("File upload successful:", response.status);
      } else {
        console.error("File upload failed:", response.status);
      }
    } catch (error) {
      console.error("Error uploading file:", error);
    }
};

// Use the signed URL generated from the previous step
const signedUrl = "SIGNED_URL";
const filePath = "LOCAL_FILE_PATH";

uploadFileToSignedUrl(signedUrl, filePath);

import requests

def upload_file_to_signed_url(signed_url, file_path):
    try:
        with open(file_path, 'rb') as file:
            response = requests.put(signed_url, data=file, headers={'Content-Type': 'video/mp4'})

        if response.ok:
            print("File upload successful:", response.status_code)
        else:
            print("File upload failed:", response.status_code)
    except Exception as error:
        print("Error uploading file:", error)

# Use the signed URL generated from the previous step
signed_url = "SIGNED_URL"
file_path = "LOCAL_FILE_PATH"

upload_file_to_signed_url(signed_url, file_path)

<?php

function uploadFileToSignedUrl($signedUrl, $filePath) {
    try {
        $fileHandle = fopen($filePath, 'rb');
        if ($fileHandle === false) {
            throw new Exception('Cannot open the file');
        }

        $ch = curl_init($signedUrl);

        curl_setopt($ch, CURLOPT_PUT, true);
        curl_setopt($ch, CURLOPT_INFILE, $fileHandle);
        curl_setopt($ch, CURLOPT_INFILESIZE, filesize($filePath));
        curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: video/mp4'));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if ($httpCode == 200) {
            echo "File upload successful: " . $httpCode;
        } else {
            echo "File upload failed: " . $httpCode;
        }

        fclose($fileHandle);
        curl_close($ch);
    } catch (Exception $e) {
        echo "Error uploading file: " . $e->getMessage();
    }
}

// Use the signed URL generated from the previous step
$signedUrl = "SIGNED_URL";
$filePath = "LOCAL_FILE_PATH";

uploadFileToSignedUrl($signedUrl, $filePath);
?>

using System;
using System.Net.Http;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string signedUrl = "SIGNED_URL"; // Replace with your signed URL
        string filePath = "LOCAL_FILE_PATH"; // Replace with your file path

        try
        {
            await UploadFileToSignedUrl(signedUrl, filePath);
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error uploading file: " + ex.Message);
        }
    }

    static async Task UploadFileToSignedUrl(string signedUrl, string filePath)
    {
        using (var client = new HttpClient())
        using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
        using (var content = new StreamContent(fileStream))
        {
            content.Headers.Add("Content-Type", "video/mp4");

            var response = await client.PutAsync(signedUrl, content);

            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("File upload successful: " + response.StatusCode);
            }
            else
            {
                Console.WriteLine("File upload failed: " + response.StatusCode);
            }
        }
    }
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpRequest.BodyPublishers;
import java.nio.file.Path;
import java.io.IOException;
import java.nio.file.Files;

public class FileUploader {

    public static void main(String[] args) {
        String signedUrl = "SIGNED_URL"; // Replace with your signed URL
        String filePath = "LOCAL_FILE_PATH"; // Replace with your file path

        try {
            uploadFileToSignedUrl(signedUrl, filePath);
        } catch (IOException | InterruptedException e) {
            System.out.println("Error uploading file: " + e.getMessage());
        }
    }

    private static void uploadFileToSignedUrl(String signedUrl, String filePath) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(signedUrl))
                .header("Content-Type", "image/jpg")
                .PUT(BodyPublishers.ofFile(Path.of(filePath)))
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() == 200) {
            System.out.println("File upload successful: " + response.statusCode());
        } else {
            System.out.println("File upload failed: " + response.statusCode());
        }
    }
}

Certifique-se de que o contentType definido ao criar a uploadUrl corresponda ao Content-Type e ao tipo do arquivo ao fazer o PUT do arquivo. Por exemplo, se você definir o contentType como “image/png” ao criar a uploadUrl, certifique-se de definir Content-Type: image/png e que o arquivo enviado termine em .png.

Em um upload bem-sucedido, será retornada uma resposta 200.

​

Exemplo de upload de arquivo binário em Node.js

Aqui está um exemplo de upload de um arquivo de mídia binário usando Node com JavaScript:

const fs = require("fs");
const request = require("request");

const API_KEY = "Your API Key";
const fileName = "test.png";
const endpoint = `https://api.ayrshare.com/api/media/uploadUrl?fileName=${fileName}&contentType=png`;

const run = async () => {
  request.get(
    {
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${API_KEY}`
      },
      url: endpoint
    },
    (err, res, body) => {
      if (err) {
        return console.error(err);
      }

      const json = JSON.parse(body);
      console.log("Upload URL:", json);

      return fs.createReadStream(`./${fileName}`).pipe(
        request.put(
          json.uploadUrl,
          {
            headers: {
              "Content-Type": json.contentType
            }
          },
          (err, httpsResponse, body) => {
            if (err) {
              console.error("err", err);
            } else {
              console.log(body);
            }
          }
        )
      );
    }
  );
};

run();

​

Exemplo de upload de arquivo binário no Postman

Você também pode usar o Postman para fazer o upload do arquivo binário para a uploadUrl.

No Postman:

1. Selecione o método HTTP PUT.
2. Cole sua uploadUrl no campo de URL. Observe que a URL expira após uma hora e só pode ser usada uma vez. Se você fizer uma chamada e ela falhar, será necessário regenerar a uploadUrl.
3. Em Headers, defina o Content-Type como o content type retornado no endpoint /uploadUrl. Por exemplo: Content-Type: image/png.
4. Selecione Body -> binary e escolha o arquivo a ser enviado.
5. Pressione Send.
6. Importante: nenhuma resposta será retornada, portanto você deve verificar se o upload foi bem-sucedido abrindo a accessUrl retornada pelo endpoint /uploadUrl em um navegador. Você também pode usar o endpoint de verificação de URL.

Arquivo JSON de exemplo do Postman

200: An upload URL and access URL

{
    "accessUrl": "https://media.ayrshare.com/Aswmfs3dIEbwLSdhTlV2/test.mp4",
    "contentType": "video/mp4",
    "uploadUrl": "https://storage.googleapis.com/..."
}

{
  "action": "upload",
  "status": "error",
  "code": 301,
  "message": "The provided content-type 'movd' is not recognized."
}