> ## Documentation Index
> Fetch the complete documentation index at: https://www.ayrshare.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Große Mediendateien hochladen

> Für Datei-Uploads größer als 10 MB eine presigned URL zum Hochladen einer Datei erhalten

export const HeaderAPI = ({noProfileKey, profileKeyRequired}) => <>
    <ParamField header="Authorization" type="string" required>
      <a href="/apis/overview#authorization">API Key</a> of the Primary Profile.
      <br />
      <br />
      Format: <code>Authorization: Bearer API_KEY</code>
    </ParamField>
    {!noProfileKey && (profileKeyRequired ? <ParamField header="Profile-Key" type="string" required>
          <a href="/apis/overview#profile-key-format">Profile Key</a> of a User Profile.
          <br />
          <br />
          Format: <code>Profile-Key: PROFILE_KEY</code>
        </ParamField> : <ParamField header="Profile-Key" type="string">
          <a href="/apis/overview#profile-key-format">Profile Key</a> of a User Profile.
          <br />
          <br />
          Format: <code>Profile-Key: PROFILE_KEY</code>
        </ParamField>)}
  </>;

export const PlansAvailable = ({plans = [], maxPackRequired}) => {
  let displayPlans = plans;
  if (plans && plans.length === 1) {
    const lowerCasePlan = plans[0].toLowerCase();
    if (lowerCasePlan === "business") {
      displayPlans = ["Launch", "Business", "Enterprise"];
    } else if (lowerCasePlan === "premium") {
      displayPlans = ["Premium", "Launch", "Business", "Enterprise"];
    }
  }
  return <Note>
Available on {displayPlans.length === 1 ? "the " : ""}
{displayPlans.join(", ").replace(/\b\w/g, l => l.toUpperCase())}{" "}
{displayPlans.length > 1 ? "plans" : "plan"}.

{maxPackRequired && <span onClick={() => window.open('https://www.ayrshare.com/docs/additional/maxpack', '_self')} className="flex items-center mt-2 cursor-pointer">
 <span className="px-1.5 py-0.5 rounded text-sm" style={{
    backgroundColor: '#C264B6',
    color: 'white',
    fontSize: '12px'
  }}>
   Max Pack required
 </span>
</span>}
</Note>;
};

<PlansAvailable plans={["premium"]} maxPackRequired={false} />

Für Datei-Uploads größer als 10 MB erhalten Sie eine presigned URL zum Hochladen einer Datei.

<ul class="custom-bullets">
  <li>Maximale Upload-Dateigröße 5 GB.</li>
  <li>Die presigned Upload-URL ist nach ihrer Erstellung 30 Minuten lang gültig.</li>

  <li>
    Die Zugriffs-URL ist nach dem Upload 30 Tage lang verfügbar. Bereits veröffentlichte Beiträge sind in den
    sozialen Netzwerken davon nicht betroffen. Geplante Beiträge außerhalb dieses Zeitraums führen zum Zeitpunkt der
    Veröffentlichung zu Fehlern.
  </li>
</ul>

<Tip>Wenn Ihre Medien bereits über eine externe URL zugänglich sind, etwa über einen S3-Bucket, können Sie den Upload der Dateien zu Ayrshare überspringen. Senden Sie einfach eine POST-Anfrage an den `/post`-Endpunkt mit Ihrer extern zugänglichen URL im Body-Parameter `mediaURLs`, und Ihre Datei wird automatisch hochgeladen.</Tip>

## Header-Parameter

<HeaderAPI noProfileKey={true} />

## Query-Parameter

<ParamField query="fileName" type="string">
  Wenn `contentType` nicht vorhanden ist, ist ein vollständiger Dateiname mit Erweiterung erforderlich.

  Name der hochzuladenden Datei. Muss eine Erweiterung wie .png, .jpg, .mov, .mp4 usw. enthalten.
</ParamField>

<ParamField query="contentType" type="string">
  Der Content-Type der hochzuladenden Medien. Gültige Formate sind: `mp4`, `mov`, `png`, `jpg` oder `jpeg`.

  Beispiel: Wenn die Datei eine Quicktime-.mov-Datei ist, sollte der contentType `mov` lauten.

  Falls nicht vorhanden, wird application/octet-stream verwendet.
</ParamField>

<RequestExample>
  ```bash cURL theme={"system"}
  curl \
  -H "Authorization: Bearer [API Key]" \
  -X GET https://api.ayrshare.com/api/media/uploadUrl?fileName=test.mov&contentType=mov
  ```

  ```javascript JavaScript theme={"system"}
  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);
  ```

  ```python Python theme={"system"}
  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 PHP theme={"system"}
  <?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);
  ```

  ```csharp C# theme={"system"}
  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}");
                  }
              }
          }
      }
  }
  ```
</RequestExample>

## Details zur Antwort

<ul class="custom-bullets">
  <li>`accessUrl` ist die URL, unter der nach dem Upload auf die Mediendatei zugegriffen werden kann.</li>

  <li>
    `contentType` ist der Content-Type, der für die hochzuladenden Medien gesetzt wurde. Verwenden Sie ihn im Header
    *Content-Type* beim Hochladen der Medien.
  </li>

  <li>`uploadUrl` ist die URL, an die die Mediendatei per *PUT* gesendet wird. Siehe unten.</li>
