สรุปสั้นๆ: Kenerate AI คือพื้นที่ทำงานด้านครีเอทีฟที่ผสานความสามารถด้านภาพ วิดีโอ การแก้ไข เสียง 3D และเอเจนต์ไว้ด้วยกัน

Kenerate AI รวมเครื่องมือสำหรับงานสร้างสรรค์ไว้ในที่เดียว นักพัฒนาควรแยกความแตกต่างของเส้นทางการเข้าถึงแบบเนทีฟของบริการนี้ก่อน ได้แก่ MCP/CLI และการเข้าถึงผ่าน Enterprise API ซึ่งแยกจากการเชื่อมต่อผ่าน CometAPI เอกสารฉบับนี้ครอบคลุมการวางแผนการเข้าถึงและค่าใช้จ่าย การตั้งค่าสภาพแวดล้อม การสร้างภาพ การจัดการการตอบสนอง การแก้ไขภาพ และการสร้างวิดีโอแบบอะซิงโครนัส ทำตามตัวอย่างเพื่อบันทึกภาพต้นฉบับ เวอร์ชันที่แก้ไข และคลิปวิดีโอที่เสร็จสมบูรณ์ โดยใช้ Python 3.10+, คีย์ CometAPI และยอดคงเหลือเพียงพอ

ประเด็นสำคัญ

• Kenerate AI เป็นบริการครีเอทีฟแบบหลายโมเดล ไม่ใช่โมเดลฐานเพียงตัวเดียว
• Kenerate มีทั้งช่องทาง MCP/CLI และการออนบอร์ดผ่าน Enterprise API เลือกเส้นทางที่เหมาะกับแอปพลิเคชันและบัญชีของคุณ
• ใช้รหัสโมเดลที่ชัดเจนและพารามิเตอร์ตามเส้นทางเมื่อสร้างการเชื่อมต่อแยกกับ CometAPI
• บันทึกไบต์ของภาพหลังการสร้าง; เก็บ task ID ของวิดีโอเพื่อให้การโพลลิ่งกลับมาทำต่อได้โดยไม่ต้องส่งงานใหม่
• CometAPI มีการผสานสำหรับนักพัฒนาแยกต่างหากสำหรับโมเดลภาพ/วิดีโอที่รองรับ พร้อมข้อมูลประจำตัวและการเรียกเก็บเงินแยกกัน

Kenerate AI คืออะไร?

ใช้สตูดิโอของ Kenerate เพื่อการสร้างสรรค์แบบอินเทอร์แอคทีฟ นักพัฒนายังสามารถใช้เครื่องมือ MCP/CLI อย่างเป็นทางการหรือ ติดต่อฝ่ายสนับสนุนเกี่ยวกับการเข้าถึง Enterprise API ส่วนถัดไปอธิบายตัวเลือกการเข้าถึงเหล่านี้; ตัวอย่าง Python ตอนหลังในคู่มือนี้เรียก CometAPI แยกต่างหาก

Kenerate AI และ CometAPI เป็นบริการคนละตัว

โค้ดด้านล่างเรียก CometAPI โดยตรง ไม่ได้ลงชื่อเข้าใช้ Kenerate ไม่ได้อัตโนมัติสตูดิโอของ Kenerate และไม่ใช้เครดิตของ Kenerate โค้ดนี้ทำซ้ำภารกิจครีเอทีฟที่นิยามแคบโดยใช้โมเดลที่รองรับ แทนที่จะอ้างว่าตรงกับพรีเซ็ตหรือผลลัพธ์ในสตูดิโอทุกประการ

ตัวอย่างภาพผลิตภัณฑ์อย่างเป็นทางการจาก Kenerate gallery นี่เป็นเพียงการสาธิตกรณีการใช้งานเชิงครีเอทีฟ ไม่ใช่ผลลัพธ์จากโค้ด API ด้านล่าง

การตั้งราคาของ Kenerate AI มีผลต่อการวางแผนต้นทุน API อย่างไร?

