sync/lipsync-v3

비디오를 비디오로

Sync.so Lipsync v3 API by Sync.so

sync/lipsync-v3

Lipsync-v3

Sync.so Lipsync v3 (sync-3) is Sync Labs state-of-the-art lip-sync model, re-syncing the lips of an existing video to a new audio track with industry-leading naturalness.

입력

Video url *

파일을 드래그 앤 드롭하거나 클릭하여 업로드할 수 있습니다

MAX:1

Audio url *

파일을 드래그 앤 드롭하거나 클릭하여 업로드할 수 있습니다

MAX:1

Sync mode *

출력

대기

생성된 비디오가 여기에 표시됩니다

설정을 구성하고 실행을 클릭하여 시작하세요

요청당 $0.22가 소요됩니다. $10로 이 모델을 약 45번 실행할 수 있습니다.

다음으로 할 수 있는 작업:

Seedance 2.0 Kling v3 Vidu Wan2.7

파라미터

코드 예시
import requests
import time

# Step 1: Start video generation
generate_url = "https://api.atlascloud.ai/api/v1/model/generateVideo"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "sync/lipsync-v3",  # Required. model name
    "video_url": "example_value",  # Required. URL of the input video whose lips will be re-synced
    "audio_url": "example_value",  # Required. URL of the driving audio to sync the lips to
    "sync_mode": "cut_off",  # Required. How to handle duration mismatch between video and audio. options: cut_off | loop | bounce | silence | remap
}

generate_response = requests.post(generate_url, headers=headers, json=data)
generate_result = generate_response.json()
prediction_id = generate_result["data"]["id"]

# Step 2: Poll for result
poll_url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"

def check_status():
    while True:
        response = requests.get(poll_url, headers={"Authorization": "Bearer $ATLASCLOUD_API_KEY"})
        result = response.json()

        if result["data"]["status"] in ["completed", "succeeded"]:
            print("Generated video:", result["data"]["outputs"][0])
            return result["data"]["outputs"][0]
        elif result["data"]["status"] == "failed":
            raise Exception(result["data"]["error"] or "Generation failed")
        else:
            # Still processing, wait 2 seconds
            time.sleep(2)

video_url = check_status()

설치

사용하는 언어에 필요한 패키지를 설치하세요.

pip install requests

인증

모든 API 요청에는 API 키를 통한 인증이 필요합니다. Atlas Cloud 대시보드에서 API 키를 받을 수 있습니다.

export ATLASCLOUD_API_KEY="your-api-key-here"

HTTP 헤더

import os

API_KEY = os.environ.get("ATLASCLOUD_API_KEY")
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

API 키를 안전하게 보관하세요

클라이언트 측 코드나 공개 저장소에 API 키를 노출하지 마세요. 대신 환경 변수 또는 백엔드 프록시를 사용하세요.

요청 제출

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateVideo"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "your-model",
    "prompt": "A beautiful landscape"
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

요청 제출

비동기 생성 요청을 제출합니다. API는 상태 확인 및 결과 조회에 사용할 수 있는 예측 ID를 반환합니다.

POST/api/v1/model/generateVideo

요청 본문

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateVideo"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}

data = {
    "model": "sync/lipsync-v3",
    "prompt": "A beautiful sunset over the ocean with gentle waves"
}

response = requests.post(url, headers=headers, json=data)
result = response.json()

print(f"Prediction ID: {result['data']['id']}")
print(f"Status: {result['data']['status']}")

응답

{
  "code": 200,
  "data": {
    "id": "pred_abc123",
    "status": "processing",
    "model": "model-name",
    "created_at": "2025-01-01T00:00:00Z"
  }
}

상태 확인

예측 엔드포인트를 폴링하여 요청의 현재 상태를 확인합니다.

GET/api/v1/model/prediction/{prediction_id}

폴링 예시

import requests
import time

prediction_id = "pred_abc123"
url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

while True:
    response = requests.get(url, headers=headers)
    result = response.json()
    status = result["data"]["status"]
    print(f"Status: {status}")

    if status in ["completed", "succeeded"]:
        output_url = result["data"]["outputs"][0]
        print(f"Output URL: {output_url}")
        break
    elif status == "failed":
        print(f"Error: {result['data'].get('error', 'Unknown')}")
        break

    time.sleep(3)