</ul>

### Weitere Endpunkt-Beispiele

Der Prozess zum Hochladen größerer Dateien:

<ul class="custom-bullets">
  <li>
    Rufen Sie über den Endpunkt `/media/uploadUrl` eine `uploadURL` und eine `accessURL` ab. Siehe oben.
  </li>

  <li>Laden Sie die Datei per *PUT* hoch, mit *Content-Type* auf den zurückgegebenen `contentType` gesetzt.</li>
  <li>Laden Sie die Medien hoch, indem Sie `--upload-file` mit einer Mediendatei und der `uploadUrl` verwenden.</li>
  <li>Bei einem erfolgreichen Upload wird eine `200`-Antwort zurückgegeben.</li>

  <li>
    Senden Sie nach dem Hochladen der Mediendatei eine POST-Anfrage an den `/post`-Endpunkt mit der `accessUrl` im
    Body-Parameter `mediaUrls`.
  </li>

  <li>
    **Auf die presigned Upload-URL kann nur einmal hochgeladen werden**. Wenn Sie eine fehlerhafte Datei gesendet haben, müssen Sie
    eine neue Upload-URL erstellen. Es wird keine Fehlerantwort zurückgegeben, wenn die Datei nicht erfolgreich hochgeladen wird.
    Siehe unten zur [Überprüfung, ob die URL existiert](/apis/media/verify-media-url).
  </li>
</ul>

<CodeGroup>
  ```bash cURL theme={"system"}
  curl -X PUT \
  -H 'Content-Type: video/mp4' \
  --upload-file LOCAL_FILE_PATH uploadUrl
  ```

  ```javascript JavaScript theme={"system"}
  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);
  ```

  ```python Python theme={"system"}
  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 PHP theme={"system"}
  <?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);
  ?>

  ```

  ```csharp C# theme={"system"}
  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);
              }
          }
      }
  }

  ```

  ```java Java theme={"system"}
  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());
          }
      }
  }

  ```
</CodeGroup>

Stellen Sie sicher, dass der beim Erstellen der `uploadUrl` gesetzte `contentType` beim PUT der Datei mit dem Content-Type und dem Dateityp übereinstimmt.
Wenn Sie beispielsweise beim Erstellen der `uploadUrl` den `contentType` auf "image/png" gesetzt haben, achten Sie darauf, `Content-Type: image/png` zu setzen und dass die hochgeladene Datei auf `.png` endet.

Bei einem erfolgreichen Upload wird eine `200`-Antwort zurückgegeben.

### Beispiel: Binäre Datei in Node.js hochladen

Hier ist ein Beispiel für das Hochladen einer binären Mediendatei mit Node.js und JavaScript:

```javascript theme={"system"}
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();
```

### Beispiel: Binärdatei-Upload in Postman

Sie können auch Postman verwenden, um die Binärdatei an die `uploadUrl` hochzuladen.

In Postman:

1. Wählen Sie die HTTP-Methode `PUT`.
2. Fügen Sie Ihre `uploadUrl` in das URL-Feld ein. Beachten Sie, dass die URL nach einer Stunde abläuft und nur einmal verwendet werden kann. Wenn ein Aufruf fehlschlägt, müssen Sie die `uploadUrl` neu generieren.
3. Setzen Sie in *Headers* den `Content-Type` auf den Content-Type, der vom /uploadUrl-Endpunkt zurückgegeben wurde. Beispiel: `Content-Type: image/png`.
4. Wählen Sie *Body -> binary* und wählen Sie die hochzuladende Datei aus.
5. Klicken Sie auf **Send**.
6. **Wichtig**: Es wird keine Rückantwort zurückgegeben, daher sollten Sie prüfen, ob der Upload erfolgreich war, indem Sie die vom /uploadUrl-Endpunkt zurückgegebene `accessUrl` in einem Browser öffnen. Sie können auch den [Verify-URL-Endpunkt](/apis/media/verify-media-url) verwenden.

<img class="center" src="https://mintcdn.com/ayrshare-docs/Nmrhj2Gh7WSf62Bh/images/apis/validate/postman%20binary.webp?fit=max&auto=format&n=Nmrhj2Gh7WSf62Bh&q=85&s=ca3def769242814afb17a58d9268667f" alt="Postman Binary Upload" width="1536" height="189" data-path="images/apis/validate/postman binary.webp" />

<Card title="Postman-Beispiel-JSON-Datei" icon="file" href="/files/Large Media File Upload.postman_collection.json" horizontal />

<ResponseExample>
  ```javascript 200: An upload URL and access URL theme={"system"}
  {
      "accessUrl": "https://media.ayrshare.com/Aswmfs3dIEbwLSdhTlV2/test.mp4",
      "contentType": "video/mp4",
      "uploadUrl": "https://storage.googleapis.com/..."
  }
  ```

  ```json 400: Bad Request Error getting signed URL theme={"system"}
  {
    "action": "upload",
    "status": "error",
    "code": 301,
    "message": "The provided content-type 'movd' is not recognized."
  }
  ```
</ResponseExample>