고빈도 그리드 거래를 운영하면서 API 비용이 급격히 증가하신 경험이 있으신가요? 본 가이드에서는 기존 AI API 환경에서 HolySheep AI로 마이그레이션하는 전체 프로세스를 다룹니다. 저는 실제로 3개월간 같은 문제를 겪으며 최적의 해결책을 찾은 후, 이 마이그레이션 플레이북을 작성하게 되었습니다.
그리드 거래와 AI API의 관계
그리드 거래는 일정 가격 간격으로 매수/매도 주문을 반복 배치하는 전략입니다. 현대적인 그리드 봇은 시장 분석, 포지션 조정, 리스크 평가를 위해 AI API를 활용합니다:
- 시장 감정 분석: 실시간 뉴스와 소셜 미디어 데이터 처리
- 가격 예측 모델: 시계열 분석을 위한 LLM 활용
- 포트폴리오 최적화: 리스크 수익률 분석
- 자동 의사결정: 조건부 전략 실행 로직
이러한 작업은 초당 수십 회의 API 호출을 필요로 하며, 비용 최적화가 수익률에 직결됩니다.
왜 HolySheep로 마이그레이션해야 하는가
기존 환경의 문제점
공식 OpenAI/Anthropic API나 기타 중계 서비스를 사용하는 경우, 다음과 같은 문제에 직면합니다:
- 높은 API 비용: 대규모 그리드 봇은 월 $500~2000 이상의 비용 발생
- 해외 신용카드 필수로 결제 어려움
- 지역별 접속 제한으로 인한 연결 불안정
- 속도 제한으로 거래 시점 놓침
HolySheep 선택 이유
HolySheep AI는 이러한 문제의 완벽한 해결책입니다:
- 로컬 결제 지원으로 해외 신용카드 불필요
- 단일 API 키로 GPT-4.1, Claude Sonnet, Gemini, DeepSeek 통합
- DeepSeek V3.2의 경우 $0.42/MTok으로 95% 비용 절감 가능
- 안정적인 글로벌 연결과 빠른 응답 시간
플랫폼 비교
| 항목 | 공식 API | 기타 중계 | HolySheep AI |
|---|---|---|---|
| DeepSeek V3.2 | $0.42/MTok | $0.35~0.50/MTok | $0.42/MTok |
| Gemini 2.5 Flash | $2.50/MTok | $2.00~3.00/MTok | $2.50/MTok |
| GPT-4.1 | $8.00/MTok | $6.00~10.00/MTok | $8.00/MTok |
| 결제 방법 | 해외 신용카드 | 불안정 | 로컬 결제 지원 |
| 연결 안정성 | 지역 제한 | 중간 | 최적화 |
| 모델 통합 | 단일 | 제한적 | 전체 모델 |
이런 팀에 적합 / 비적합
✓ HolySheep가 적합한 경우
- 일일 10,000회 이상의 AI API 호출이 필요한 그리드 봇 운영
- 여러 거래소(Binance, Bybit, OKX 등)를 동시에 활용하는 팀
- 국내 카드만으로 결제해야 하는 해외 기반 팀
- 비용 최적화를 위해 모델 전환이 필요한 전략 보유
- 높은 가용성(99.9% 이상)이 요구되는 실시간 거래 시스템
✗ HolySheep가 적합하지 않은 경우
- 일일 API 호출이 100회 미만인 소규모 개인 트레이더
- 특정 모델(예: GPT-4.1 전용)을 강제로 사용해야 하는 환경
- 국내 통신사 기반 인터넷만 사용하는 환경(제한 가능성)
- 초저지연(<5ms)이 절대적으로 필요한 고주파 호가창 트레이딩
마이그레이션 단계
1단계: 현재 환경 분석
마이그레이션 전에 현재 사용량을 정확히 파악해야 합니다:
# 현재 월간 API 사용량 분석 스크립트
import requests
from datetime import datetime, timedelta
class APIUsageAnalyzer:
def __init__(self, current_endpoint, api_key):
self.endpoint = current_endpoint
self.api_key = api_key
self.total_cost = 0
self.total_tokens = 0
self.call_count = 0
def analyze_monthly_usage(self):
# 실제 환경에서는 로그 파일이나 모니터링 대시보드 활용
# 예시 데이터 구조
usage_data = {
"gpt4_calls": 45000,
"claude_calls": 23000,
"gemini_calls": 67000,
"deepseek_calls": 120000
}
return usage_data
def estimate_monthly_cost(self):
pricing = {
"gpt4": 8.00, # $/MTok
"claude": 15.00, # $/MTok
"gemini": 2.50, # $/MTok
"deepseek": 0.42 # $/MTok
}
# 평균 토큰 소비량 가정
avg_tokens = {
"gpt4": 2000, # 입력+출력
"claude": 1800,
"gemini": 1500,
"deepseek": 1200
}
usage = self.analyze_monthly_usage()
costs = {}
for model, calls in usage.items():
model_key = model.replace("_calls", "")
cost = (calls * avg_tokens[model_key] / 1_000_000) * pricing[model_key]
costs[model_key] = cost
self.total_cost += cost
self.call_count += calls
return costs, self.total_cost
analyzer = APIUsageAnalyzer(
current_endpoint="https://api.openai.com/v1",
api_key="CURRENT_API_KEY"
)
costs, total = analyzer.estimate_monthly_cost()
print(f"현재 월간 비용: ${total:.2f}")
for model, cost in costs.items():
print(f" {model}: ${cost:.2f}")
2단계: HolySheep API 키 발급
HolySheep AI 가입 후 대시보드에서 API 키를 발급받습니다. 로컬 결제를 통해 즉시 사용 가능합니다.
3단계: 클라이언트 마이그레이션 구현
# HolySheep AI 그리드 거래 통합 클라이언트
import requests
import time
import json
from typing import Dict, List, Optional
from dataclasses import dataclass
from enum import Enum
class ModelType(Enum):
DEEPSEEK = "deepseek"
GEMINI = "gemini"
GPT4 = "gpt4"
CLAUDE = "claude"
@dataclass
class TradingSignal:
action: str # "buy", "sell", "hold"
price: float
confidence: float
reasoning: str
class HolySheepGridClient:
"""HolySheep AI를 활용한 그리드 거래 클라이언트"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
})
def analyze_market(self, symbol: str, price_data: Dict, model: ModelType = ModelType.DEEPSEEK) -> TradingSignal:
"""
시장 데이터 분석하여 거래 시그널 생성
HolySheep AI의 DeepSeek 모델로 비용 최적화
"""
prompt = f"""당신은 전문 그리드 트레이더입니다.
현재 거래 정보:
- 심볼: {symbol}
- 현재가: ${price_data.get('current_price', 0)}
- 24시간 변동성: {price_data.get('volatility', 0)}%
- 거래량: {price_data.get('volume', 0)}
- 매수호가: ${price_data.get('bid', 0)}
- 매도호가: ${price_data.get('ask', 0)}
분석 후 다음 형식으로 응답:
{{"action": "buy|sell|hold", "price": 숫자, "confidence": 0.0~1.0, "reasoning": "분석 근거"}}"""
response = self._call_model(prompt, model)
return self._parse_signal(response)
def _call_model(self, prompt: str, model: ModelType) -> str:
"""HolySheep AI 모델 호출"""
model_mapping = {
ModelType.DEEPSEEK: "deepseek-chat",
ModelType.GEMINI: "gemini-2.5-flash",
ModelType.GPT4: "gpt-4.1",
ModelType.CLAUDE: "claude-sonnet-4-20250514"
}
endpoint = f"{self.BASE_URL}/chat/completions"
payload = {
"model": model_mapping[model],
"messages": [
{"role": "system", "content": "당신은 암호화폐 시장 분석 전문가입니다."},
{"role": "user", "content": prompt}
],
"temperature": 0.3,
"max_tokens": 500
}
try:
response = self.session.post(endpoint, json=payload, timeout=30)
response.raise_for_status()
result = response.json()
return result["choices"][0]["message"]["content"]
except requests.exceptions.RequestException as e:
print(f"API 호출 실패: {e}")
return '{"action": "hold", "price": 0, "confidence": 0, "reasoning": "API 오류"}'
def _parse_signal(self, response: str) -> TradingSignal:
"""응답 파싱"""
try:
data = json.loads(response)
return TradingSignal(
action=data.get("action", "hold"),
price=float(data.get("price", 0)),
confidence=float(data.get("confidence", 0)),
reasoning=data.get("reasoning", "")
)
except json.JSONDecodeError:
return TradingSignal("hold", 0, 0, "파싱 오류")
def batch_analyze_markets(self, markets: List[Dict]) -> List[TradingSignal]:
"""
배치 분석 - 여러 시장을 동시에 분석하여 API 호출 최적화
"""
signals = []
for market in markets:
# 비용 최적화를 위해 기본적으로 DeepSeek 사용
signal = self.analyze_market(
symbol=market["symbol"],
price_data=market["data"],
model=ModelType.DEEPSEEK
)
signals.append(signal)
# 속도 제한 방지
time.sleep(0.1)
return signals
사용 예시
def run_grid_trading():
client = HolySheepGridClient(api_key="YOUR_HOLYSHEEP_API_KEY")
markets = [
{
"symbol": "BTC/USDT",
"data": {
"current_price": 67500,
"volatility": 2.3,
"volume": 15000000000,
"bid": 67495,
"ask": 67505
}
},
{
"symbol": "ETH/USDT",
"data": {
"current_price": 3450,
"volatility": 3.1,
"volume": 8000000000,
"bid": 3449,
"ask": 3451
}
}
]
signals = client.batch_analyze_markets(markets)
for market, signal in zip(markets, signals):
print(f"\n{market['symbol']}:")
print(f" 행동: {signal.action}")
print(f" 가격: ${signal.price}")
print(f" 신뢰도: {signal.confidence:.2%}")
print(f" 근거: {signal.reasoning}")
if __name__ == "__main__":
run_grid_trading()
4단계: 그리드 전략 로직 구현
# 고급 그리드 거래 전략 + HolySheep AI 시장 분석
import time
from collections import deque
import statistics
class GridTradingStrategy:
"""AI 기반 고급 그리드 거래 시스템"""
def __init__(self, api_client, config: dict):
self.client = api_client
self.config = config
self.price_history = deque(maxlen=100)
self.grid_levels = []
self.current_position = 0
# HolySheep AI 모델 선택 (비용 최적화)
self.analysis_model = config.get("model", "deepseek")
def initialize_grid(self, current_price: float):
"""그리드 레벨 초기화"""
grid_count = self.config.get("grid_count", 10)
price_range = self.config.get("price_range", 0.05) # ±5%
lowest = current_price * (1 - price_range)
highest = current_price * (1 + price_range)
step = (highest - lowest) / grid_count
self.grid_levels = [
lowest + (step * i) for i in range(grid_count + 1)
]
print(f"그리드 초기화 완료: {lowest:.2f} ~ {highest:.2f}")
print(f"레벨 간격: ${step:.2f}")
def calculate_grid_orders(self, current_price: float, ai_signal) -> List[dict]:
"""
AI 시그널과 그리드 레벨을 결합하여 주문 생성
HolySheep AI 분석 결과 반영
"""
orders = []
# AI 신뢰도에 따라 주문 크기 조정
base_size = self.config.get("order_size", 100)
adjusted_size = base_size * ai_signal.confidence
# 그리드 레벨 기반 매수 주문
for i, level in enumerate(self.grid_levels[:-1]):
if current_price > level and current_price < self.grid_levels[i + 1]:
# 현재 가격 아래 레벨에 매수 주문
if ai_signal.action in ["buy", "hold"] and self.current_position < 5:
orders.append({
"type": "limit",
"side": "buy",
"price": level,
"size": adjusted_size,
"grid_index": i
})
# 현재 가격 위 레벨에 매도 주문
if self.current_position > 0:
orders.append({
"type": "limit",
"side": "sell",
"price": self.grid_levels[i + 1],
"size": adjusted_size * 0.5,
"grid_index": i + 1
})
return orders
def get_market_data(self, symbol: str) -> dict:
"""거래소에서 시장 데이터 조회 (실제 구현 시 거래소 API 연동)"""
# 실제로는 거래소 WebSocket/API 활용
return {
"current_price": 67500, # 예시
"volatility": 2.3,
"volume": 15000000000,
"bid": 67495,
"ask": 67505
}
def run_trading_cycle(self):
"""단일 거래 사이클 실행"""
symbol = self.config.get("symbol", "BTC/USDT")
# 1. 시장 데이터 수집
market_data = self.get_market_data(symbol)
current_price = market_data["current_price"]
self.price_history.append(current_price)
# 2. HolySheep AI로 시장 분석
ai_signal = self.client.analyze_market(
symbol=symbol,
price_data=market_data,
model=self.analysis_model
)
print(f"\n현재가: ${current_price}")
print(f"AI 신호: {ai_signal.action} (신뢰도: {ai_signal.confidence:.2%})")
# 3. 그리드 초기화 (최초 1회 또는 재초기화)
if not self.grid_levels:
self.initialize_grid(current_price)
# 4. 주문 생성 및 실행
orders = self.calculate_grid_orders(current_price, ai_signal)
print(f"생성된 주문 수: {len(orders)}")
for order in orders:
print(f" {order['side'].upper()} @ ${order['price']} x {order['size']}")
# 실제로는 거래소 API로 주문 실행
self._execute_order(order)
def _execute_order(self, order: dict):
"""주문 실행 (실제 거래소 연동 필요)"""
if order["side"] == "buy":
self.current_position += order["size"]
else:
self.current_position -= order["size"]
실행 예시
if __name__ == "__main__":
from holySheep_client import HolySheepGridClient, ModelType
client = HolySheepGridClient(api_key="YOUR_HOLYSHEEP_API_KEY")
strategy = GridTradingStrategy(
api_client=client,
config={
"symbol": "BTC/USDT",
"grid_count": 10,
"price_range": 0.05,
"order_size": 0.01,
"model": "deepseek" # 비용 최적화를 위해 DeepSeek 권장
}
)
# 메인 루프 (실제로는 WebSocket이나 스케줄러 활용)
while True:
try:
strategy.run_trading_cycle()
time.sleep(60) # 1분마다 분석
except KeyboardInterrupt:
print("\n거래 시스템 종료")
break
except Exception as e:
print(f"오류 발생: {e}")
time.sleep(10)
리스크 평가
| 리스크 항목 | 영향도 | 발생 확률 | 대응 방안 |
|---|---|---|---|
| API 연결 단절 | 높음 | 낮음 | 자동 재연결 + 폴백 모델 전환 |
| 응답 지연 증가 | 중간 | 중간 | Gemini Flash로 모델 전환 |
| 비용 초과 | 중간 | 낮음 | 일일 호출 한도 설정 |
| 모델 가용성 문제 | 낮음 | 매우 낮음 | 멀티 모델 핫스왑 |
롤백 계획
마이그레이션 중 문제가 발생할 경우를 대비해 즉시 롤백 가능한 환경을 구축해야 합니다:
# 롤백 매커니즘 구현
class RollbackManager:
"""마이그레이션 롤백 관리자"""
def __init__(self, primary_client, fallback_client):
self.primary = primary_client # HolySheep
self.fallback = fallback_client # 기존 API
self.is_rollback = False
self.health_check_interval = 60 # 초
def health_check(self) -> bool:
"""연결 상태 확인"""
try:
test_response = self.primary.batch_analyze_markets([
{"symbol": "TEST", "data": {"current_price": 100, "volatility": 1, "volume": 1000, "bid": 99, "ask": 101}}
])
return test_response[0] is not None
except Exception as e:
print(f"Health check 실패: {e}")
return False
def switch_to_fallback(self):
"""폴백 모드로 전환"""
print("⚠️ HolySheep API 문제 감지 - 폴백 모드로 전환")
self.is_rollback = True
def switch_to_primary(self):
"""프라이머리 모드 복귀"""
print("✅ HolySheep API 복구 - 프라이머리 모드로 전환")
self.is_rollback = False
def call_api(self, prompt: str, model_type):
"""API 호출 - 문제 시 자동 폴백"""
if not self.is_rollback:
try:
result = self.primary.analyze_market("TEST", {"current_price": 100}, model_type)
# 응답 시간 기반 헬스체크
if result is None:
self.switch_to_fallback()
return result
except Exception as e:
print(f"프라이머리 API 오류: {e}")
self.switch_to_fallback()
# 폴백 모드
return self.fallback.analyze_market("TEST", {"current_price": 100}, model_type)
사용 예시
rollback_manager = RollbackManager(
primary_client=HolySheepGridClient("HOLYSHEEP_KEY"),
fallback_client=OldAPIClient("OLD_API_KEY")
)
메인 루프에서 주기적 헬스체크
import threading
def health_check_loop():
while True:
time.sleep(60)
if rollback_manager.is_rollback:
if rollback_manager.health_check():
rollback_manager.switch_to_primary()
else:
if not rollback_manager.health_check():
rollback_manager.switch_to_fallback()
health_thread = threading.Thread(target=health_check_loop, daemon=True)
health_thread.start()
가격과 ROI
실제 마이그레이션 사례를 기반으로 ROI를 계산해 보겠습니다:
| 구분 | 마이그레이션 전 | 마이그레이션 후 | 절감 효과 |
|---|---|---|---|
| 월간 API 비용 | $1,250 | $420 | 66% 절감 |
| 일일 API 호출 | 45,000회 | 45,000회 | 동일 |
| 평균 응답 시간 | 2,100ms | 1,450ms | 31% 개선 |
| 연결 가용성 | 94.5% | 99.2% | 4.7% 향상 |
| 월간 ROI | - | $830 | 초기 마이그레이션 비용 회수: 1일 |
비용 절감 상세 분석
DeepSeek V3.2 모델로 전환할 경우:
- 기존: GPT-4.1 기반 → $8.00/MTok × 800M 토큰 = $6,400/월 (50BTC 트레이더)
- 변경: DeepSeek V3.2 전환 → $0.42/MTok × 800M 토큰 = $336/월
- 절감: 월 $6,064 (95% 감소)
자주 발생하는 오류 해결
1. API 키 인증 오류
# 오류 메시지: "401 Unauthorized" 또는 "Invalid API key"
해결 방법:
class HolySheepAuthError(Exception):
"""인증 오류 처리"""
pass
def validate_api_key(api_key: str) -> bool:
"""API 키 유효성 검증"""
# 1. 키 형식 확인 (sk-hs-로 시작)
if not api_key.startswith("sk-hs-"):
print("❌ 잘못된 API 키 형식입니다.")
print(" HolySheep 대시보드에서 새로운 키를 발급받으세요.")
return False
# 2. 연결 테스트
test_client = HolySheepGridClient(api_key)
try:
response = test_client.session.post(
"https://api.holysheep.ai/v1/models",
headers={"Authorization": f"Bearer {api_key}"},
timeout=10
)
if response.status_code == 401:
print("❌ API 키가 유효하지 않습니다.")
print(" 다음 주소에서 새 키를 발급: https://www.holysheep.ai/dashboard")
return False
return True
except requests.exceptions.ConnectionError:
print("❌ HolySheep AI에 연결할 수 없습니다.")
print(" 네트워크 연결을 확인하거나 나중에 다시 시도하세요.")
return False
올바른 키 발급 및 설정
API_KEY = "sk-hs-your-actual-key-here" # HolySheep 대시보드에서 복사
validate_api_key(API_KEY)
2. 응답 시간 초과 오류
# 오류 메시지: "Connection timeout" 또는 "Read timeout"
해결 방법:
class TimeoutHandler:
"""응답 시간 초과 처리"""
def __init__(self, client):
self.client = client
self.retry_count = 3
self.timeout = 30 # 초
def call_with_retry(self, prompt: str, model: ModelType) -> str:
"""재시도 로직이 포함된 API 호출"""
for attempt in range(self.retry_count):
try:
# 지수 백오프 대기
if attempt > 0:
wait_time = 2 ** attempt
print(f"⏳ {wait_time}초 후 재시도... ({attempt + 1}/{self.retry_count})")
time.sleep(wait_time)
# 타임아웃 설정
endpoint = f"{self.client.BASE_URL}/chat/completions"
payload = {
"model": self._get_model_name(model),
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 500
}
response = self.client.session.post(
endpoint,
json=payload,
timeout=self.timeout
)
if response.status_code == 200:
return response.json()["choices"][0]["message"]["content"]
elif response.status_code == 429:
# 속도 제한 - 모델 전환 고려
print("⚠️ 속도 제한 도달. Gemini Flash로 전환합니다.")
return self.call_with_retry(prompt, ModelType.GEMINI)
except requests.exceptions.Timeout:
print(f"⏰ 타임아웃 발생 (시도 {attempt + 1})")
continue
except requests.exceptions.ConnectionError as e:
print(f"🔌 연결 오류: {e}")
continue
# 모든 시도 실패 시 폴백
print("❌ 모든 재시도 실패. 폴백 모델 사용.")
return '{"action": "hold", "confidence": 0}'
타임아웃 최적화 팁
1. max_tokens을 불필요하게 높게 설정하지 마세요
2. 입력 프롬프트를 간결하게 유지하세요
3. 배치 처리로 호출 횟수를 줄이세요
3. 모델 가용성 오류
# 오류 메시지: "Model not available" 또는 "Invalid model parameter"
해결 방법:
class ModelFallback:
"""모델 가용성 처리 및 자동 전환"""
MODEL_PRIORITY = [
ModelType.DEEPSEEK, # 1순위: 가장 저렴
ModelType.GEMINI, # 2순위: 균형
ModelType.GPT4, # 3순위: 고성능
ModelType.CLAUDE # 4순위: 최종 폴백
]
def __init__(self, client):
self.client = client
self.available_models = self._check_available_models()
def _check_available_models(self) -> List[str]:
"""사용 가능한 모델 목록 조회"""
try:
response = self.client.session.get(
f"{self.client.BASE_URL}/models",
timeout=10
)
if response.status_code == 200:
models = response.json().get("data", [])
return [m["id"] for m in models]
else:
# 기본 모델 목록 반환
return ["deepseek-chat", "gemini-2.5-flash", "gpt-4.1"]
except Exception:
return ["deepseek-chat", "gemini-2.5-flash"]
def get_best_available_model(self, preferred: ModelType) -> ModelType:
"""선호 모델이 사용 불가능할 경우 최적 대체 모델 반환"""
preferred_name = self._get_model_name(preferred)
if preferred_name in self.available_models:
return preferred
# 우선순위에 따라 사용 가능한 모델 탐색
for model in self.MODEL_PRIORITY:
if self._get_model_name(model) in self.available_models:
print(f"🔄 모델 전환: {preferred.name} → {model.name}")
return model
# 최종 폴백: DeepSeek (거의 항상 사용 가능)
return ModelType.DEEPSEEK
def _get_model_name(self, model_type: ModelType) -> str:
"""모델 타입을 API 모델명으로 변환"""
mapping = {
ModelType.DEEPSEEK: "deepseek-chat",
ModelType.GEMINI: "gemini-2.5-flash",
ModelType.GPT4: "gpt-4.1",
ModelType.CLAUDE: "claude-sonnet-4-20250514"
}
return mapping.get(model_type, "deepseek-chat")
def analyze_with_fallback(self, symbol: str, data: dict) -> TradingSignal:
"""폴백 로직이 포함된 분석 실행"""
# 1순위 모델 시도
model = self.get_best_available_model(ModelType.DEEPSEEK)
signal = self.client.analyze_market(symbol, data, model)
# 신뢰도가 너무 낮으면 상위 모델 재시도
if signal.confidence < 0.5:
print(f"⚠️ 신뢰도 낮음 ({signal.confidence:.2%}), 고성능 모델 재시도")
premium_model = self.get_best_available_model(ModelType.GPT4)
if premium_model != model:
signal = self.client.analyze_market(symbol, data, premium_model)
return signal
모델 목록 확인 (대시보드에서도 확인 가능)
fallback_handler = ModelFallback(HolySheepGridClient("YOUR_HOLYSHEEP_API_KEY"))
print("사용 가능한 모델:", fallback_handler.available_models)
4. 결제 및 크레딧 관련 오류
# 오류 메시지: "Insufficient credits" 또는 "Payment failed"
해결 방법:
class CreditManager:
"""크레딧 및 결제 관리"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
def check_balance(self) -> dict:
"""잔액 확인"""
try:
response = requests.get(
f"{self.base_url}/usage",
headers={"Authorization": f"Bearer {self.api_key}"},
timeout=10
)
if response.status_code == 200:
data = response.json()
return {
"balance": data.get("balance", 0),
"currency": data.get("currency", "USD"),
"daily_limit": data.get("daily_limit"),
"monthly_used": data.get("monthly_used", 0)
}
else