Kenerate โปรโมตเครดิตเริ่มต้น 25 เครดิต และแพ็กเครดิตแบบชำระครั้งเดียวเริ่มต้นที่ $15 คำถามที่พบบ่อยเกี่ยวกับการเรียกเก็บเงิน ระบุว่าเครดิตที่ซื้อจะไม่มีวันหมดอายุ และการสร้างวิดีโอต้องใช้แพ็กเครดิตที่ซื้อ เงื่อนไขเหล่านี้เป็นเงื่อนไขการเรียกเก็บเงินของสตูดิโอ ไม่ใช่ใบเสนอราคาสำหรับการเข้าถึง Enterprise API

CometAPI ใช้ข้อมูลประจำตัวและการเรียกเก็บเงินแยกต่างหาก ก่อนทดสอบหรือรันชุดงาน ให้ตรวจสอบโมเดลที่เลือกและการตั้งค่าคำขอตาม การประเมินต้นทุน กำหนดขีดจำกัดงาน และตรวจสอบการใช้งานที่บันทึกไว้ เครดิตของ Kenerate ไม่ได้เป็นตัวกำหนดต้นทุนของคำขอใน CometAPI

เข้าถึง Kenerate AI ได้อย่างไร?

เชื่อมต่อผ่าน MCP หรือ CLI

Kenerate MCP/CLI setup page อย่างเป็นทางการ เป็นเส้นทางนักพัฒนาแบบเนทีฟ เซิร์ฟเวอร์ MCP ระยะไกลคือ https://mcp.kenerateai.com/mcp เพิ่มเซิร์ฟเวอร์นี้ในไคลเอนต์ที่รองรับและทำการลงชื่อเข้าใช้ Kenerate ในที่ที่รองรับ; ปฏิบัติตามหน้าตั้งค่าสำหรับการติดตั้ง CLI และการยืนยันตัวตน เครื่องมือเหล่านี้ใช้บัญชี Kenerate ของคุณ ไม่ใช่คีย์ CometAPI

ขอสิทธิ์ API ระดับองค์กรเมื่อจำเป็น

คำถามที่พบบ่อยอย่างเป็นทางการ ยังอธิบายการเข้าถึง API สำหรับพันธมิตรระดับ Enterprise ผ่านฝ่ายสนับสนุน สำหรับเส้นทางนั้น ให้ขอเอกสารเอ็นด์พอยต์ วิธีการยืนยันตัวตน การดำเนินการที่รองรับ โควตา และเงื่อนไขการเรียกเก็บเงิน การออนบอร์ดระดับองค์กรไม่ควรถูกนำเสนอว่าเป็นตัวเลือกการผสานแบบเนทีฟเพียงอย่างเดียว

จะตั้งค่าเวิร์กโฟลว์ CometAPI แยกต่างหากได้อย่างไร?

บัญชีและข้อมูลประจำตัว

สร้างบัญชี CometAPI และสร้างคีย์ตาม คำแนะนำการตั้งค่า API key เก็บคีย์ไว้บนเซิร์ฟเวอร์หรือเครื่องพัฒนา คำสั่ง Bash ต่อไปนี้จะติดตั้ง HTTP ไคลเอนต์และอ่านคีย์โดยไม่ echo ผู้ใช้ Windows สามารถรันใน WSL หรือ Git Bash

python -m pip install requests
read -rsp "CometAPI API key: " COMETAPI_KEY
export COMETAPI_KEY
printf '\n'

คำขอแรกที่เล็กและเฉพาะเจาะจง

ใช้พรอมป์ตเดียวและเอาต์พุตเดียวก่อนค่อยเพิ่มตัวควบคุมเสริม สำหรับเวิร์กโฟลว์ภาพ นักพัฒนาสามารถเข้าถึง GPT Image 2 API ใน CometAPI เวิร์กโฟลว์วิดีโอใช้ Kling Video API ใน CometAPI โดยใช้ค่า model_name ตามควิกสตาร์ตของผู้พัฒนา ป้ายชื่อในสตูดิโอไม่สามารถใช้แทนตัวระบุของ API ได้

เปรียบเทียบตัวอย่าง CometAPI

CometAPI มีเอกสารคำขอและฟิลด์ผลลัพธ์ของภาพ และเอกสารเส้นทางส่งงานและโพลลิ่งของวิดีโอแยกจากกัน จัดการข้อมูลประจำตัว เส้นทาง เนื้อคำขอ และการพาร์เซผลลัพธ์ให้เป็นการผสานที่ครบถ้วนหนึ่งชุด

