> This page is for Plattform, version V4 Experimental.
> For other versions, use one of these documentation indexes:
> - V4 (default): https://next.developer.frame.io/platform/v4/llms.txt
> - V4 Experimental: https://next.developer.frame.io/platform/v4-experimental/llms.txt
> - Vorgängerversion: https://next.developer.frame.io/platform/v2/llms.txt

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

# So funktionieren lokale und Remote-Uploads

In diesem Leitfaden wird der vollständige Fluss zum Hochladen von Dateien mit der Frame.io V4-API beschrieben.Erklärt werden die rohen API-Anfragen und -Antworten sowohl für lokale als auch für Remote-Uploads.

> **Info**
>
> \*\*Suchen Sie nach SDK-spezifischen Leitfäden?\*\*Informationen zu Upload-Implementierungen mit integriertem Chunking, Wiederholungsversuchen und Tracking des Fortschritts finden Sie im [Python SDK Upload-Leitfaden](./python-sdk-upload-guide).

## Voraussetzungen

Bevor Sie mit dem Hochladen von Dateien beginnen, vergewissern Sie sich, dass Sie diese Setup-Schritte abgeschlossen haben:

#### Frame.io V4-Konto

Sie haben ein Frame.io V4-Konto, das über die [Adobe Admin Console](https://adminconsole.adobe.com/) verwaltet wird, ODER Sie haben für Ihren Kontobenutzer bzw. Ihre Kontobenutzerin [zur Adobe-Authentifizierung gewechselt](https://help.frame.io/de/articles/11758018-connecting-to-adobe-authentication).

#### Setup der Adobe Developer Console

Sie haben sich bei der [Adobe Developer Console](https://developer.adobe.com/console) angemeldet und die Frame.io-API zu einem neuen oder bestehenden Projekt hinzugefügt.

#### Authentifizierungsdaten

Sie haben die [entsprechenden Authentifizierungsdaten](https://developer.adobe.com/frameio/guides/Authentication/) für Ihr Projekt generiert.

#### Zugriffstoken

Sie haben diese Anmeldedaten erfolgreich verwendet, um einen Zugriffstoken zu generieren.

## Auswahl Ihrer Upload-Methode

Es gibt zwei Möglichkeiten, eine Datei mit der Frame.io-API hochzuladen: `Datei erstellen (lokal hochladen)` und `Datei erstellen (Remote-Upload)`.

#### Lokaler Upload

Diese Methode wird genutzt, wenn die Medien für Ihre Anwendung lokal zugänglich sind, ähnlich wie beim Ziehen einer Datei vom Desktop.

#### Remote-Upload

Diese Methode wird verwendet, wenn über das Netzwerk auf die Medien zugegriffen wird, beispielsweise durch .eine Integration mit einem anderen Service

In diesem Leitfaden beginnen wir mit dem einfacheren Fall des Abschließens eines Remote-Uploads.

## Remote-Upload

Wählen Sie den Endpunkt **Datei erstellen (Remote-Upload)**, um eine Datei über Remote-Upload zu erstellen.Für den Anfragefließtext wird der Dateiname und seine Quell-URL benötigt.

> **Warning**
>
> Für den Remote-Upload besteht derzeit ein **Dateigrößen-Limit von 50 GB**.Nutzen Sie bei Dateien von mehr als 50 GB stattdessen den [lokalen Upload](#local-upload).

### Anfragebeispiel

```json
{ 
    "data": {
        "name": "my_file.jpg",
        "source_url": "https://upload.wikimedia.org/wikipedia/commons/e/e1/White_Pixel_1x1.jpg"
    }
}
```

### Antwortbeispiel

Eine erfolgreiche Anfrage führt zu einer Antwort wie der unten gezeigten:

```json
{
    "data": {
        "id": "93e4079d-0a8a-4bf3-96cd-e6a03c465e5e",
        "name": "my_file.jpg",
        "status": "created",
        "type": "file",
        "file_size": 518,
        "updated_at": "2025-06-26T20:14:33.796116Z",
        "media_type": "image/jpeg",
        "parent_id": "2e426fe0-f965-4594-8b2b-b4dff1dc00ec",
        "project_id": "7e46e495-4444-4555-8649-bee4d391a997",
        "created_at": "2025-06-26T20:14:33.159489Z",
        "view_url": "https://next.frame.io/project/7e46e495-4444-4555-8649-bee4d391a997/view/93e4079d-0a8a-4bf3-96cd-e6a03c465e5e"
    },
    "links": {
        "status": "/v4/accounts/6f70f1bd-7e89-4a7e-b4d3-7e576585a181/files/93e4079d-0a8a-4bf3-96cd-e6a03c465e5e/status"
    }
}
```

## Lokaler Upload

Wählen Sie den Endpunkt **Datei erstellen (lokal hochladen)**, um eine Datei über den lokalen Upload zu erstellen.Für den Anfragefließtext werden der Dateiname und die Dateigröße in Bytes benötigt.

### Anfragebeispiel

```json
{ 
    "data": {
        "name": "my_file.jpg",
        "file_size": 50645990
    }
}
```

### Antwortbeispiel

Wenn die Anfrage erfolgreich ist, wird eine Platzhalter-Dateiressource ohne Inhalt erstellt.Je nach Dateigröße enthält der Antwortfließtext eine oder mehrere `upload_urls`.Bei diesem Beispiel müssen wir diesen Upload in mehreren Teilen verwalten.

```json
{
    "data": {
        "id": "fa18ba7b-b3ee-4dd6-9b31-bd07e554241d",
        "name": "my_file.jpg",
        "status": "created",
        "type": "file",
        "file_size": 50645990,
        "updated_at": "2025-06-26T20:08:06.823170Z",
        "media_type": "image/jpeg",
        "parent_id": "2e426fe0-f965-4594-8b2b-b4dff1dc00ec",
        "project_id": "7e46e495-4444-4555-8649-bee4d391a997",
        "created_at": "2025-06-26T20:08:06.751313Z",
        "upload_urls": [
            {
                "size": 16881997,
                "url": "https://frameio-uploads-development.s3-accelerate.amazonaws.com/parts/fa18ba7b-b3ee-4dd6-9b31-bd07e554241d/part_1?..."
            },
            {
                "size": 16881997,
                "url": "https://frameio-uploads-development.s3-accelerate.amazonaws.com/parts/fa18ba7b-b3ee-4dd6-9b31-bd07e554241d/part_2?..."
            },
            {
                "size": 16881996,
                "url": "https://frameio-uploads-development.s3-accelerate.amazonaws.com/parts/fa18ba7b-b3ee-4dd6-9b31-bd07e554241d/part_3?..."
            }
        ],
        "view_url": "https://next.frame.io/project/7e46e495-4444-4555-8649-bee4d391a997/view/fa18ba7b-b3ee-4dd6-9b31-bd07e554241d"
    }
}
```

> **Warning**
>
> **Wichtige Upload-Anforderungen:**
>
> Hier sind wichtige Details, die Sie bei nachfolgenden Upload-Anfragen beachten müssen:
>
> * Die HTTP-Anfragemethode muss `PUT` sein.
> * Der `x-amz-acl`-Header muss enthalten sein und auf „privat“ eingestellt sein.
> * Der Header `Content-Type` muss mit dem `media_type` übereinstimmen, der in der ursprünglichen Anfrage **Datei erstellen (lokal hochladen)** angegeben wurde.Dies gilt auch beim Hochladen der Datei in separaten Teilen.Im obigen Beispiel lautet der Wert für `media_type``image/jpeg`.Daher muss der Wert für `Content-Type` ebenfalls `image/jpeg` sein.

## Mehrteiliger Upload

Wenn eine bestimmte Datei zu mehr als einer Upload-URL führt, müssen Sie die Quelldatei in Chunks aufteilen und für jeden einzelnen eine PUT-Anfrage senden.

> **Info**
>
> **Empfehlung:** Im [Python SDK Upload-Leitfaden](./python-sdk-upload-guide) wird der mehrteilige Upload mit `FrameioUploader` dargelegt, mit dem das Chunking, parallele Uploads, Wiederholungsversuche und die Fortschrittsverfolgung vorkonfiguriert verarbeitet wird.

Wenn Sie den Upload manuell implementieren müssen – zum Beispiel in einer Sprache ohne SDK oder für vollständige Kontrolle über den Prozess –, sehen Sie im unten stehenden Skript, wie Sie eine Datei in Chunks aufteilen und jeden einzelnen mit den vorsignierten URLs hochladen.

### Python-Implementierungsbeispiel

**`Skript für mehrteiligen Upload`**

```python title="Skript für mehrteiligen Upload"
import requests
import math
from typing import List
from tqdm import tqdm  # For progress bar

def upload_file_in_chunks(file_path: str, upload_urls: list[str], content_type: str | None = None, chunk_size: int | None = None) -> bool:
    """
    Upload a file in chunks using presigned URLs.
    """
    try:
        # Auto-detect content type based on file extension
        if content_type is None:
            detected_content_type, _ = mimetypes.guess_type(file_path)
            content_type = detected_content_type # Default fallback

        print(f"Detected content type: {content_type}")

        # Get file size
        with open(file_path, 'rb') as f:
            f.seek(0, 2)  # Seek to end of file
            file_size = f.tell()

        # Calculate chunk size if not provided
        if chunk_size is None:
            chunk_size = math.ceil(file_size / len(upload_urls))

        print(f"File size: {file_size} bytes")
        print(f"Chunk size: {chunk_size} bytes")
        print(f"Number of chunks: {len(upload_urls)}")

        # Upload each chunk
        with open(file_path, 'rb') as f:
            with tqdm(total=len(upload_urls), desc="Uploading chunks") as pbar:
                for i, url in enumerate(upload_urls):
                    start_byte = i * chunk_size
                    end_byte = min(start_byte + chunk_size, file_size)

                    # Read chunk from file
                    f.seek(start_byte)
                    chunk = f.read(end_byte - start_byte)

                    print(f"Uploading chunk {i+1}: {len(chunk)} bytes")

                    # Upload chunk with minimal headers matching the signature
                    response = requests.put(
                        url,
                        data=chunk,
                        headers={
                            'content-type': content_type,
                            'x-amz-acl': 'private'
                        }
                    )

                    if response.status_code != 200:
                        print(f"Failed to upload chunk {i+1}. Status code: {response.status_code}")
                        print(f"Response text: {response.text}")
                        print(f"Response headers: {dict(response.headers)}")
                        return False
                    else:
                        print(f"Chunk {i+1} uploaded successfully!")

                    pbar.update(1)

        return True

    except Exception as e:
        print(f"Error during upload: {str(e)}")
        return False

# Example usage
if __name__ == "__main__":
    # Replace these with your actual values
    file_path = "/Users/MyComputer/local_upload/sample.jpg"  # Path to your file
    upload_urls = [
        "https://frameio-uploads-development.s3-accelerate.amazonaws.com/parts/fa18ba7b-b3ee-4dd6-9b31-bd07e554241d/part_1?...",
        "https://frameio-uploads-development.s3-accelerate.amazonaws.com/parts/fa18ba7b-b3ee-4dd6-9b31-bd07e554241d/part_2?...",
        "https://frameio-uploads-development.s3-accelerate.amazonaws.com/parts/fa18ba7b-b3ee-4dd6-9b31-bd07e554241d/part_3?..."
    ]
    content_type = "image/jpeg"

    print("Starting file upload...")
    success = upload_file_in_chunks(file_path, upload_urls, content_type)

    if success:
        print("File upload completed successfully!")
    else:
        print("File upload failed!")
```

## Zusammenfassung des Upload-Flusses

#### Wahl der Upload-Methode

Entscheiden Sie sich zwischen Remote-Upload (Datei über URL zugänglich) oder lokalem Upload (Datei auf Ihrem System).

#### Erstellen der Dateianfrage

Stellen Sie die erste Anfrage, um die Dateiressource mit den erforderlichen Metadaten zu erstellen.

#### Verarbeiten von Upload-URLs

Verarbeite bei lokalen Uploads die zurückgegebenen upload\_urls (einzeln oder mehrere Teile)

#### Hochladen des Dateiinhalts

Laden Sie Dateiinhalte mit PUT-Anfragen und den richtigen Headern auf die bereitgestellten URLs hoch.

#### Überprüfen des Uploads

Überprüfen Sie den Dateistatus, um das erfolgreiche Hochladen und die Verarbeitung zu bestätigen.

> **Info**
>
> **Nächste Schritte**: Sobald Ihre Datei hochgeladen ist, können Sie mit der zurückgegebenen Datei-ID Kommentare hinzufügen, Freigaben erstellen oder andere Vorgänge mit der Frame.io V4-API durchführen.