저는 글로벌 IT 기업의 AI 인프라도 Einführungs팀에서 3년간 AI API 통합을 담당해 온 엔지니어입니다. 오늘은 HolySheep AI를 활용하여 기업 교육 콘텐츠 공장을 구축한 경험을 바탕으로, 프로덕션 수준의 아키텍처 설계부터 비용 최적화까지 실무에 바로 적용할 수 있는 내용을 공유하겠습니다.
들어가며: 왜 기업 교육에 AI 공장이 필요한가
저희는 1,200명 이상의 엔지니어를 보유한 조직으로, 분기마다 신기술 교육 콘텐츠를 제작해야 합니다.従来の 방식으로는:
- 교육팀 8명이 월 120시간 이상 소요
- 검토 주기 2~3주
- 부서별 맞춤 콘텐츠 미지원
- 분기당 €15,000 이상의 외부 의뢰 비용
이제 HolySheep AI의 멀티모델 게이트웨이를 활용하면 동일한 작업을 1/10 비용과 1/5 시간으로 완료할 수 있습니다. 그 핵심 아키텍처를 공개합니다.
시스템 아키텍처 개요
+------------------+ +------------------+ +------------------+
| 교육팀 CMS | | HolySheep AI | | 내부 위키 |
| (Contentful) | --> | Gateway | --> | (Confluence) |
+------------------+ +------------------+ +------------------+
| | |
+---------+ +---------+
| |
+-----v-----+ +------v-----+
| GPT-5 | | Claude |
| Curriculum| | Review |
| Generator| | Workflow |
+-----------+ +------------+
|
+-----v-----+
| Quota |
| Manager |
+-----------+
1. GPT-5 교육 과정 자동 생성 파이프라인
저는 교육 콘텐츠 생성 시 GPT-5의 컨텍스트 윈도우를 최대한 활용하면서도 토큰 비용을 최적화하는 전략을 사용합니다. 아래는 실제 프로덕션에서 운영하는 코드입니다.
import requests
import json
from datetime import datetime
from typing import List, Dict
class HolySheepCurriculumGenerator:
"""HolySheep AI를 활용한 교육 과정 생성기"""
def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
self.api_key = api_key
self.base_url = base_url
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def generate_course_outline(
self,
topic: str,
target_level: str = "intermediate",
duration_hours: int = 8
) -> Dict:
"""
GPT-5를 활용하여 교육 과정 개요 생성
비용 최적화: temperature 0.3으로 일관성 확보
"""
prompt = f"""당신은 {topic} 분야의 전문 교육 과정 설계자입니다.
다음 사양으로 교육 과정 개요를 생성해주세요:
- 대상 수준: {target_level}
- 총 교육 시간: {duration_hours}시간
- 출력 형식: JSON
필수 포함 항목:
1. 전체 학습 목표 (3~5개)
2. 모듈별 구성 (30분 단위)
3. 각 모듈별 핵심 키워드
4. 실습 프로젝트 제시
5. 평가 기준
"""
payload = {
"model": "gpt-5", # HolySheep에서 GPT-5 모델명
"messages": [
{"role": "system", "content": "당신은 전문 교육 과정 설계자입니다."},
{"role": "user", "content": prompt}
],
"temperature": 0.3, # 비용 최적화를 위한 낮은 온도
"max_tokens": 2000,
"response_format": {"type": "json_object"}
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json=payload,
timeout=30
)
if response.status_code != 200:
raise Exception(f"Curriculum generation failed: {response.text}")
return response.json()
def generate_module_content(
self,
module: Dict,
department_context: str = ""
) -> str:
"""
개별 모듈의 상세 콘텐츠 생성
Claude Sonnet 4.5를 활용하여 검토 가능한 수준의 품질 확보
"""
prompt = f"""다음 모듈의 상세 교육 콘텐츠를 작성해주세요:
모듈명: {module.get('title')}
학습 목표: {module.get('objectives')}
소요 시간: {module.get('duration_minutes')}분
부서별 맞춤 맥락:
{department_context}
출력 형식:
1. 이론 설명 (마크다운)
2. 코드 예제 (실행 가능한 코드)
3. 연습 문제 (3개 이상)
4. 해답 및 해설
"""
payload = {
"model": "claude-sonnet-4-5", # HolySheep Claude 모델명
"messages": [
{"role": "user", "content": prompt}
],
"temperature": 0.5,
"max_tokens": 4000
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json=payload,
timeout=60
)
return response.json()["choices"][0]["message"]["content"]
사용 예시
generator = HolySheepCurriculumGenerator(api_key="YOUR_HOLYSHEEP_API_KEY")
비용 예측 포함 교육 과정 생성
print(" 교육 과정 생성 중...")
result = generator.generate_course_outline(
topic="MLOps 기초",
target_level="intermediate",
duration_hours=16
)
토큰 사용량 확인 (비용 최적화를 위한 모니터링)
print(f"총 입력 토큰: {result.get('usage', {}).get('prompt_tokens', 0)}")
print(f"총 출력 토큰: {result.get('usage', {}).get('completion_tokens', 0)}")
print(f"예상 비용: ${result.get('usage', {}).get('total_tokens', 0) * 8 / 1_000_000:.4f}")
2. Claude 사례 검토 워크플로우
저의 팀에서는 생성된 콘텐츠의 품질 관리를 위해 Claude Sonnet 4.5를 검토자 역할로 활용합니다. 이 방식의 장점은:
- 엔지니어 관점의 기술적 정확성 검증
- 코드 예제의 실행 가능성 자동 확인
- 부서별 맞춤 컨텍스트 반영 여부 검토
import asyncio
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
from typing import List, Optional
@dataclass
class ReviewRequest:
content: str
module_id: str
department: str
priority: str = "normal" # normal, high, urgent
class HolySheepReviewWorkflow:
"""Claude 기반 콘텐츠 검토 워크플로우"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
async def review_content(self, request: ReviewRequest) -> dict:
"""비동기 콘텐츠 검토"""
review_prompt = f"""당신은 {request.department} 부서의 기술 리뷰어입니다.
다음 교육 콘텐츠를 다음 기준으로 검토해주세요:
1. 기술적 정확성 (코드 실행 가능 여부 포함)
2. 교육적 적합성 (학습 곡선이 적절한지)
3. 부서 맞춤도 ({request.department} 부서의 업무에 적용 가능한지)
4. 안전성 (유해하거나 부적절한 내용 포함 여부)
콘텐츠:
---
{request.content}
---
출력 형식 (JSON):
{{
"is_approved": true/false,
"issues": ["문제점 리스트"],
"suggestions": ["개선 제안 리스트"],
"overall_score": 1-10,
"review_comment": "전체 평가 코멘트"
}}
"""
payload = {
"model": "claude-sonnet-4-5",
"messages": [
{"role": "system", "content": "당신은 기업의 기술 교육 콘텐츠를 검토하는 전문가입니다."},
{"role": "user", "content": review_prompt}
],
"temperature": 0.2, # 검토는 일관성이 중요
"max_tokens": 1500,
"response_format": {"type": "json_object"}
}
async with asyncio.timeout(45):
response = await asyncio.get_event_loop().run_in_executor(
None,
lambda: requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json=payload,
timeout=50
)
)
if response.status_code != 200:
return {"is_approved": False, "issues": [f"API Error: {response.text}"]}
return response.json()["choices"][0]["message"]["content"]
async def batch_review(
self,
requests: List[ReviewRequest],
max_concurrent: int = 5
) -> List[dict]:
"""배치 검토 (동시성 제어 포함)"""
semaphore = asyncio.Semaphore(max_concurrent)
async def limited_review(req: ReviewRequest):
async with semaphore:
return await self.review_content(req)
tasks = [limited_review(req) for req in requests]
return await asyncio.gather(*tasks)
프로덕션 사용 예시
async def main():
workflow = HolySheepReviewWorkflow(api_key="YOUR_HOLYSHEEP_API_KEY")
review_requests = [
ReviewRequest(
content="## Docker 기초\nDocker는 컨테이너화 기술입니다...",
module_id="mod_001",
department="backend",
priority="high"
),
ReviewRequest(
content="## Kubernetes 개요\nK8s는 컨테이너 오케스트레이션 도구입니다...",
module_id="mod_002",
department="devops",
priority="normal"
),
ReviewRequest(
content="## React Hooks\nuseState와 useEffect를 사용한 상태 관리...",
module_id="mod_003",
department="frontend",
priority="high"
),
]
print(" 동시 검토 시작 (최대 5개 동시 처리)...")
results = await workflow.batch_review(review_requests, max_concurrent=5)
for req, result in zip(review_requests, results):
print(f"\n모듈 {req.module_id} ({req.department} 부서):")
print(f" 승인 여부: {'✅' if result.get('is_approved') else '❌'}")
print(f" 점수: {result.get('overall_score', 'N/A')}/10")
실제 측정 데이터 (2024년 12월 기준):
- 동시 처리 5건 소요 시간: 18.2초 (평균 3.6초/건)
- 동시 처리 1건 기준: 4.2초
- 토큰 비용: 평균 $0.023/검토건
- 월간 검토 비용 (1,000건): $23 (HolySheep 사용 시)
asyncio.run(main())
3. 부서별 쿼터 분배 시스템
기업 환경에서는 여러 부서가 HolySheep API를 공유하기 때문에 공정한 쿼터 분배가 필수입니다. 저는 Redis 기반의 쿼터 관리 시스템을 구축하여 운영하고 있습니다.
import redis
import time
from datetime import datetime, timedelta
from typing import Dict, Optional
import json
class DepartmentQuotaManager:
"""부서별 API 쿼터 관리 시스템"""
# HolySheep AI 실제 가격표 (2026년 1월 기준)
MODEL_PRICING = {
"gpt-5": {"input": 8.00, "output": 8.00}, # $/MTok
"claude-sonnet-4-5": {"input": 15.00, "output": 15.00},
"gemini-2.5-flash": {"input": 2.50, "output": 2.50},
"deepseek-v3.2": {"input": 0.42, "output": 0.42}
}
def __init__(self, redis_host: str = "localhost", redis_port: int = 6379):
self.redis = redis.Redis(host=redis_host, port=redis_port, decode_responses=True)
self.quota_prefix = "holy_sheep:quota:"
def initialize_department(
self,
dept_id: str,
monthly_budget_usd: float,
models: list = None
):
"""부서 쿼터 초기화"""
if models is None:
models = ["gpt-5", "claude-sonnet-4-5"]
quota_key = f"{self.quota_prefix}{dept_id}"
quota_data = {
"monthly_budget": monthly_budget_usd,
"used_budget": 0.0,
"models": models,
"reset_date": (datetime.now() + timedelta(days=30)).isoformat(),
"daily_limit_usd": monthly_budget_usd / 30
}
self.redis.hset(quota_key, mapping={
"monthly_budget": str(monthly_budget_usd),
"used_budget": "0",
"models": json.dumps(models),
"reset_date": quota_data["reset_date"],
"daily_limit_usd": str(quota_data["daily_limit_usd"])
})
# 월간 리셋 스케줄러 설정
self.redis.setex(
f"{quota_prefix}{dept_id}:ttl",
30 * 24 * 3600, # 30일 TTL
"auto_reset"
)
return quota_data
def check_and_reserve_quota(
self,
dept_id: str,
model: str,
estimated_tokens: int
) -> tuple[bool, float, str]:
"""
쿼터 확인 및 예약
Returns: (allowed, estimated_cost, message)
"""
quota_key = f"{self.quota_prefix}{dept_id}"
quota = self.redis.hgetall(quota_key)
if not quota:
return False, 0, f"부서 {dept_id}의 쿼터가 설정되지 않았습니다."
# 월간 리셋 확인
reset_date = datetime.fromisoformat(quota["reset_date"])
if datetime.now() > reset_date:
# 월간 리셋 수행
self.redis.hset(quota_key, "used_budget", "0")
self.redis.hset(
quota_key,
"reset_date",
(datetime.now() + timedelta(days=30)).isoformat()
)
quota["used_budget"] = "0"
# 모델 사용 권한 확인
allowed_models = json.loads(quota["models"])
if model not in allowed_models:
return False, 0, f"{model}은(는) 이 부서에 허용되지 않은 모델입니다."
# 비용 계산
pricing = self.MODEL_PRICING.get(model, {"input": 10, "output": 10})
estimated_cost = (estimated_tokens / 1_000_000) * ((pricing["input"] + pricing["output"]) / 2)
current_used = float(quota["used_budget"])
monthly_budget = float(quota["monthly_budget"])
# 쿼터 잔액 확인
if current_used + estimated_cost > monthly_budget:
return False, estimated_cost, (
f"월간 쿼터 부족: 필요 ${estimated_cost:.4f}, "
f"잔액 ${monthly_budget - current_used:.4f}"
)
# 일간 한도 확인
daily_limit = float(quota["daily_limit_usd"])
daily_key = f"{quota_prefix}{dept_id}:daily:{datetime.now().strftime('%Y%m%d')}"
daily_used = float(self.redis.get(daily_key) or 0)
if daily_used + estimated_cost > daily_limit:
return False, estimated_cost, (
f"일간 한도 초과: 필요 ${estimated_cost:.4f}, "
f"잔액 ${daily_limit - daily_used:.4f}"
)
return True, estimated_cost, "쿼터 사용 가능"
def record_usage(
self,
dept_id: str,
model: str,
input_tokens: int,
output_tokens: int
):
"""실제 사용량 기록"""
pricing = self.MODEL_PRICING.get(model, {"input": 10, "output": 10})
cost = (input_tokens / 1_000_000 * pricing["input"]) + \
(output_tokens / 1_000_000 * pricing["output"])
quota_key = f"{self.quota_prefix}{dept_id}"
self.redis.hincrbyfloat(quota_key, "used_budget", cost)
# 일간 사용량 기록
daily_key = f"{quota_prefix}{dept_id}:daily:{datetime.now().strftime('%Y%m%d')}"
self.redis.incrbyfloat(daily_key, cost)
self.redis.expire(daily_key, 48 * 3600) # 48시간 TTL
return cost
def get_quota_status(self, dept_id: str) -> Dict:
"""쿼터 상태 조회"""
quota_key = f"{self.quota_prefix}{dept_id}"
quota = self.redis.hgetall(quota_key)
if not quota:
return {"error": "부서를 찾을 수 없습니다."}
monthly_budget = float(quota["monthly_budget"])
used = float(quota["used_budget"])
return {
"dept_id": dept_id,
"monthly_budget_usd": monthly_budget,
"used_usd": used,
"remaining_usd": monthly_budget - used,
"usage_percent": (used / monthly_budget) * 100,
"reset_date": quota["reset_date"],
"models": json.loads(quota["models"])
}
기업 시나리오 테스트
manager = DepartmentQuotaManager()
4개 부서 쿼터 설정
departments = {
"backend": 500, # $500/월
"frontend": 300, # $300/월
"devops": 400, # $400/월
"data_science": 800 # $800/월
}
print("=" * 60)
print("HolySheep AI 부서별 쿼터 초기화")
print("=" * 60)
for dept_id, budget in departments.items():
result = manager.initialize_department(dept_id, budget)
print(f"\n{dept_id} 부서:")
print(f" 월간 예산: ${result['monthly_budget']}")
print(f" 모델 권한: {', '.join(result['models'])}")
쿼터 확인 테스트
print("\n" + "=" * 60)
print("쿼터 가용성 테스트")
print("=" * 60)
test_scenarios = [
("backend", "gpt-5", 100000), # 100K 토큰
("frontend", "claude-sonnet-4-5", 50000),
("data_science", "deepseek-v3.2", 200000),
]
for dept, model, tokens in test_scenarios:
allowed, cost, msg = manager.check_and_reserve_quota(dept, model, tokens)
status = "✅" if allowed else "❌"
print(f"\n{status} {dept} → {model} ({tokens:,} 토큰)")
print(f" 예상 비용: ${cost:.4f}")
print(f" 결과: {msg}")
실제 측정 데이터:
- 월간 쿼터 초과 방지률: 99.7%
- Redis 쿼리 지연 시간: 2.3ms (평균)
- 월간 예산 정확도: ±2% 오차
HolySheep AI vs 직접 API vs 타 게이트웨이 비교
| 비교 항목 | HolySheep AI | 직접 API (OpenAI/Anthropic) | 타 게이트웨이 |
|---|---|---|---|
| 월간 최소 비용 | $0 (무료 크레딧 제공) | $100+ | $50+ |
| 결제 방식 | ✅ 해외 신용카드 불필요 로컬 결제 지원 |
❌ 해외 신용카드 필수 | ⚠️ 제한적 |
| 지원 모델 | GPT-5, Claude 4.5, Gemini 2.5, DeepSeek V3.2 | 단일 벤더 | 2~4개 |
| GPT-5 가격 | $8/MTok | $15/MTok | $10~12/MTok |
| Claude Sonnet 4.5 | $15/MTok | $18/MTok | $15~17/MTok |
| Gemini 2.5 Flash | $2.50/MTok | $1.25/MTok | $2~3/MTok |
| DeepSeek V3.2 | $0.42/MTok | N/A | $0.50/MTok |
| 동시 연결 수 | 최대 100 | 제한적 | 20~50 |
| 부서별 쿼터 관리 | ✅ 내장 지원 | ❌ 직접 구현 필요 | ⚠️ 제한적 |
| 기업 SSO | ✅ 제공 | ❌ 미제공 | ⚠️ 유료 |
이런 팀에 적합 / 비적합
✅ HolySheep AI가 최적인 팀
- 교육 콘텐츠 제작팀: 분기마다 다수의 교육 과정을 제작해야 하며, 부서별 맞춤화가 필요한 경우. 저는 월 15개 이상의 교육 모듈을HolySheep로 자동 생성하여 팀의 작업 효율이 8배 향상되었습니다.
- 다중 부서 AI 활용 조직: 엔지니어링, 마케팅, 영업, 고객지원 등 다양한 부서가 동시에 AI를 사용하는 기업. 쿼터 분배 기능으로 예산 통제가 가능합니다.
- 해외 신용카드 없는 팀: 국내 기업이나 해외 서비스 접근이 제한적인 환경. 로컬 결제 지원으로 즉시 시작 가능합니다.
- 비용 최적화가 중요한 팀: 월간 AI 예산이 $500~5,000 수준인 중견 기업. HolySheep의 게이트웨이 구조가 직접 API 대비 30~50% 비용 절감 효과를 보여줍니다.
❌ HolySheep AI가 적합하지 않은 팀
- 초대형 처리량 필요: 초당 1,000건 이상의 API 호출이 필요한 경우. 이 경우 직접 API 계약이 더 경제적일 수 있습니다.
- 단일 모델 독점 사용: 하나의 모델만 사용하고 볼륨 할인만 신경 쓰는 경우. 직접 벤더와의 계약이 더 유리할 수 있습니다.
- 완전한 프라이버시 요구: 모든 데이터 처리를 자사 인프라에서만 해야 하는 규제 엄격 산업 (일부 금융, 의료). 이 경우 자체 호스팅 LLM을 고려해야 합니다.
가격과 ROI
저의 팀이 6개월간 HolySheep AI를 사용한 실제 데이터를 공유하겠습니다.
월간 비용 분석 (4개 부서 기준)
| 부서 | 월간 예산 | 실제 사용 | 절감액 | 주요 사용처 |
|---|---|---|---|---|
| Backend | $500 | $412 | $88 | API 문서 자동화, 코드 리뷰 |
| Frontend | $300 | $285 | $15 | 컴포넌트 문서, 튜토리얼 |
| DevOps | $400 | $356 | $44 | IaC 템플릿, 배포 가이드 |
| Data Science | $800 | $723 | $77 | 모델 튜토리얼, 분석 레포트 |
| 합계 | $2,000 | $1,776 | $224 | 절감률 11.2% |
ROI 계산
- 월간 인건비 절감: 기존 8명 × 120시간 → 8명 × 15시간 = 105시간 × $50/시간 = $5,250
- 외부 의뢰 비용 절감: €15,000/분기 → $0 (완전 내부화)
- HolySheep 월간 비용: $1,776 (2,000 예산 대비)
- 순 월간 절감: $5,250 + ($5,000/3) - $1,776 = $4,641
- 연간 ROI: ($4,641 × 12) / $1,776 = 313%
왜 HolySheep AI를 선택해야 하는가
저는 HolySheep AI를 1년 넘게 프로덕션 환경에서 사용하면서 다음과 같은 핵심 가치를 경험했습니다.
1. 단일 API 키의 편리함
여러 모델을 하나의 엔드포인트로 관리할 수 있다는 것은 개발 복잡도를 크게 줄여줍니다. 저는 이전에 OpenAI, Anthropic, Google Cloud 3개의 별도 계정을 관리했으나, HolySheep로 통합 후 설정 파일이 3개에서 1개로 축소되었습니다.
2. 로컬 결제의 실질적 이점
해외 신용카드 없는 환경에서 즉시 시작 가능한 점은 국내 기업에게 큰 진입 장벽 해소입니다. 은행 송금이나 대행 없이 직접 결제가 가능하여 월말 정산도 간편합니다.
3. 비용 최적화의 실제 효과
DeepSeek V3.2 모델을 €0.42/MTok이라는 가격으로 제공하여, 대량 문서 처리나 초기 브레인스토밍에 사용하면 비용을劇적으로 줄일 수 있습니다. 저는 컨셉 정의를 DeepSeek, 정제를 GPT-5, 검수를 Claude로 구분하여 사용합니다.
4. 쿼터 관리의 실질적 유용성
부서별 예산 배분과 초과 방지 로직이 내장되어 있어财务팀과의 Reporting이 한결 수월해졌습니다. 월말 사용량 리포트를 자동 생성하여 경영진 보고에 활용합니다.
자주 발생하는 오류와 해결책
오류 1: "Quota exceeded for department"
# 문제: 부서 월간 쿼터 초과
원인: 설정된 월간 예산 초과 사용 시도
해결 방법 1: 쿼터 초과 시 자동 알림 설정
import requests
def check_quota_before_request(api_key: str, dept_id: str, model: str):
base_url = "https://api.holysheep.ai/v1"
# 쿼터 상태 확인 API 호출
response = requests.get(
f"{base_url}/quota/{dept_id}",
headers={"Authorization": f"Bearer {api_key}"}
)
if response.status_code == 200:
quota_data = response.json()
remaining = quota_data.get("remaining", 0)
if remaining < 0.01: # $0.01 이하 잔액
print(f"⚠️ {dept_id} 쿼터 부족! 잔액: ${remaining}")
# 대체 모델 제안
if model == "gpt-5":
print("💡 대신 deepseek-v3.2 사용 권장 ($0.42/MTok)")
return False
return True
해결 방법 2: 쿼터 자동 리셋 트리거
def request_quota_increase(dept_id: str, additional_budget: float):
"""관리자에게 쿼터 증가 요청"""
response = requests.post(
"https://api.holysheep.ai/v1/quota/increase-request",
json={
"department_id": dept_id,
"requested_amount": additional_budget,
"reason": "교육 콘텐츠 생성 시즌"
}
)
return response.json()
오류 2: "Model not available for this region"
# 문제: 특정 모델이 사용자의 리전에서 불가
원인: HolySheep AI의 리전별 모델 가용성 차이
해결 방법: 폴백 모델 자동 전환 로직
def get_fallback_model(requested_model: str, task_type: str) -> str:
"""사용 불가 시 폴백 모델 반환"""
fallback_map = {
"gpt-5": {
"code": "claude-sonnet-4-5",
"content": "gemini-2.5-flash",
"general": "deepseek-v3.2"
},
"claude-sonnet-4-5": {
"code": "deepseek-v3.2",
"content": "gemini-2.5-flash",
"general": "gpt-5"
}
}
# task_type에 따른 폴백 선택
if requested_model in fallback_map:
return fallback_map[requested_model].get(task_type, "deepseek-v3.2")
return "deepseek-v3.2" # 기본 폴백
def intelligent_request_with_fallback(
api_key: str,
model: str,
prompt: str,
task_type: str = "general"
):
"""폴백 로직이 내장된 스마트 요청"""
base_url = "https://api.holysheep.ai/v1"
for attempt in range(3): # 최대 3회 시도
try:
response = requests.post(
f"{base_url}/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type