สามารถใช้ OpenAI SDK ร่วมกับ CometAPI ได้หรือไม่?

ได้ สำหรับเส้นทางที่รองรับและเข้ากันได้กับ OpenAI CometAPI คู่มือ SDK ใช้คีย์ CometAPI และ base URL https://api.cometapi.com/v1. OpenAI Python SDK รองรับ base_url แบบกำหนดเอง หากเลือกใช้ ให้ติดตั้ง SDK แยกต่างหาก; สคริปต์ภาพและวิดีโอที่รันได้ด้านล่างนี้ใช้ requests

python -m pip install openai

import os
from openai import OpenAI

client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
)

Client configuration only: no generation request is submitted here.

ความเข้ากันได้หมายถึงเอ็นด์พอยต์ ฟิลด์ และรูปแบบการตอบกลับที่มีเอกสาร ไม่ได้ทำให้เส้นทางของผู้ให้บริการทั้งหมดใช้แทนกันได้ ควิกสตาร์ตภาพรองรับ client.images.generate; ตัวอย่าง Kling ด้านล่างใช้เส้นทางเฉพาะผู้ให้บริการ /kling/v1/videos/text2video และสัญญาของงาน ทำตามควิกสตาร์ต [image](https://apidoc.cometapi.com/quickstarts/image/gpt-image-api) หรือ [Kling](https://apidoc.cometapi.com/quickstarts/video/kling-api) ที่ตรงกัน แทนการแทนที่ด้วยการเรียกวิดีโอแบบ SDK ทั่วไป

## จะสร้างและบันทึกรูปภาพด้วย CometAPI ได้อย่างไร?

### เลือกการตั้งค่าภาพ

สำหรับการทดสอบภาพครั้งแรก ให้ใช้ gpt-image-2, size="1024x1024", quality="low" และ output_format="jpeg" บันทึกผลด้วยนามสกุลไฟล์ที่สอดคล้อง เสนอคำอธิบายที่ชัดเจนเกี่ยวกับสินค้า พื้นหลัง และแสง เส้นทางภาพนี้ใช้ฟิลด์ model และส่งคืนไบต์ภาพใน data[0].b64_json

### สร้างและบันทึกภาพ

CometAPI มีเอกสารการสร้างภาพด้วย [gpt-image-2](https://apidoc.cometapi.com/quickstarts/image/gpt-image-api) และเอาต์พุตแบบ base64 ตัวอย่างนี้ส่งคำขอแบบซิงโครนัสและบันทึกไบต์ที่ส่งคืนเป็น JPEG บันทึกเป็น generate_image.py และรัน python generate_image.py หลังตั้งค่า environment variable แล้ว

import base64
import os
from pathlib import Path
import requests

response = requests.post(
"https://api.cometapi.com/v1/images/generations",
headers={"Authorization": f"Bearer {os.environ['COMETAPI_KEY']}"},
json={
"model": "gpt-image-2",
"prompt": "A ceramic cup on marble, realistic product lighting",
"quality": "low",
"size": "1024x1024",
"output_format": "jpeg",
},
timeout=(10, 180),
)
response.raise_for_status()
payload = response.json()
items = payload.get("data", [])
if not items or not items[0].get("b64_json"):
raise RuntimeError("No image bytes returned; inspect the response schema.")
image_bytes = base64.b64decode(items[0]["b64_json"], validate=True)
if not image_bytes:
raise RuntimeError("The returned image is empty.")
output = Path("product-image.jpeg")
output.write_bytes(image_bytes)
print(f"Saved {output} ({len(image_bytes)} bytes)")

### ตรวจสอบภาพที่บันทึก

ก่อนอื่นยืนยันว่า `product-image.jpeg` มีอยู่และเปิดในโปรแกรมดูภาพได้ จากนั้นตรวจสอบว่าเรื่องหลัก องค์ประกอบ และรายละเอียดของสินค้าสอดคล้องกับพรอมป์ตหรือไม่ ตรวจสอบองค์ประกอบและเรื่องหลักก่อนเปลี่ยนพรอมป์ต การตอบกลับ HTTP 200 ยืนยันว่าคำขอสำเร็จ แต่ยังจำเป็นต้องตรวจสอบข้อมูลที่ส่งคืนและตรวจสอบภาพด้วย หากการตอบกลับมีข้อผิดพลาดหรือสคีมาที่ต่างออกไป ให้ตรวจสอบก่อนเปลี่ยนตัวถอดรหัส; อย่าบันทึกข้อความ JSON พร้อมนามสกุลไฟล์รูปภาพ

เก็บภาพต้นฉบับไว้โดยไม่เปลี่ยนแปลงสำหรับการแก้ไขภายหลัง จับคู่นามสกุลไฟล์กับ output_format ที่ขอไว้ และตรวจสอบข้อความสำคัญหรือรายละเอียดสินค้าด้วยสายตา หากเปลี่ยนโมเดล ให้ตรวจสอบสัญญาการตอบกลับของโมเดลนั้นก่อนนำตัวถอดรหัส base64 นี้กลับมาใช้

### แก้ไขภาพที่สร้างไว้หรือภาพโลคัล

อัปโหลดไฟล์ต้นทางเป็น multipart data ระบุการเปลี่ยนแปลงที่ต้องการและรายละเอียดที่ต้องคงไว้; เก็บไฟล์ต้นฉบับ และบันทึกผลลัพธ์ที่อนุมัติแล้วแต่ละครั้งเป็นชื่อใหม่

สำหรับเวิร์กโฟลว์ CometAPI แยกต่างหาก [เอ็นด์พอยต์ image-edit รองรับการอัปโหลดแบบ multipart](https://apidoc.cometapi.com/api/image/openai/image-editing) บันทึกสคริปต์แบบสแตนด์อโลนนี้เป็น edit_image.py ไว้ข้าง `product-image.jpeg` จากขั้นตอนสร้าง แล้วรัน python edit_image.py พรอมป์ตขอการเปลี่ยนแปลงเพียงข้อเดียวคือสีของแก้ว และสคริปต์จะบันทึกผลลัพธ์เป็น `product-image-edited.jpeg`

import base64
import os
from pathlib import Path
import requests

source = Path("product-image.jpeg")
with source.open("rb") as image_file:
response = requests.post(
"https://api.cometapi.com/v1/images/edits",
headers={"Authorization": f"Bearer {os.environ['COMETAPI_KEY']}"},
files={"image": (source.name, image_file, "image/jpeg")},
data={
"model": "gpt-image-2",
"prompt": "Change only the cup color to matte black. Preserve its shape, background and lighting.",
"quality": "low",
"output_format": "jpeg",
},
timeout=(10, 240),
)
response.raise_for_status()
items = response.json().get("data", [])
if not items or not items[0].get("b64_json"):
raise RuntimeError("No edited image returned; inspect the response.")
edited_bytes = base64.b64decode(items[0]["b64_json"], validate=True)
if not edited_bytes:
raise RuntimeError("The edited image is empty.")
Path("product-image-edited.jpeg").write_bytes(edited_bytes)
print("Saved product-image-edited.jpeg")

#### การใช้ภาพอ้างอิงแบบโลคัล

หากต้องการแก้ไขภาพถ่ายสินค้าที่มีอยู่ ให้ตั้งค่า source เป็นไฟล์นั้น ตั้งค่า MIME type ของการอัปโหลดให้ตรงกับฟอร์แมตจริง เช่น image/png สำหรับ PNG ค่า output_format ที่ขอสามารถคงเป็น jpeg ได้โดยไม่ขึ้นกับฟอร์แมตต้นทาง ปล่อยให้ requests สร้างส่วนหัว multipart Content-Type เอง; การบังคับใช้ application/json ด้วยตนเองจะทำให้การอัปโหลดไฟล์ล้มเหลว

ภาพอ้างอิงช่วยเรื่องความสม่ำเสมอ แต่ไม่รับประกันการรักษาโลโก้หรือเรขาคณิตของสินค้าอย่างแม่นยำ ควรมีขั้นตอนการอนุมัติจากมนุษย์สำหรับการอ้างสิทธิ์เชิงพาณิชย์เกี่ยวกับสินค้า

#### ดำเนินการแก้ไขต่อ

สำหรับการแก้ไขเพิ่มเติม ให้อัปโหลดเอาต์พุตที่อนุมัติแล้วเป็นแหล่งถัดไป และเขียนคำสั่งถัดไป เก็บแต่ละเวอร์ชันภายใต้ชื่อไฟล์ที่ต่างกัน ตรวจสอบทั้งการเปลี่ยนแปลงที่ร้องขอและองค์ประกอบที่ควรคงเดิมก่อนดำเนินการต่อ

## จะส่งและดึงวิดีโอ Kling ด้วย CometAPI ได้อย่างไร

### ส่งงานวิดีโอ

ควิกสตาร์ต [Kling](https://apidoc.cometapi.com/quickstarts/video/kling-api) แบบ text-to-video ใช้งานอะซิงโครนัส: ส่งครั้งเดียว เก็บ ID และสอบถามเส้นทางที่ตรงกัน ตัวอย่างด้านล่างใช้ `model_name="kling-v3"`, `mode="std"`, `duration="5"` และ `sound="off"` ค่าพวกนี้ใช้กับเส้นทาง Kling ของ CometAPI นี้ อธิบายกิจกรรมของตัวแบบให้ชัดเจนหนึ่งอย่างและการเคลื่อนกล้องที่ตั้งใจ

ใช้ model_name สำหรับเส้นทางเฉพาะผู้ให้บริการนี้ และคง mode="std", duration="5" และ sound="off" สำหรับการทดสอบแรก บันทึก task_id ที่ส่งคืนทันที นี่เป็นคำขอ text-to-video; การใช้อ้างอิงภาพต้องใช้เส้นทาง image-to-video ตามที่ผู้ให้บริการนั้นๆ ระบุไว้

บันทึกโค้ดเป็น generate_video.py รัน python generate_video.py เพื่อสร้างงาน หลังการโพลลิ่งถูกขัดจังหวะ ให้รัน python generate_video.py TASK_ID โดยใช้ ID ที่บันทึกไว้เพื่อทำต่อ [สัญญาการดึงงาน](https://apidoc.cometapi.com/api/video/kling/individual-queries) มีเอกสาร URL ของผลลัพธ์และรองรับทั้งซอง data และออบเจ็กต์งานโดยตรง

### โพลลิ่งงานและดาวน์โหลดผลลัพธ์

การตอบกลับของการสร้างวิดีโอจะให้ task ID ไม่ใช่ไฟล์มีเดียที่เสร็จแล้ว บันทึก ID พร้อมกับงาน ตรวจสอบ task_status เมื่อดึงข้อมูล และดาวน์โหลดผลลัพธ์หลังสถานะ succeed เท่านั้น สคริปต์วิดีโอแบบสมบูรณ์ด้านล่างจัดการการส่งงาน การโพลลิ่ง ความล้มเหลว และการดาวน์โหลด; โหมดทำต่อจะใช้งานเดิมซ้ำ

ดึงงานที่มีอยู่ด้วย GET /kling/v1/videos/text2video/{task_id} รอจน task_status="succeed" ก่อนอ่าน task_result.videos[0].url; จัดการ "failed" เป็นข้อผิดพลาด การจำกัดเวลาโพลลิ่งในโลคัลควรเก็บ task ID ไว้เพื่อให้ดึงต่อได้โดยไม่ต้องเริ่มสร้างใหม่

import json
import os
import sys
import time
from pathlib import Path
import requests

route = "https://api.cometapi.com/kling/v1/videos/text2video"
headers = {"Authorization": f"Bearer {os.environ['COMETAPI_KEY']}"}

def read_task(response):
response.raise_for_status()
body = response.json()
if body.get("code") not in (None, 0):
raise RuntimeError(f"API error: {body.get('message', body.get('code'))}")
return body.get("data", body)

if len(sys.argv) > 1:
task_id = sys.argv[1]
else:
created = read_task(requests.post(
route, headers=headers,
json={
"model_name": "kling-v3",
"prompt": "A wristwatch on dark marble. Slow lateral camera motion, soft light, no cuts.",
"mode": "std", "duration": "5", "sound": "off",
}, timeout=(10, 60),
))
task_id = created["task_id"]
Path("video-task-id.txt").write_text(task_id, encoding="utf-8")
print(f"Task ID: {task_id}", flush=True)

deadline = time.monotonic() + 600
while time.monotonic() < deadline:
task = read_task(requests.get(
f"{route}/{task_id}", headers=headers, timeout=(10, 30),
))
state = task["task_status"]
if state == "failed":
raise RuntimeError(task.get("task_status_msg") or "Video task failed")
if state == "succeed":
Path("video-result.json").write_text(json.dumps(task), encoding="utf-8")
asset_url = task["task_result"]["videos"][0]["url"]
with requests.get(asset_url, stream=True, timeout=(10, 120)) as asset:
asset.raise_for_status()
with Path("product-video.mp4").open("wb") as output:
for chunk in asset.iter_content(chunk_size=1024 * 1024):
if chunk:
output.write(chunk)
print("Saved product-video.mp4")
break
time.sleep(5)
else:
raise TimeoutError(f"Polling stopped. Resume with task ID {task_id}.")

### การเสร็จสิ้นและการกู้คืน

เปิดไฟล์ product-video.mp4 และยืนยันว่าสามารถเล่นจนจบ สคริปต์จะบันทึกผลลัพธ์ของงานก่อนดาวน์โหลด ดังนั้นความล้มเหลวในการดาวน์โหลดจึงไม่จำเป็นต้องสร้างคลิปใหม่อีกครั้ง กำหนดเส้นตายการโพลลิ่งในโลคัลจะหยุดรอ; ไม่ได้ยกเลิกงานระยะไกล เก็บ ID และดึงผลลัพธ์ต่อได้ การดาวน์โหลดไฟล์มีเดียตั้งใจใช้คำขอแยกต่างหากที่ไม่ยืนยันตัวตนเพื่อไม่ให้คีย์ CometAPI ถูกส่งไปยังโฮสต์สื่อ

ตัวอย่างวิดีโอใช้อินพุตแบบข้อความ ไม่สามารถแนบภาพที่อนุมัติแล้วโดยการสร้างฟิลด์ reference_image บนเส้นทางนี้; image-to-video ต้องใช้เวิร์กโฟลว์ภาพของผู้ให้บริการที่เลือกตามที่มีเอกสาร

## จะต่อยอดเวิร์กโฟลว์ CometAPI สำหรับโปรดักชันอย่างไร?

### ระเบียนงานและแอสเซ็ตนำกลับมาใช้ได้

เก็บพรอมป์ต การกำหนดค่า แอสเซ็ตต้นทาง task ID และเส้นทางเอาต์พุตไว้ในหนึ่งงานของแอปพลิเคชัน แยกเวอร์ชันภาพแต่ละรายการเพื่อให้ผู้ใช้ย้อนกลับไปยังเวอร์ชันที่อนุมัติแล้วได้ สำหรับวิดีโอ ให้บันทึก task ID ก่อนออกจากฮ্যান্ডเลอร์คำขอ และให้เวิร์กเกอร์จัดการการดึงผลลัพธ์

### คอลแบ็กและการกระทบยอด

สำหรับการส่งมอบวิดีโอแบบอะซิงโครนัส ให้ทำตาม [คำแนะนำเรื่องโพลลิ่งและเว็บฮุคของ CometAPI](https://apidoc.cometapi.com/guides/webhook-and-polling-for-video-generation) เพิ่มคอลแบ็กหลังจากการโพลลิ่งพื้นฐานทำงานแล้ว และทำให้การประมวลผลการแจ้งเตือนซ้ำทำได้อย่างปลอดภัย เก็บเส้นทางดึงผลสำหรับงานที่คอลแบ็คล่าช้าหรือหายไป

## ควรจัดการข้อผิดพลาดในเวิร์กโฟลว์ CometAPI อย่างไร?

ใช้ [เอกสารข้อผิดพลาดของ API และแนวทางการรีทราย](https://apidoc.cometapi.com/guides/error-codes-and-retry-strategy) เมื่อสร้างเวิร์กโฟลว์ CometAPI ก่อนอื่นแยกคำขอไม่ถูกต้องออกจากความล้มเหลวชั่วคราวของการขนส่ง เก็บสถานะการตอบกลับ ตัวระบุคำขอ และ task ID ในบันทึกฝั่งเซิร์ฟเวอร์ โดยไม่รวมคีย์ลับ

* การยืนยันตัวตนล้มเหลว: ตรวจสอบคีย์ การเข้าถึงบัญชี และโฮสต์ปลายทางก่อนรีทราย
* พารามิเตอร์ที่ไม่รองรับ: กลับไปที่คำขอที่เล็กที่สุดตามเอกสาร แล้วค่อยเพิ่มฟิลด์เสริมทีละรายการ
* การจำกัดอัตรา หรือความล้มเหลวในการโพลลิ่งชั่วคราว: รอด้วย backoff ที่มีขอบเขตและดึงงานเดิมต่อ
* การหมดเวลาในการสร้างงาน: ตรวจสอบว่าคำขอแรกสร้างงานแล้วหรือไม่ก่อนส่งซ้ำ การส่งคำขอสร้างซ้ำอาจมีค่าใช้จ่ายเพิ่มเติม
* การดาวน์โหลดเอาต์พุตล้มเหลว: ใช้ผลลัพธ์ของงานที่เก็บไว้หรือดึงงานเดิมอีกครั้งแทนการเริ่มสร้างใหม่

## บทสรุป

ก่อนอื่นเลือกบริการและเส้นทางการเข้าถึง สำหรับ Kenerate ให้เริ่มจากการตั้งค่า MCP/CLI อย่างเป็นทางการหรือพูดคุยข้อกำหนด Enterprise API กับฝ่ายสนับสนุน สำหรับการใช้งาน CometAPI แยกต่างหาก ให้กำหนดค่าคีย์ของบริการ ทำตามเส้นทางภาพหรือ Kling ตรวจสอบเอาต์พุตที่บันทึก และเก็บ task ID ของวิดีโอเพื่อการกู้คืน ไมล์สโตนแรกที่มีประโยชน์คือภาพโลคัลที่ถูกต้องหนึ่งภาพ เวอร์ชันแก้ไขหนึ่งไฟล์ และวิดีโอที่เล่นได้หนึ่งคลิป

## คำถามที่พบบ่อย

### เวิร์กโฟลว์ CometAPI นี้สามารถทำงานทั้งหมดในเบราว์เซอร์ได้หรือไม่?

เบราว์เซอร์สามารถแสดงพรอมป์ตและความคืบหน้าได้ แต่ส่วนหน้าสาธารณะไม่ควรมีคีย์ API ลับ วางคำขอสร้างงานและการติดตามงานไว้หลังแบ็กเอนด์ของคุณเอง ยืนยันตัวตนผู้ใช้ที่นั่น และส่งคืนเฉพาะผลลัพธ์หรือความคืบหน้าที่อินเทอร์เฟซต้องการ การใช้งาน CometAPI แยกต่างหากควรยึดตามการแยกหน้าที่นี้เช่นกัน

### ทีมงานควรขออะไรบ้างก่อนการออนบอร์ด Enterprise ของ Kenerate AI?

ขอเอกสาร API แบบเนทีฟและคำอธิบายเป็นลายลักษณ์อักษรเกี่ยวกับโมเดลและการดำเนินการที่ใช้ได้กับบัญชีของคุณ รวมทั้งเคลียร์เรื่องการยืนยันตัวตน โควตา การเรียกเก็บเงิน ระยะเวลาการเก็บงาน และเจ้าของซัพพอร์ต การสาธิตในสตูดิโอแสดงขีดความสามารถเชิงครีเอทีฟ แต่ไม่ได้ยืนยันสคีมาคำขอหรือเงื่อนไขบริการที่แอปของคุณจะได้รับ

### พรอมป์ตเดียวกันของ Kenerate AI จะให้เอาต์พุต API เหมือนกันทุกครั้งหรือไม่?

ไม่ควรพึ่งพาเรื่องนั้น เริ่มจากปรับให้ตรงกันทั้งเวอร์ชันโมเดล แอสเซ็ตอินพุต และการตั้งค่าการสร้างที่เปิดให้ใช้ สตูดิโออาจมีค่าเริ่มต้นหรือกระบวนการเพิ่มเติมที่คำขอ API ของคุณไม่ได้ทำซ้ำ เก็บบรีฟและแอสเซ็ตอ้างอิงที่อนุมัติไว้ แล้วประเมินเอาต์พุตใหม่ตามข้อกำหนดการส่งมอบจริง แทนที่จะคาดหวังสื่อที่เหมือนกันพิกเซลต่อพิกเซล