상태 값

processing요청이 아직 처리 중입니다.

completed생성이 완료되었습니다. 출력을 사용할 수 있습니다.

succeeded생성이 성공했습니다. 출력을 사용할 수 있습니다.

failed생성에 실패했습니다. 오류 필드를 확인하세요.

완료 응답

{
  "data": {
    "id": "pred_abc123",
    "status": "completed",
    "outputs": [
      "https://storage.atlascloud.ai/outputs/result.mp4"
    ],
    "metrics": {
      "predict_time": 45.2
    },
    "created_at": "2025-01-01T00:00:00Z",
    "completed_at": "2025-01-01T00:00:10Z"
  }
}

파일 업로드

Atlas Cloud 스토리지에 파일을 업로드하고 API 요청에 사용할 수 있는 URL을 받습니다. multipart/form-data를 사용하여 업로드합니다.

POST/api/v1/model/uploadMedia

업로드 예시

import requests

url = "https://api.atlascloud.ai/api/v1/model/uploadMedia"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

with open("image.png", "rb") as f:
    files = {"file": ("image.png", f, "image/png")}
    response = requests.post(url, headers=headers, files=files)

result = response.json()
download_url = result["data"]["download_url"]
print(f"File URL: {download_url}")

응답

{
  "data": {
    "download_url": "https://storage.atlascloud.ai/uploads/abc123/image.png",
    "file_name": "image.png",
    "content_type": "image/png",
    "size": 1024000
  }
}

입력 Schema

다음 파라미터를 요청 본문에서 사용할 수 있습니다.

전체: 4필수: 4선택: 0

modelstringrequired

model name

Default: "sync/lipsync-v3"

video_urlstringrequired

URL of the input video whose lips will be re-synced. Public URL or Base64. Formats: mp4/mov/webm.

audio_urlstringrequired

URL of the driving audio to sync the lips to. Public URL or Base64. Formats: wav/mp3/m4a.

sync_modestringrequired

How to handle duration mismatch between video and audio. cut_off: trim to shorter; loop: repeat video; bounce: ping-pong; silence: pad audio; remap: time-remap.

Default: "cut_off"

cut_offloopbouncesilenceremap

요청 본문 예시

{
  "model": "sync/lipsync-v3",
  "video_url": "example_video_url",
  "audio_url": "example_audio_url",
  "sync_mode": "cut_off"
}

출력 Schema

API는 생성된 출력 URL이 포함된 예측 응답을 반환합니다.

modelstring

model name

Default: "sync/lipsync-v3"

created_atstring

ISO timestamp of when the request was created.

idstring

Unique identifier for the prediction.

outputsarray

Array of URLs to the generated video (empty until completed).

statusstring

Status: created, processing, completed, or failed.

응답 예시

{
  "id": "pred_abc123",
  "status": "completed",
  "model": "model-name",
  "outputs": [
    "https://storage.atlascloud.ai/outputs/result.mp4"
  ],
  "metrics": {
    "predict_time": 45.2
  },
  "created_at": "2025-01-01T00:00:00Z",
  "completed_at": "2025-01-01T00:00:10Z"
}

Atlas Cloud Skills

Atlas Cloud Skills는 400개 이상의 AI 모델을 AI 코딩 어시스턴트에 직접 통합합니다. 한 번의 명령으로 설치하고 자연어로 이미지, 동영상 생성 및 LLM과 대화할 수 있습니다.

지원 클라이언트

Claude Code

OpenAI Codex

Gemini CLI

Cursor

Windsurf

VS Code

Trae

GitHub Copilot

Cline

Roo Code

Amp

Goose

Replit

40+ 지원 클라이언트

설치

npx skills add AtlasCloudAI/atlas-cloud-skills

API 키 설정

Atlas Cloud 대시보드에서 API 키를 받아 환경 변수로 설정하세요.

export ATLASCLOUD_API_KEY="your-api-key-here"

기능

