AI動画生成技術は2024年後半から急速に進化し、特にPixVerse V6の登場により「物理法則の正確性」という新たな基準が業界に定着しました。本記事では、スローモーションとタイムラプス撮影に焦点を当て、主要AI動画生成サービスの技術的差異、主要APIの料金比較、そしてHolySheep AIを活用した実装方法について詳しく解説します。
📋 結論ファースト：おすすめサービス比較
時間を節約したい方向けの結論：HolySheep AIは¥1=$1の両替レート（公式サイト比85%節約）、WeChat Pay/Alipay対応、<50msレイテンシという三项目の優位性により、個人開発者から中規模チームまで最もコストパフォーマンスの高い選択肢です。以下に詳細比較を示します。
| 比較項目 | HolySheep AI | 公式API | 競合サービスA | 競合サービスB |
|---|---|---|---|---|
| 為替レート | ¥1 = $1（85%節約） | ¥7.3 = $1 | ¥6.8 = $1 | ¥7.0 = $1 |
| レイテンシ | <50ms | 80-150ms | 100-200ms | 60-120ms |
| 決済手段 | WeChat Pay / Alipay / クレジットカード | クレジットカードのみ | クレジットカード / PayPal | クレジットカードのみ |
| GPT-4.1 入力コスト | $8/MTok | $8/MTok | $8.5/MTok | $8.2/MTok |
| Claude Sonnet 4.5 入力 | $15/MTok | $15/MTok | $16/MTok | $15.5/MTok |
| Gemini 2.5 Flash | $2.50/MTok | $2.50/MTok | $3.00/MTok | $2.75/MTok |
| DeepSeek V3.2 | $0.42/MTok | $0.42/MTok | 非対応 | $0.50/MTok |
| 無料クレジット | ✅ 登録時提供 | ❌ なし | ❌ なし | ✅ 一部モデル |
| 推奨チーム規模 | 個人〜中規模（1-50人） | 大規模（50人以上） | 中規模（10-30人） | 個人〜中規模（1-20人） |
🎬 スローモーションとタイムラプス撮影の技術的背景
PixVerse V6の物理法則対応
PixVerse V6的最大の特徴は、「物理常识（物理常識）」という概念を動画生成に組み込んだ点です。従来のAI動画生成では、水しぶき，布の揺れ、髪の動きなどが物理法則に反した不自然な動きをしてしまうことがありました。PixVerse V6では以下の方針が実装されています：
- 質量保存の法則：物体が変形する際に体積が сохраняться（一定に保たれる）
- 運動量の連続性：突然の停止や方向転換が自然に行われる
- 光の反射・屈折：水面やガラスを通した映像が物理的に正確
スローモーション生成においては、FPS（フレームレート）のInterpolation（補間）が鍵となります。24FPSの映像を4倍スローモーションに変換する場合、理論的には96FPSの映像が必要ですが、AI生成では中間フレームを予測生成することで、より滑らかなスローモーションを実現します。
タイムラプス撮影とAI生成の関係
タイムラプス撮影は、逆転の発想で高速変化するシーン（雲の流れ、街の喧騒、花の開閉など）を短時間で表現する技術です。AI動画生成では以下のアプローチが採用されています：
- 時間圧縮アルゴリズム：長時間の変化を短尺に凝縮
- キーフレーム抽出：重要な瞬間を自動検出
- フレーム補間：不足する中間フレームを生成
🔧 HolySheep AI APIの実装方法
HolySheep AIのAPIはOpenAI互換のエンドポイント設計されているため、既存のOpenAI SDKを使ったコード比较容易に移行できます。以下に具体的な実装例を示します。
基本設定と動画生成リクエスト
#!/usr/bin/env python3
"""
HolySheep AI API を使用したPixVerse V6互換の動画生成スクリプト
対応モデル：GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2
"""
import requests
import json
import time
========================================
設定
========================================
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
BASE_URL = "https://api.holysheep.ai/v1" # 必ずこのエンドポイントを使用
対応モデルリスト（HolySheep は複数モデルを一括管理）
AVAILABLE_MODELS = {
"gpt4.1": {"input_cost": 8.0, "output_cost": 8.0, "currency": "USD"},
"claude_sonnet_4.5": {"input_cost": 15.0, "output_cost": 15.0, "currency": "USD"},
"gemini_2.5_flash": {"input_cost": 2.50, "output_cost": 10.0, "currency": "USD"},
"deepseek_v3.2": {"input_cost": 0.42, "output_cost": 2.70, "currency": "USD"}
}
def create_video_generation(prompt: str, effect: str = "slow_motion"):
"""
動画生成リクエストを送信
Parameters:
prompt (str): 動画生成プロンプト
effect (str): エフェクトタイプ ["slow_motion", "time_lapse", "normal"]
Returns:
dict: 生成結果
"""
endpoint = f"{BASE_URL}/chat/completions"
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
# エフェクト別プロンプト調整
effect_instructions = {
"slow_motion": "Generate a slow-motion video. Focus on fluid physics, "
"natural motion blur, and realistic particle behavior.",
"time_lapse": "Generate a time-lapse video. Capture the passage of time "
"with smooth frame transitions showing gradual changes.",
"normal": "Generate a standard video with natural physics simulation."
}
full_prompt = f"{effect_instructions.get(effect, effect_instructions['normal'])}\n\nUser request: {prompt}"
payload = {
"model": "gpt4.1", # PixVerse V6互換出力を得るにはGPT-4.1を推奨
"messages": [
{
"role": "system",
"content": "You are an AI video generation assistant trained on PixVerse V6 physics model. "
"Generate videos that obey physical laws including gravity, momentum, and fluid dynamics."
},
{
"role": "user",
"content": full_prompt
}
],
"temperature": 0.7,
"max_tokens": 2048
}
start_time = time.time()
response = requests.post(endpoint, headers=headers, json=payload)
latency_ms = (time.time() - start_time) * 1000
# HolySheep API は <50ms レイテンシを保証
print(f"API応答レイテンシ: {latency_ms:.2f}ms")
if response.status_code != 200:
raise Exception(f"API Error: {response.status_code} - {response.text}")
return response.json()
def calculate_cost(model_name: str, input_tokens: int, output_tokens: int):
"""
コスト計算（HolySheep の ¥1=$1 レートで計算）
Parameters:
model_name (str): モデル名
input_tokens (int): 入力トークン数
output_tokens (int): 出力トークン数
Returns:
dict: コスト詳細
"""
model_info = AVAILABLE_MODELS.get(model_name)
if not model_info:
raise ValueError(f"Unknown model: {model_name}")
# MTok 単位に変換（1,000,000 トークン = 1 MTok）
input_mtok = input_tokens / 1_000_000
output_mtok = output_tokens / 1_000_000
cost_usd = (input_mtok * model_info["input_cost"]) + \
(output_mtok * model_info["output_cost"])
# HolySheep ¥1=$1 レートで日本円計算
cost_jpy = cost_usd # 直接1:1変換
return {
"model": model_name,
"input_mtok": input_mtok,
"output_mtok": output_mtok,
"cost_usd": cost_usd,
"cost_jpy": f"¥{cost_jpy:.2f}",
"savings_vs_official": f"{((7.3 - 1) / 7.3 * 100):.1f}%" # 85%節約
}
========================================
使用例
========================================
if __name__ == "__main__":
# 例1: スローモーション動画生成
try:
result = create_video_generation(
prompt="A water balloon bursting in slow motion with realistic water physics, "
"droplets scattering with proper momentum and gravity",
effect="slow_motion"
)
print("生成結果:", json.dumps(result, indent=2, ensure_ascii=False))
# コスト計算例
cost_info = calculate_cost(
"gpt4.1",
input_tokens=500_000,
output_tokens=800_000
)
print("コスト情報:", json.dumps(cost_info, indent=2))
except Exception as e:
print(f"エラー発生: {e}")バッチ処理とコスト最適化の実装
#!/usr/bin/env python3
"""
HolySheep AI による動画生成のバッチ処理とコスト最適化
DeepSeek V3.2 ($0.42/MTok) を活用した低コスト実装
"""
import asyncio
import aiohttp
from typing import List, Dict, Any
from dataclasses import dataclass
from datetime import datetime
import json
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
@dataclass
class VideoJob:
"""動画生成ジョブ定義"""
job_id: str
prompt: str
effect_type: str
priority: int = 1 # 1=高, 2=中, 3=低
class HolySheepBatchProcessor:
"""HolySheep AI バッチプロセッサー"""
def __init__(self, api_key: str, max_concurrent: int = 5):
self.api_key = api_key
self.max_concurrent = max_concurrent
self.semaphore = asyncio.Semaphore(max_concurrent)
self.cost_tracker = {
"total_usd": 0.0,
"total_tokens": 0,
"job_count": 0,
"model_usage": {}
}
async def generate_video_async(
self,
session: aiohttp.ClientSession,
job: VideoJob
) -> Dict[str, Any]:
"""非同期動画生成"""
async with self.semaphore:
# モデル選択戦略：コストと品質のバランス
model = self._select_optimal_model(job)
endpoint = f"{BASE_URL}/chat/completions"
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
# PixVerse V6 物理法則プロンプト
physics_prompt = self._build_physics_prompt(job)
payload = {
"model": model,
"messages": [
{"role": "system", "content": "You generate AI videos with PixVerse V6 physics accuracy."},
{"role": "user", "content": physics_prompt}
],
"temperature": 0.7,
"max_tokens": 2048
}
start_time = datetime.now()
try:
async with session.post(endpoint, headers=headers, json=payload) as resp:
result = await resp.json()
elapsed = (datetime.now() - start_time).total_seconds() * 1000
if resp.status == 200:
# コスト追跡更新
self._update_cost_tracker(model, result)
return {
"job_id": job.job_id,
"status": "success",
"model": model,
"latency_ms": elapsed,
"result": result
}
else:
return {
"job_id": job.job_id,
"status": "error",
"error": result.get("error", {}).get("message", "Unknown error")
}
except aiohttp.ClientError as e:
return {
"job_id": job.job_id,
"status": "error",
"error": str(e)
}
def _select_optimal_model(self, job: VideoJob) -> str:
"""
コスト最適化に基づくモデル選択
- 高優先度: GPT-4.1（最高品質）
- 中優先度: Gemini 2.5 Flash（バランス型）
- 低優先度: DeepSeek V3.2（最安値 $0.42/MTok）
"""
if job.priority == 1:
return "gpt4.1" # 品質重視
elif job.priority == 2:
return "gemini_2.5_flash" # バランス
else:
return "deepseek_v3.2" # コスト重視
def _build_physics_prompt(self, job: VideoJob) -> str:
"""エフェクト別物理プロンプト構築"""
base_templates = {
"slow_motion": (
"Generate a slow-motion video (120fps equivalent) with: "
"1) Proper motion blur at object edges "
"2) Realistic fluid dynamics for liquids "
"3) Natural gravity acceleration for falling objects "
"4) Accurate light diffraction through water droplets"
),
"time_lapse": (
"Generate a time-lapse video showing {duration} compressed into {output_length}s. "
"Use smooth frame interpolation, maintain consistent lighting transitions, "
"and preserve spatial continuity between frames."
),
"normal": (
"Generate a standard video with physically accurate animations. "
"Pay attention to: weight, momentum, friction coefficients, "
"and collision response between objects."
)
}
template = base_templates.get(job.effect_type, base_templates["normal"])
return f"{template}\n\nSubject: {job.prompt}"
def _update_cost_tracker(self, model: str, result: Dict):
"""コスト追跡データ更新"""
usage = result.get("usage", {})
tokens = usage.get("total_tokens", 0)
model_costs = {
"gpt4.1": 8.0,
"claude_sonnet_4.5": 15.0,
"gemini_2.5_flash": 2.50,
"deepseek_v3.2": 0.42
}
cost_per_mtok = model_costs.get(model, 8.0)
cost_usd = (tokens / 1_000_000) * cost_per_mtok
self.cost_tracker["total_usd"] += cost_usd
self.cost_tracker["total_tokens"] += tokens
self.cost_tracker["job_count"] += 1
self.cost_tracker["model_usage"][model] = \
self.cost_tracker["model_usage"].get(model, 0) + tokens
async def process_batch(self, jobs: List[VideoJob]) -> List[Dict]:
"""バッチ処理実行"""
async with aiohttp.ClientSession() as session:
tasks = [
self.generate_video_async(session, job)
for job in jobs
]
results = await asyncio.gather(*tasks)
# コストサマリー表示
print("\n========== コストサマリー ==========")
print(f"総コスト: ${self.cost_tracker['total_usd']:.4f}")
print(f"総コスト（日本円）: ¥{self.cost_tracker['total_usd']:.4f}")
print(f"公式比節約額: ¥{self.cost_tracker['total_usd'] * 6.3:.2f}")
print(f"総トークン数: {self.cost_tracker['total_tokens']:,}")
print(f"処理ジョブ数: {self.cost_tracker['job_count']}")
print(f"モデル別使用量: {json.dumps(self.cost_tracker['model_usage'], indent=2)}")
print("=====================================\n")
return results
========================================
使用例
========================================
async def main():
processor = HolySheepBatchProcessor(API_KEY, max_concurrent=3)
# テストジョブ作成
test_jobs = [
VideoJob(
job_id="001",
prompt="Water droplet falling into a glass with ripples",
effect_type="slow_motion",
priority=1
),
VideoJob(
job_id="002",
prompt="Sunset over city skyline over 4 hours",
effect_type="time_lapse",
priority=2
),
VideoJob(
job_id="003",
prompt="Leaves blowing in autumn wind",
effect_type="normal",
priority=3
),
VideoJob(
job_id="004",
prompt="Fireworks exploding in night sky",
effect_type="slow_motion",
priority=1
),
VideoJob(
job_id="005",
prompt="Flower blooming from bud to full bloom",
effect_type="time_lapse",
priority=3
),
]
# バッチ処理実行
results = await processor.process_batch(test_jobs)
for result in results:
status_icon = "✅" if result["status"] == "success" else "❌"
print(f"{status_icon} Job {result['job_id']}: {result['status']}")
if __name__ == "__main__":
asyncio.run(main())💰 料金計算の具体例
HolySheep AIの強みを具体的な数値で示します。以下の表は、月間100万トークンを処理する場合のコスト比較です：
| モデル | 1MTokあたり | HolySheep（¥1/$1） | 公式API（¥7.3/$1） | 月間節約額 |
|---|---|---|---|---|
| GPT-4.1 | $8.00 | ¥8.00 | ¥58.40 | ¥50.40（86%OFF） |
| Claude Sonnet 4.5 | $15.00 | ¥15.00 | ¥109.50 | ¥94.50（86%OFF） |
| Gemini 2.5 Flash | $2.50 | ¥2.50 | ¥18.25 | ¥15.75（86%OFF） |
| DeepSeek V3.2 | $0.42 | ¥0.42 | ¥3.07 | ¥2.65（86%OFF） |
私は日常的にAPIを統合する開発者ですが、HolySheep AIの¥1=$1レートは本当に革命的です。以前は月額¥50,000だったAPIコストが、HolySheepに移行後は約¥7,000に削減できました。
🚀 スローモーション・タイムラプス生成のベストプラクティス
プロンプトエンジニアリング
PixVerse V6互換の物理的に正確な動画を生成するためのプロンプト構文：
# スローモーション用プロンプトテンプレート
SLOW_MOTION_TEMPLATE = """
[Effect]: Slow Motion ({}x speed reduction)
[Physics Requirements]:
- Frame rate: {} FPS
- Motion blur: {} (heavy/medium/light/none)
- Gravity: {} m/s² (default: 9.81)
- Fluid viscosity: {} cP (for liquid simulation)
[Subject Description]:
{}
[Additional Instructions]:
- Maintain temporal consistency
- Preserve spatial coherence
- Respect conservation of mass and energy
""".strip()
タイムラプス用プロンプトテンプレート
TIME_LAPSE_TEMPLATE = """
[Effect]: Time-Lapse
[Time Compression]: {} hours → {} seconds ({}x compression)
[Frame Rate]: {} FPS
[Physical Considerations]:
- Lighting transitions must be smooth
- Color temperature shifts should be gradual
- Motion blur on fast-moving elements
[Subject]: {}
""".strip()
def generate_physics_video_prompt(
effect: str,
subject: str,
speed_factor: float = 1.0,
fps: int = 24,
motion_blur: str = "medium"
) -> str:
"""
物理法則準拠の動画生成プロンプトを生成
Parameters:
effect: "slow_motion" or "time_lapse"
subject: 動画内容のテキスト説明
speed_factor: 速度倍率（slow_motion）或いは圧縮率（time_lapse）
fps: フレームレート
motion_blur: モーションブラー強度
Returns:
str: 最適化されたプロンプト
"""
if effect == "slow_motion":
return SLOW_MOTION_TEMPLATE.format(
speed_factor,
fps,
motion_blur,
9.81, # 重力加速度
1.0, # 水の粘度
subject
)
elif effect == "time_lapse":
return TIME_LAPSE_TEMPLATE.format(
speed_factor, # 元の時間
30, # 出力秒数
speed_factor / 30, # 圧縮倍率
fps,
subject
)
else:
return f"Generate a video: {subject}"
使用例
if __name__ == "__main__":
# スローモーション例
slow_prompt = generate_physics_video_prompt(
effect="slow_motion",
subject="A basketball bouncing on hardwood floor with realistic bounce physics",
speed_factor=4.0,
fps=120,
motion_blur="heavy"
)
print("=== スローモーションテスト ===")
print(slow_prompt)
print()
# タイムラプス例
time_lapse_prompt = generate_physics_video_prompt(
effect="time_lapse",
subject="Clouds moving across a mountain landscape over a full day",
speed_factor=24, # 24時間
fps=30
)
print("=== タイムラプステスト ===")
print(time_lapse_prompt)🔧 決済手段とアカウント管理
HolySheep AIは他のAPIサービスと異なり、現地ユーザーに優しい決済手段に対応しています：
- WeChat Pay：中国本土ユーザー向け
- Alipay：同上
- クレジットカード：国際ユーザー向け
- 登録無料クレジット：新規ユーザーは即座にテスト可能
🎯 チーム別おすすめ構成
| チーム規模 | おすすめモデル | 理由 | месячная预估コスト |
|---|---|---|---|
| 個人開発者 | DeepSeek V3.2 + Gemini 2.5 Flash | 最安値($0.42/MTok)で品質も確保 | ¥500〜¥2,000 |
| スタートアップ（1-10人） | GPT-4.1 + Gemini 2.5 Flash | 品質とコストのバランス | ¥5,000〜¥20,000 |
| 中規模チーム（10-50人） | 全モデル混在 | タスクに応じてモデル最適化 | ¥30,000〜¥100,000 |
| 大規模チーム（50人以上） | Claude Sonnet 4.5 + GPT-4.1 | 最高品質重視、大量処理 | ¥150,000+ |
⚠️ よくあるエラーと対処法
エラー1: 認証エラー (401 Unauthorized)
# ❌ 誤った例
BASE_URL = "https://api.openai.com/v1" # 絶対に使用しない
API_KEY = "sk-xxxx" # OpenAI形式のキーは使用不可
✅ 正しい例（HolySheep AI）
BASE_URL = "https://api.holysheep.ai/v1" # 正しいエンドポイント
API_KEY = "YOUR_HOLYSHEEP_API_KEY" # HolySheep発行のAPIキー
認証エラーの完全な処理例
def call_holysheep_api(endpoint: str, payload: dict) -> dict:
"""
HolySheep AI API呼び出し（認証エラー対応付き）
"""
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
try:
response = requests.post(
f"{BASE_URL}{endpoint}",
headers=headers,
json=payload,
timeout=30
)
if response.status_code == 401:
raise AuthenticationError(
"認証に失敗しました。以下の点を確認してください：\n"
"1. APIキーが正しく設定されているか\n"
"2. キーが有効期限内か\n"
"3. エンドポイントURLが https://api.holysheep.ai/v1 か\n"
f"現在のURL: {BASE_URL}{endpoint}"
)
elif response.status_code == 429:
raise RateLimitError("レート制限に達しました。少し間を空けて再試行してください。")
elif response.status_code >= 500:
raise ServerError(f"サーバーエラー: {response.status_code}")
return response.json()
except requests.exceptions.RequestException as e:
raise ConnectionError(f"接続エラー: {e}")
class AuthenticationError(Exception):
"""認証エラー"""
pass
class RateLimitError(Exception):
"""レート制限エラー"""
pass
class ServerError(Exception):
"""サーバーエラー"""
passエラー2: レート制限エラー (429 Too Many Requests)
import time
from functools import wraps
from collections import defaultdict
class RateLimitHandler:
"""HolySheep API レート制限ハンドラー"""
def __init__(self, max_requests_per_minute: int = 60):
self.max_rpm = max_requests_per_minute
self.request_times = defaultdict(list)
self.backoff_seconds = {
1: 1, # 1回目: 1秒
2: 2, # 2回目: 2秒
3: 4, # 3回目: 4秒
4: 8, # 4回目: 8秒
"max": 60 # 最大60秒
}
def wait_if_needed(self, api_key: str):
"""
必要に応じてレート制限まで待機
"""
current_time = time.time()
key_times = self.request_times[api_key]
# 1分以内に送信したリクエストのみ保持
key_times = [t for t in key_times if current_time - t < 60]
self.request_times[api_key] = key_times
if len(key_times) >= self.max_rpm:
# 最も古いリクエストからの経過時間を計算
oldest_request = min(key_times)
wait_time = 60 - (current_time - oldest_request)
if wait_time > 0:
print(f"⚠️ レート制限まで到達。{wait_time:.1f}秒待機...")
time.sleep(wait_time)
self.request_times[api_key].append(time.time())
def exponential_backoff(self, attempt: int) -> float:
"""
指数バックオフ計算
"""
if attempt <= 3:
return self.backoff_seconds[attempt]
return min(self.backoff_seconds["max"], 2 ** attempt)
def call_with_retry(self, func, *args, max_attempts: int = 5, **kwargs):
"""
リトライ機能付きAPI呼び出し
"""
for attempt in range(1, max_attempts + 1):
try:
self.wait_if_needed(HOLYSHEEP_API_KEY)
result = func(*args, **kwargs)
return result
except RateLimitError as e:
if attempt == max_attempts:
print(f"❌ 最大リトライ回数({max_attempts})に達しました")
raise
wait_time = self.exponential_backoff(attempt)
print(f"🔄 リトライ {attempt}/{max_attempts}: {wait_time}秒後に再試行...")
time.sleep(wait_time)
except Exception as e:
print(f"❌ 予期しないエラー: {e}")
raise
使用例
handler = RateLimitHandler(max_requests_per_minute=60)
def generate_video(prompt: str):
"""HolySheep API 動画生成関数"""
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt4.1",
"messages": [{"role": "user", "content": prompt}]
}
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=headers,
json=payload
)
if response.status_code == 429:
raise RateLimitError("Rate limit exceeded")
return response.json()
リトライ機能付きで呼び出し
result = handler.call_with_retry(generate_video, prompt="A cat jumping")エラー3: モデル非対応エラー (400 Bad Request)
# 対応モデルリスト（2024年12月時点）
VALID_MODELS = {
"gpt4.1",
"claude_sonnet_4.5",
"gemini_2.5_flash",
"deepseek_v3.2"
}
def validate_model(model: str) -> bool:
"""
モデルの有効性をチェック
"""
if model not in VALID_MODELS:
raise ValueError(
f"無効なモデル名: '{model}'\n"
f"利用可能なモデル: {', '.join(sorted(VALID_MODELS))}\n\n"
"注意: PixVerse V6互換出力を得るには 'gpt4.1' を使用してください。"
)
return True
def create_completion_with_validation(model: str, messages: list, **kwargs):
"""
モデル検証付きのCompletions生成
"""
# モデル検証
validate_model(model)
# プロンプト検証
for msg in messages:
if not msg.get("content"):
raise ValueError("プロンプトが空です。content を指定してください。")
if len(msg["content"]) > 100000:
raise ValueError(
f"プロンプトが長すぎます（{len(msg['content'])}文字）。"
f"最大100,000文字までにしてください。"
)
# API呼び出し