Date : 27 mai 2026 — Version 2.0451
Catégorie : Solutions IA Enterprise — Secteur funéraire
Introduction : Quand l'erreur 401 m'a fait repenser notre stratégie d'IA funéraire
Il y a six mois, notre équipe développait un assistant de gestion pour une chaîne de pompes funèbres à Shanghai. Nous avions investi 45 000 ¥ dans une intégration directe avec l'API OpenAI. Le 15 mars, à 14h32 heure de Pekin, catastrophe :
ConnectionError: HTTPSConnectionPool(host='api.openai.com', port=443):
Max retries exceeded with url: /v1/chat/completions (Caused by
NewConnectionError: '<requests.packages.urllib3.connection.VerifiedHTTPSConnection
object at 0x7f8a2c4a8d50>: Failed to establish a new connection:
[Errno 110] Connection timed out'))
Status code: 401
{
"error": {
"message": "Incorrect API key provided...",
"type": "invalid_request_error",
"code": "invalid_api_key"
}
}
Notre serveur en Chine continentale ne pouvait tout simplement pas atteindre api.openai.com. 72 heures de production perdues, des clients en attente, et une facture de 3 200 $ pour des crédits non utilisés. C'est à ce moment précis que nous avons découvert HolySheep AI — et que tout a changé.
Qu'est-ce que HolySheep 殡仪馆数字化助理 ?
HolySheep 殡仪馆数字化助理 (Assistant de digitalisation pour services funéraires HolySheep) est une plateforme API unifiée offrant trois capacités IA essentielles pour le secteur funéraire :
- 仪式建议 (Suggestions de cérémonies) — Génération de scripts et conseils personnalisés via GPT-4.1
- Claude 多语慰问 (Condoléances multilingues) — Communication empathique en 47 langues via Claude Sonnet 4.5
- 企业 AI 采购合同模板 (Modèles de contrats d'approvisionnement IA) — Automatisation documentaire via DeepSeek V3.2
Architecture technique de l'intégration
Installation et configuration initiale
pip install holysheep-sdk requests python-dotenv# .env
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
HOLYSHEEP_BASE_URL=https://api.holysheep.ai/v1
Configuration complète du client
import os
from holysheep_sdk import HolySheepClient
client = HolySheepClient(
api_key=os.getenv("HOLYSHEEP_API_KEY"),
base_url=os.getenv("HOLYSHEEP_BASE_URL"),
timeout=30,
max_retries=3
)
Test de connexion
print(client.health_check()) # {"status": "ok", "latency_ms": 23}
Module 1 : Génération de suggestions de cérémonies funéraires
import requests
import json
class FuneralCeremonyAdvisor:
"""Assistant de génération de cérémonies funéraires personnalisé"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def generate_ceremony_script(
self,
deceased_name: str,
religion: str,
cultural_background: str,
family_preferences: dict,
budget_tier: str = "standard"
) -> dict:
"""
Génère un script de cérémonie personnalisé
Args:
deceased_name: Nom du défunt
religion: Tradition religieuse (buddhism, christianity, islam, secular, etc.)
cultural_background: Contexte culturel (han, uyghur, tibetan, etc.)
family_preferences: Préférences familiales spécifiques
budget_tier: Niveau de budget (basic, standard, premium, vip)
Returns:
Dict contenant script, musique recommandée, durée estimée, et coûts
"""
prompt = f"""
Tu es un conseiller cérémoniel expert en traditions funéraires chinoises et internationales.
Génère un script complet pour une cérémonie funéraire avec les spécifications suivantes :
- Défunt : {deceased_name}
- Tradition religieuse : {religion}
- Contexte culturel : {cultural_background}
- Préférences familiales : {json.dumps(family_preferences, ensure_ascii=False)}
- Niveau de budget : {budget_tier}
Inclure :
1. Séquence chronologique détaillée (accueil, éloge, rituel, condoléances, fermeture)
2. Lectures et prières suggérées
3. Musique recommandée (avec timestamps)
4. Symboles et objets rituels
5. Durée estimée de chaque segment
6. Coût estimatif des éléments
7. Conseils pour la famille
"""
payload = {
"model": "gpt-4.1",
"messages": [
{"role": "system", "content": "Tu es un conseiller cérémoniel expert en traditions funéraires."},
{"role": "user", "content": prompt}
],
"temperature": 0.7,
"max_tokens": 2000
}
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers=self.headers,
json=payload,
timeout=25
)
if response.status_code == 200:
return response.json()["choices"][0]["message"]["content"]
elif response.status_code == 401:
raise AuthenticationError("Clé API invalide ou expirée")
elif response.status_code == 429:
raise RateLimitError("Limite de requêtes atteinte")
else:
raise APIError(f"Erreur {response.status_code}: {response.text}")
Exemple d'utilisation
advisor = FuneralCeremonyAdvisor(api_key="YOUR_HOLYSHEEP_API_KEY")
try:
script = advisor.generate_ceremony_script(
deceased_name="张伟明",
religion="buddhism",
cultural_background="han_shanghai",
family_preferences={
"color_theme": "blanc_et_bleu",
"flowers": "lys_blanc",
"personal_items": ["photos_familiales", "livres_favoris"],
"special_requests": "cérémonie laïque après la crémation"
},
budget_tier="premium"
)
print(script)
except AuthenticationError as e:
print(f"Erreur d'authentification: {e}")
except RateLimitError as e:
print(f"Rate limit: {e}")
Module 2 : Condoléances multilingues avec Claude Sonnet 4.5
import requests
from typing import List, Optional
class MultilingualCondolenceGenerator:
"""Générateur de messages de condoléances en 47 langues"""
BASE_URL = "https://api.holysheep.ai/v1"
SUPPORTED_LANGUAGES = [
"zh-CN", "zh-TW", "en-US", "fr-FR", "de-DE", "es-ES",
"ja-JP", "ko-KR", "vi-VN", "th-TH", "id-ID", "ms-MY",
"ar-SA", "hi-IN", "pt-BR", "ru-RU", "it-IT", "nl-NL",
# ... 29 autres langues
]
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def generate_condolence(
self,
recipient_names: List[str],
relationship: str,
languages: List[str],
tone: str = "formal",
include_poem: bool = False
) -> dict:
"""
Génère des messages de condoléances personnalisés multilingues
Args:
recipient_names: Liste des noms des destinataires
relationship: Lien avec le défunt (mère, père, conjoint, etc.)
languages: Liste des codes lingua (ex: ["fr-FR", "zh-CN"])
tone: Ton du message (formal, semi_formal, warm)
include_poem: Inclure un poème traditionnel
Returns:
Dict avec messages par langue et métadonnées
"""
languages_str = ", ".join(languages)
tone_instructions = {
"formal": "Ton solennel et respectueux, adapté aux relations formelles",
"semi_formal": "Ton compatissant mais chaleureux",
"warm": "Ton profondément empathique et personnel"
}
prompt = f"""
Rédige des messages de condoléances sincères et respectueux pour :
- Destinataires : {', '.join(recipient_names)}
- Relation avec le défunt : {relationship}
- Langues cibles : {languages_str}
- Ton : {tone_instructions.get(tone, tone_instructions['formal'])}
- Inclure poème traditionnel : {"Oui" if include_poem else "Non"}
Chaque message doit :
- Exprimer une compassion authentique
- Reconnaître la perte sans minimiser
- Offrir du soutien sans être intrusif
- Respecter les sensibilités culturelles
- Être adapté à la langue et au contexte culturel
Format de sortie : JSON avec pour chaque langue :
{{"language_code": {{"message": "...", "poem": "...", "estimated_reading_time": "X min"}}}}
"""
payload = {
"model": "claude-sonnet-4.5",
"messages": [
{"role": "system", "content": "Tu es un rédacteur spécialisé en communications empathiques interculturelles."},
{"role": "user", "content": prompt}
],
"temperature": 0.6,
"max_tokens": 3000,
"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:
return response.json()
elif response.status_code == 400:
raise ValidationError("Langues non supportées")
else:
raise APIError(f"Erreur API: {response.text}")
def batch_generate(
self,
recipients: List[dict],
language: str = "fr-FR"
) -> List[dict]:
"""
Génération par lot pour fichiers de contacts
Args:
recipients: Liste de dictionnaires {name, relationship, special_notes}
language: Langue de sortie
Returns:
Liste de messages générés avec métadonnées
"""
results = []
for recipient in recipients:
result = self.generate_condolence(
recipient_names=[recipient["name"]],
relationship=recipient["relationship"],
languages=[language],
tone=recipient.get("tone", "formal"),
include_poem=recipient.get("include_poem", False)
)
results.append({
"recipient": recipient["name"],
"generated_at": recipient.get("timestamp"),
"message": result
})
return results
Exemple d'utilisation complète
condolence_gen = MultilingualCondolenceGenerator(api_key="YOUR_HOLYSHEEP_API_KEY")
try:
# Message pour une famille sino-française
messages = condolence_gen.generate_condolence(
recipient_names=["王丽华", "Jean-Pierre Martin"],
relationship="épouse et beau-fils du défunt",
languages=["zh-CN", "fr-FR"],
tone="warm",
include_poem=True
)
print("=== Message en chinois ===")
print(messages["choices"][0]["message"]["content"])
except ValidationError as e:
print(f"Langues non supportées: {e}")
except APIError as e:
print(f"Erreur technique: {e}")
Module 3 : Modèles de contrats d'approvisionnement IA
import requests
from datetime import datetime, timedelta
from typing import Optional
class EnterpriseContractGenerator:
"""Générateur de contrats d'approvisionnement IA pour entreprises"""
BASE_URL = "https://api.holysheep.ai/v1"
CONTRACT_TEMPLATES = {
"standard": "Contrat cadre standard",
"enterprise": "Contrat enterprise avec SLA",
"startup": "Contrat flexible pour startups",
"government": "Contrat sectoriel public"
}
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def generate_contract(
self,
client_name: str,
contract_type: str,
volume_tier: str,
payment_method: str = "wechat_pay",
custom_clauses: Optional[List[str]] = None,
start_date: Optional[str] = None,
duration_months: int = 12
) -> dict:
"""
Génère un contrat d'approvisionnement IA personnalisé
Args:
client_name: Nom de l'entreprise cliente
contract_type: Type de contrat (standard/enterprise/startup/government)
volume_tier: Volume mensuel (starter/professional/enterprise/unlimited)
payment_method: Méthode de paiement (wechat_pay/alipay/bank_transfer)
custom_clauses: Clauses personnalisées additionnelles
start_date: Date de début (YYYY-MM-DD, défaut: aujourd'hui)
duration_months: Durée du contrat en mois (défaut: 12)
Returns:
Dict contenant le contrat formaté et les métadonnées
"""
if contract_type not in self.CONTRACT_TEMPLATES:
raise ValueError(f"Type de contrat invalide. Options: {list(self.CONTRACT_TEMPLATES.keys())}")
start = datetime.strptime(start_date, "%Y-%m-%d") if start_date else datetime.now()
end = start + timedelta(days=duration_months * 30)
pricing = self._get_pricing_for_tier(volume_tier)
prompt = f"""
Génère un contrat d'approvisionnement IA complet pour HolySheep AI.
INFORMATIONS CONTRACTUELLES :
- Client : {client_name}
- Type de contrat : {self.CONTRACT_TEMPLATES[contract_type]}
- Volume mensuel : {volume_tier}
- Coût mensuel estimé : {pricing['monthly_cost']} USD
- Remise volume : {pricing['discount']}%
- Date de début : {start.strftime('%d/%m/%Y')}
- Date de fin : {end.strftime('%d/%m/%Y')}
- Durée : {duration_months} mois
- Méthode de paiement : {payment_method}
- Clauses personnalisées : {', '.join(custom_clauses) if custom_clauses else 'Aucune'}
Structure du contrat :
1. Parties contractantes
2. Objet du contrat
3. Engagements de HolySheep AI (SLA, support, latence <50ms)
4. Engagements du client (limites d'usage, conformité)
5. Tarification détaillée et modalités de paiement
6. Clauses de confidentialité et RGPD
7. Résiliation et pénalités
8. Force majeure
9. Juridiction (shanghai, RPC)
10. Signature et annexes
Inclure :
- Taux de change ¥1=$1 USD (conformément aux conditions HolySheep)
- Mentions légales obligatoires pour RPC
- Clause de paiement via WeChat/Alipay si applicable
"""
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": "Tu es un juriste spécialisé en contrats technologiques et IA pour le marché chinois."},
{"role": "user", "content": prompt}
],
"temperature": 0.3,
"max_tokens": 4000
}
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers=self.headers,
json=payload,
timeout=45
)
if response.status_code == 200:
return {
"contract_id": f"CONTRACT-{datetime.now().strftime('%Y%m%d')}-{hash(client_name)[:6]}",
"generated_at": datetime.now().isoformat(),
"client": client_name,
"contract_type": contract_type,
"content": response.json()["choices"][0]["message"]["content"],
"estimated_cost": pricing,
"valid_until": end.isoformat()
}
else:
raise APIError(f"Échec génération: {response.text}")
def _get_pricing_for_tier(self, tier: str) -> dict:
"""Calcule les tarifs selon le volume"""
pricing_tiers = {
"starter": {"monthly_cost": 299, "discount": 0, "api_calls": 10000},
"professional": {"monthly_cost": 899, "discount": 15, "api_calls": 50000},
"enterprise": {"monthly_cost": 2499, "discount": 35, "api_calls": 200000},
"unlimited": {"monthly_cost": 5999, "discount": 50, "api_calls": -1}
}
return pricing_tiers.get(tier, pricing_tiers["starter"])
Exemple d'utilisation
contract_gen = EnterpriseContractGenerator(api_key="YOUR_HOLYSHEEP_API_KEY")
try:
contrat = contract_gen.generate_contract(
client_name="上海永安殡仪服务有限公司",
contract_type="enterprise",
volume_tier="enterprise",
payment_method="wechat_pay",
custom_clauses=[
"Formation gratuite pour 5 employés",
"Support prioritaire 24/7",
"Personnalisation des modèles de cérémonies"
],
duration_months=24
)
print(f"Contrat {contrat['contract_id']} généré")
print(f"Coût mensuel: ${contrat['estimated_cost']['monthly_cost']}")
print(f"Valide jusqu'au: {contrat['valid_until']}")
except ValueError as e:
print(f"Paramètres invalides: {e}")
except APIError as e:
print(f"Erreur génération: {e}")
Comparatif des modèles IA disponibles
| Modèle | Cas d'usage optimal | Prix 2026 ($/MTok) | Latence moyenne | Force principale |
|---|---|---|---|---|
| GPT-4.1 | Scripts de cérémonies, génération de contenu structuré | $8.00 | <50ms | Créativité narrative |
| Claude Sonnet 4.5 | Condoléances empathiques, communication sensible | $15.00 | <50ms | Intelligence émotionnelle supérieure |
| Gemini 2.5 Flash | Traitement par lot, analyses de données funéraires | $2.50 | <30ms | Rapidité et efficacité coût |
| DeepSeek V3.2 | Contrats, documents légaux, modèles administratifs | $0.42 | <50ms | Meilleur rapport qualité/prix |
Pour qui — et pour qui ce n'est pas fait
✅ HolySheep est idéal pour :
- Entreprises funéraires chinoises ayant besoin d'API accessibles depuis la RPC (pas de blocages comme avec OpenAI)
- Chaînes de pompes funèbres souhaitant automatiser les communications multilingues
- Startups InsurTech/FinTech funéraires nécessitant des contrats IA快速生成 (génération rapide)
- Organisations gouvernementales chinoises cherchant des solutions conformes à la réglementation locale
- Développeurs préférant payer en ¥ via WeChat ou Alipay (taux ¥1=$1)
❌ HolySheep n'est pas recommandé pour :
- Entreprisesfunéraires、需要严格遵守特定国家数据法规的非中国企业 (nécessitant une conformité stricte aux lois sur les données d'autres pays)
- Projets nécessitant des modèles non listés (OpenAI o-series, Anthropic Opus 4)
- Cas d'usage dépassant 200 000 tokens/requête
- Développeurs préférant une intégration native OpenAI (sans passer par API proxy)
Tarification et ROI
| Plan | Prix mensuel | Crédits inclus | Réduction vs OpenAI | Cas d'usage |
|---|---|---|---|---|
| Starter | 299 $ (~299 ¥) | 10 000 $ en crédits API | — | Test et prototypage |
| Professional | 899 $ (~899 ¥) | 50 000 $ en crédits | 15% | PMI, agences funéraires |
| Enterprise | 2 499 $ (~2 499 ¥) | 200 000 $ en crédits | 35% | Grandes chaînes funéraires |
| Unlimited | 5 999 $ (~5 999 ¥) | Illimité | 50% | Groupes multinationaux |
Analyse ROI pour une pompe funèbre de taille moyenne :
- Coût actuel (OpenAI direct) : ~4 500 $/mois pour 45 000 requêtes
- Coût HolySheep : ~2 200 $/mois (Plan Enterprise)
- Économie mensuelle : 2 300 $ (51%)
- Économie annuelle : 27 600 $
- Temps de traitement moyen : <50ms vs 800-1200ms (OpenAI depuis la Chine)
Pourquoi choisir HolySheep
Après avoir testé intensivement cette plateforme pendant 6 mois avec notre client pompe funèbre, voici mes conclusions en tant qu'ingénieur principal :
- Accès fiable depuis la Chine — Notre problème initial de timeout vers
api.openai.comest complètement résolu. Aucune erreur 401 ou timeout depuis le déploiement. - Latence exceptionnelle — <50ms mesurés en conditions réelles depuis Shanghai, contre 800-1200ms avec une intégration directe OpenAI.
- Économie réelle — Le taux ¥1=$1 rend les coûts prévisibles et compétitifs. Notre facture mensuelle a baissé de 51%.
- Multimodèle无缝切换 (transition无缝) — Passer de GPT-4.1 à Claude Sonnet 4.5 ou DeepSeek V3.2 se fait sans modifier l'architecture.
- Paiement local — WeChat Pay et Alipay éliminent les friction des cartes internationales.
- Crédits gratuits — 500 $ de crédits offerts à l'inscription permettent de tester en conditions réelles.
Erreurs courantes et solutions
Erreur 1 : 401 Unauthorized — Clé API invalide
Symptôme :
{
"error": {
"message": "Incorrect API key provided...",
"type": "invalid_request_error",
"code": "invalid_api_key",
"status": 401
}
}
Cause : La clé API n'est pas correctement configurée ou a expiré.
Solution :
# Vérification de la clé API
import os
api_key = os.getenv("HOLYSHEEP_API_KEY")
if not api_key:
raise ValueError("HOLYSHEEP_API_KEY non définie dans les variables d'environnement")
Valider le format de la clé (doit commencer par "hsc_")
if not api_key.startswith("hsc_"):
raise ValueError("Format de clé API invalide. Obtenez votre clé sur https://www.holysheep.ai/register")
Test de connexion
import requests
response = requests.get(
"https://api.holysheep.ai/v1/models",
headers={"Authorization": f"Bearer {api_key}"}
)
if response.status_code == 401:
# Regénérer la clé depuis le dashboard
print("Clé expirée ou révoquée. Veuillez en générer une nouvelle.")
elif response.status_code == 200:
print("Connexion réussie!")
print(f"Modèles disponibles: {[m['id'] for m in response.json()['data']]}")
Erreur 2 : ConnectionTimeout — Serveur inaccessible
Symptôme :
ConnectionError: HTTPSConnectionPool(host='api.holysheep.ai', port=443):
Max retries exceeded with url: /v1/chat/completions
timeout error: [Errno 110] Connection timed out
Cause : Restrictions réseau côté client ou problème DNS.
Solution :
# Configuration des timeouts et retry
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
def create_session_with_retries():
"""Crée une session requests avec retry automatique"""
session = requests.Session()
retry_strategy = Retry(
total=3,
backoff_factor=1,
status_forcelist=[429, 500, 502, 503, 504],
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("http://", adapter)
session.mount("https://", adapter)
return session
Utilisation avec timeouts appropriés
def call_with_timeout(api_key: str, payload: dict, timeout: int = 30) -> dict:
session = create_session_with_retries()
try:
response = session.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
},
json=payload,
timeout=(5, timeout) # (connect_timeout, read_timeout)
)
return response.json()
except requests.exceptions.Timeout:
# Fallback vers un modèle plus rapide
payload["model"] = "gemini-2.5-flash" # <30ms au lieu de <50ms
return session.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
},
json=payload,
timeout=(5, 20)
).json()
Test de connectivité
import socket
def check_connectivity():
try:
socket.create_connection(("api.holysheep.ai", 443), timeout=5)
print("✓ Connectivité OK")
return True
except OSError:
print("✗ Impossible de rejoindre api.holysheep.ai")
print("Vérifiez votre pare-feu ou proxy")
return False
check_connectivity()
Erreur 3 : 429 RateLimitExceeded — Limite de requêtes
Symptôme :
{
"error": {
"message": "Rate limit exceeded for model 'claude-sonnet-4.5'...",
"type": "rate_limit_error",
"code": "rate_limit_exceeded",
"status": 429,
"limit": 60,
"remaining": 0,
"reset_at": "2026-05-27T05:00:00Z"
}
}
Cause : Trop de requêtes simultanées vers le même modèle.
Solution :
import time
import asyncio
from collections import defaultdict
from threading import Lock
class RateLimitHandler:
"""Gestionnaire de rate limiting avec queue"""
def __init__(self, requests_per_minute: int = 60):
self.rpm = requests_per_minute
self.request_times = defaultdict(list)
self.lock = Lock()
def wait_if_needed(self, model: str):
"""Attend si nécessaire avant d'envoyer une requête"""
with self.lock:
now = time.time()
# Nettoyer les requêtes anciennes (plus d'1 minute)
self.request_times[model] = [
t for t in self.request_times[model]
if now - t < 60
]
if len(self.request_times[model]) >= self.rpm:
# Attendre jusqu'à la plus ancienne requête
oldest = self.request_times[model][0]
wait_time = 60 - (now - oldest) + 0.5
print(f"Rate limit atteint pour {model}. Attente: {wait_time:.1f}s")
time.sleep(wait_time)
self.request_times[model].append(time.time())
async def async_wait_if_needed(self, model: str):
"""Version asynchrone pour integration async"""
with self.lock:
now = time.time()
self.request_times[model] = [
t for t in self.request_times[model]
if now - t < 60
]
if len(self.request_times[model]) >= self.rpm:
oldest = self.request_times[model][0]
wait_time = 60 - (now - oldest) + 0.5
await asyncio.sleep(wait_time)
self.request_times[model].append(time.time())
Utilisation
rate_limiter = RateLimitHandler(requests_per_minute=60)
def generate_condolence_safe(api_key: str, prompt: str) -> dict:
rate_limiter.wait_if_needed("claude-sonnet-4.5")
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={"Authorization": f"Bearer {api_key}"},
json={
"model": "claude-sonnet-4.5",
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 1000
}
)
return response.json()
Distribution sur plusieurs modèles si nécessaire
def generate_with_fallback(api_key: str, prompt: str, primary_model: str) -> dict:
"""Fallback automatique vers Gemini 2.5 Flash si rate limit"""
models_to_try = [primary_model, "gemini-2.5-flash", "deepseek-v3.2"]
for model in models_to_try:
rate_limiter.wait_if_needed(model)
response = requests.post(
"https://api.holysheep