설치 후 AI 어시스턴트에서 자연어를 사용하여 모든 Atlas Cloud 모델에 접근할 수 있습니다.

이미지 생성Nano Banana 2, Z-Image 등의 모델로 이미지를 생성합니다.

동영상 제작Kling, Vidu, Veo 등으로 텍스트나 이미지에서 동영상을 만듭니다.

LLM 채팅Qwen, DeepSeek 등 대규모 언어 모델과 대화합니다.

미디어 업로드이미지 편집 및 이미지-동영상 변환 워크플로우를 위해 로컬 파일을 업로드합니다.

더 알아보기

github.com/AtlasCloudAI/atlas-cloud-skills

MCP Server

Atlas Cloud MCP Server는 Model Context Protocol을 통해 IDE와 400개 이상의 AI 모델을 연결합니다. MCP 호환 클라이언트에서 사용할 수 있습니다.

지원 클라이언트

Cursor

VS Code

Windsurf

Claude Code

OpenAI Codex

Gemini CLI

Cline

Roo Code

100+ 지원 클라이언트

설치

npx -y atlascloud-mcp

설정

다음 설정을 IDE의 MCP 설정 파일에 추가하세요.

{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": [
        "-y",
        "atlascloud-mcp"
      ],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}

사용 가능한 도구

atlas_generate_image텍스트 프롬프트로 이미지를 생성합니다.

atlas_generate_video텍스트나 이미지로 동영상을 만듭니다.

atlas_chat대규모 언어 모델과 대화합니다.

atlas_list_models400개 이상의 사용 가능한 AI 모델을 탐색합니다.

atlas_quick_generate최적 모델을 자동 선택하여 한 번에 콘텐츠를 생성합니다.

atlas_upload_mediaAPI 워크플로우를 위해 로컬 파일을 업로드합니다.

더 알아보기

github.com/AtlasCloudAI/mcp-server

API 스키마

{
  "info": {
    "description": "The AtlasCloud API.",
    "title": "AtlasCloud API",
    "version": "1.0.0"
  },
  "paths": {
    "/api/v1/model/generateVideo": {
      "post": {
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "The request status."
          }
        },
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Input"
              }
            }
          }
        }
      },
      "x-api-name": "model_run"
    },
    "/api/v1/model/result/{request_id}": {
      "get": {
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "Result of the request."
          }
        },
        "parameters": [
          {
            "in": "path",
            "name": "request_id",
            "schema": {
              "type": "string",
              "description": "Request ID"
            },
            "required": true
          }
        ]
      },
      "x-api-name": "model_result"
    }
  },
  "openapi": "3.0.0",
  "servers": [
    {
      "url": "https://api.atlascloud.ai"
    }
  ],
  "components": {
    "schemas": {
      "Input": {
        "properties": {
          "model": {
            "type": "string",
            "description": "model name",
            "default": "sync/lipsync-v3"
          },
          "video_url": {
            "description": "URL of the input video whose lips will be re-synced. Public URL or Base64. Formats: mp4/mov/webm.",
            "type": "string",
            "x-ui-component": "uploader"
          },
          "audio_url": {
            "description": "URL of the driving audio to sync the lips to. Public URL or Base64. Formats: wav/mp3/m4a.",
            "type": "string",
            "x-ui-component": "uploader"
          },
          "sync_mode": {
            "description": "How to handle duration mismatch between video and audio. cut_off: trim to shorter; loop: repeat video; bounce: ping-pong; silence: pad audio; remap: time-remap.",
            "type": "string",
            "default": "cut_off",
            "enum": [
              "cut_off",
              "loop",
              "bounce",
              "silence",
              "remap"
            ]
          }
        },
        "required": [
          "model",
          "video_url",
          "audio_url",
          "sync_mode"
        ],
        "type": "object",
        "x-order-properties": [
          "model",
          "video_url",
          "audio_url",
          "sync_mode"
        ]
      },
      "PredictionResponse": {
        "properties": {
          "model": {
            "type": "string",
            "description": "model name",
            "default": "sync/lipsync-v3"
          },
          "created_at": {
            "description": "ISO timestamp of when the request was created.",
            "format": "date-time",
            "type": "string"
          },
          "has_nsfw_contents": {
            "description": "NSFW detection per output.",
            "items": {
              "type": "boolean"
            },
            "type": "array"
          },
          "id": {
            "description": "Unique identifier for the prediction.",
            "type": "string"
          },
          "outputs": {
            "description": "Array of URLs to the generated video (empty until completed).",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "status": {
            "description": "Status: created, processing, completed, or failed.",
            "type": "string"
          },
          "urls": {
            "description": "Object containing related API endpoints.",
            "type": "object"
          }
        },
        "type": "object"
      }
    },
    "securitySchemes": {
      "apiKeyAuth": {
        "in": "header",
        "name": "Authorization",
        "type": "apiKey"
      }
    }
  }
}

LLM 친화적 프롬프트 템플릿

# sync/lipsync-v3

> Sync.so Lipsync v3 (sync-3) is Sync Labs state-of-the-art lip-sync model, re-syncing the lips of an existing video to a new audio track with industry-leading naturalness.


## Overview

- **Submit endpoint (POST)**: `https://api.atlascloud.ai/api/v1/model/generateVideo` — start an async generation; returns a `prediction_id`
- **Poll endpoint (GET)**: `https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}` — poll this until the prediction finishes
- **Model ID**: `sync/lipsync-v3`


## API Information

This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.


### Input Schema

The API accepts the following input parameters:

- **`model`** (`string`, _required_):
  model name
  - Default: `"sync/lipsync-v3"`

- **`video_url`** (`string`, _required_):
  URL of the input video whose lips will be re-synced. Public URL or Base64. Formats: mp4/mov/webm.

- **`audio_url`** (`string`, _required_):
  URL of the driving audio to sync the lips to. Public URL or Base64. Formats: wav/mp3/m4a.

- **`sync_mode`** (`string`, _required_):
  How to handle duration mismatch between video and audio. cut_off: trim to shorter; loop: repeat video; bounce: ping-pong; silence: pad audio; remap: time-remap.
  - Default: `"cut_off"`
  - Options: "cut_off", "loop", "bounce", "silence", "remap"



**Required Parameters Example**:

```json
{
  "model": "sync/lipsync-v3",
  "video_url": "",
  "audio_url": "",
  "sync_mode": "cut_off"
}
```


**Full Example**:

```json
{
  "model": "sync/lipsync-v3",
  "video_url": "",
  "audio_url": "",
  "sync_mode": "cut_off"
}
```


### Output Schema

The API returns the following output format:


- **`model`** (`string`, _optional_):
  model name
  - Default: `"sync/lipsync-v3"`

- **`created_at`** (`string`, _optional_):
  ISO timestamp of when the request was created.

- **`has_nsfw_contents`** (`array[boolean]`, _optional_):
  NSFW detection per output.

- **`id`** (`string`, _optional_):
  Unique identifier for the prediction.

- **`outputs`** (`array[string]`, _optional_):
  Array of URLs to the generated video (empty until completed).

- **`status`** (`string`, _optional_):
  Status: created, processing, completed, or failed.

- **`urls`** (`object`, _optional_):
  Object containing related API endpoints.



**Example Response**:

```json
{
  "model": "sync/lipsync-v3",
  "created_at": "",
  "has_nsfw_contents": [],
  "id": "",
  "outputs": [
    ""
  ],
  "status": "",
  "urls": {}
}
```


## Usage Examples

### cURL

```bash
# Step 1: Start generation (async)
curl -X POST "https://api.atlascloud.ai/api/v1/model/generateVideo" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "sync/lipsync-v3",
  "video_url": "",
  "audio_url": "",
  "sync_mode": "cut_off"
}'

# Response will contain: {"code": 200, "data": {"id": "prediction_id", "status": "processing"}}

# Step 2: Poll for result (replace {prediction_id} with the id returned above)
curl -X GET "https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY"

# Keep polling until status is "completed", "succeeded" or "failed"
# When completed, outputs will contain the generated content URL(s)
```

## Additional Resources

### Documentation

- [Model Playground](https://www.atlascloud.ai/models/sync/lipsync-v3)

사용 가능한 예제 없음

로드 중...