中文|EN
API v1.0 — Production

Build on Equine Biological Intelligence

Programmatic access to the most comprehensive equine biology knowledge graph. Query breeds, variants, phenotypes, and foundation intelligence — all grounded in traceable evidence.

14
API Endpoints
17
Breeds
500K+
Variants
100%
Traceable

5-Minute Quick Start

Go from zero to your first API call in under five minutes. No credit card required.

1

Create a Developer Account

Register at eqaios.com/developers and verify your email address.

2

Create a Project

From the Developer Console, create a new project. Each project gets its own API key and usage quota.

3

Generate Your API Key

Navigate to Settings → API Keys and generate a key. Store it securely — it will only be shown once.

4

Make Your First Call

Query the breeds endpoint to verify your setup works.

curl -X GET "https://api.eqaios.com/api/v1/breeds" \
  -H "Authorization: Bearer eqai_sk_your_api_key_here"
import requests

response = requests.get(
    "https://api.eqaios.com/api/v1/breeds",
    headers={"Authorization": "Bearer eqai_sk_your_api_key_here"}
)
print(response.json())
const response = await fetch('https://api.eqaios.com/api/v1/breeds', {
  headers: { 'Authorization': 'Bearer eqai_sk_your_api_key_here' }
});
const data = await response.json();
console.log(data);

Bearer Token Authentication

All API requests require an API key passed via the Authorization header using the Bearer scheme.

🔑 Authentication Header

Include your API key in every request:

Authorization: Bearer <YOUR_API_KEY>

🔄 OAuth 2.0 (Service-to-Service)

For automated integrations, use the client credentials flow to obtain short-lived access tokens:

{
  "grant_type": "client_credentials",
  "client_id": "eqai_client_abc123",
  "client_secret": "sk_live_...",
  "scope": "read:breeds read:variants read:knowledge"
}
{
  "access_token": "eyJhbGciOiJSUzI1NiIs...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "scope": "read:breeds read:variants read:knowledge"
}

Available Scopes

read:breedsBreed data & variants
read:variantsVariant & evidence
read:knowledgeKnowledge Graph
read:foundationFI & HorseVector
write:decisionDecision products

Fair Usage & Rate Limits

Every API tier includes generous limits. Rate limit headers are returned with every response.

Tier Requests / min Burst Monthly Quota
Free 60 10 10,000
Research 300 50 100,000
Commercial 1,000 200 1,000,000
Enterprise Custom Custom Unlimited
Rate Limit Headers: X-RateLimit-Limit · X-RateLimit-Remaining · X-RateLimit-Reset

14 Core Endpoints

RESTful API organized into four layers: Data Access, Knowledge Graph, Foundation Intelligence, and Decision Products.

Data Access Layer

GET
GET /api/v1/breeds List all genotyped breeds
GET /api/v1/breeds/{breed_id} Breed detail + phenotypes
GET /api/v1/breeds/{breed_id}/variants Breed-specific variant frequencies
GET /api/v1/variants/{rsID} Variant detail + full evidence
GET /api/v1/variants/{rsID}/evidence Full evidence chain for variant
GET /api/v1/variants/{rsID}/validation Validation status & history

Knowledge Graph Layer

GET
GET /api/v1/knowledge/search Semantic search across all entities
GET /api/v1/knowledge/graph/{gene_id} Full subgraph for a gene
GET /api/v1/knowledge/phenotypes/{id} Phenotype & associated entities

Foundation Intelligence Layer

GET / POST
GET /api/v1/foundation/{entity_id} Foundation Intelligence for entity
POST /api/v1/foundation/embed Generate HorseVector embedding

Decision Products & Search

POST / GET
POST /api/v1/jumphealth/screen Genetic disease risk screening
POST /api/v1/jumpid/identify Genetic identification
POST /api/v1/jumpchain/verify Pedigree verification
GET /api/v1/search Unified search across all data

Core API Details

The four most-used endpoints for building on equine biological intelligence.

GET /api/v1/breeds

Breed Query

List all genotyped breeds with genotype counts, variant counts, and production status. Filter by status=production or integrating.

status page per_page
GET /api/v1/variants/{rsID}

Variant Query

Full variant details including coordinate, allele, breed-specific frequencies, phenotypes, and complete evidence chain with traceability.

rsID traceability_chain breed_frequencies
GET /api/v1/knowledge/graph/{gene_id}

Knowledge Graph

Retrieve the full knowledge subgraph for a gene — connected variants, phenotypes, and breeds with edge types and validation status.

depth edge_types knowledge_node knowledge_edge
POST /api/v1/foundation/embed

HorseVector Embed

Generate a 1024-dimensional HorseVector embedding for any equine biological entity — genes, variants, breeds, or custom genotype data.

entity_type entity_id 1024-dim model_version

Standard Response Format

Every API response follows a strict envelope format ensuring consistency, traceability, and scientific accountability.

data required
object
Core response payload. Structure varies by endpoint.
traceability required
object
Evidence chain from output to source — Radical Traceability.
confidence required
object { value, methodology }
Statistical confidence (0.0–1.0) with methodology note.
version required
object { data_version, data_timestamp }
Data provenance — Truth is versioned.
validation_status required
string
Top-level evidence quality label.
pagination
object
Page, per_page, total, total_pages (list endpoints only).
Example Response
{
  "data": {
    "breed_id": "TB",
    "name": "Thoroughbred",
    "status": "production",
    "genotype_count": 12450,
    "variant_count": 487230
  },
  "traceability": {
    "source_papers": ["PMID:34567890"],
    "coordinate_system": "EquCab3.0",
    "validation_status": "validated"
  },
  "confidence": {
    "value": 0.97,
    "methodology": "cross-breed validation with 8 independent populations"
  },
  "version": {
    "data_version": "2026.07.01",
    "data_timestamp": "2026-07-01T00:00:00Z"
  },
  "validation_status": "validated"
}

Validation Status Labels

Every response includes a validation status indicating the evidence quality. This is not a confidence score — it reflects independent verification.

✅ validated ⚠️ partially_validated 🔴 unvalidated 📋 under_review
Validated

Confirmed by ≥2 independent sources. Cross-referenced in dbSNP + OMIA + literature.

Partially Validated

Some evidence exists, needs more confirmation. Awaiting independent replication.

Unvalidated

Preliminary, hypothesis only. No independent validation yet performed.

Under Review

Being evaluated by domain experts. Submitted for expert review.

Code Examples

Real-world examples for the most common integration patterns. Switch between cURL, Python, and JavaScript.

Query Breed Data

# Get detailed info for the Thoroughbred breed
curl -X GET "https://api.eqaios.com/api/v1/breeds/TB" \
  -H "Authorization: Bearer eqai_sk_your_api_key"
import requests

API_KEY = "eqai_sk_your_api_key"
BASE = "https://api.eqaios.com/api/v1"

# Get detailed info for the Thoroughbred breed
resp = requests.get(
    f"{BASE}/breeds/TB",
    headers={"Authorization": f"Bearer {API_KEY}"}
)
breed = resp.json()

print(f"Breed: {breed['data']['name']}")
print(f"Genotypes: {breed['data']['genotype_count']:,}")
print(f"Validation: {breed['validation_status']}")
print(f"Confidence: {breed['confidence']['value']}")
const API_KEY = 'eqai_sk_your_api_key';
const BASE = 'https://api.eqaios.com/api/v1';

// Get detailed info for the Thoroughbred breed
const resp = await fetch(`${BASE}/breeds/TB`, {
  headers: { 'Authorization': `Bearer ${API_KEY}` }
});
const breed = await resp.json();

console.log(`Breed: ${breed.data.name}`);
console.log(`Genotypes: ${breed.data.genotype_count.toLocaleString()}`);
console.log(`Validation: ${breed.validation_status}`);

Knowledge Graph Query

# Get the knowledge subgraph for the MSTN gene
curl -X GET "https://api.eqaios.com/api/v1/knowledge/graph/MSTN?depth=2" \
  -H "Authorization: Bearer eqai_sk_your_api_key"
import requests

API_KEY = "eqai_sk_your_api_key"
BASE = "https://api.eqaios.com/api/v1"

# Get the knowledge subgraph for MSTN gene
resp = requests.get(
    f"{BASE}/knowledge/graph/MSTN",
    params={"depth": 2},
    headers={"Authorization": f"Bearer {API_KEY}"}
)
graph = resp.json()

focal = graph["data"]["focal_node"]["knowledge_node"]
print(f"Gene: {focal['name']} ({focal['id']})")

for node in graph["data"]["nodes"]:
    n = node["knowledge_node"]
    print(f"  → {n['node_type']}: {n.get('name', n['id'])}")

for edge in graph["data"]["edges"]:
    e = edge["knowledge_edge"]
    print(f"  {e['source']} —[{e['relation']}]→ {e['target']}")
const API_KEY = 'eqai_sk_your_api_key';
const BASE = 'https://api.eqaios.com/api/v1';

// Get the knowledge subgraph for MSTN gene
const resp = await fetch(
  `${BASE}/knowledge/graph/MSTN?depth=2`,
  { headers: { 'Authorization': `Bearer ${API_KEY}` } }
);
const graph = await resp.json();

const focal = graph.data.focal_node.knowledge_node;
console.log(`Gene: ${focal.name} (${focal.id})`);

graph.data.nodes.forEach(node => {
  const n = node.knowledge_node;
  console.log(`  → ${n.node_type}: ${n.name || n.id}`);
});

graph.data.edges.forEach(edge => {
  const e = edge.knowledge_edge;
  console.log(`  ${e.source} —[${e.relation}]→ ${e.target}`);
});

Generate HorseVector Embedding

# Generate a HorseVector for a variant
curl -X POST "https://api.eqaios.com/api/v1/foundation/embed" \
  -H "Authorization: Bearer eqai_sk_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "entity_type": "variant",
    "entity_id": "rs112719330"
  }'
import requests

API_KEY = "eqai_sk_your_api_key"
BASE = "https://api.eqaios.com/api/v1"

# Generate HorseVector for the MSTN speed variant
resp = requests.post(
    f"{BASE}/foundation/embed",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "entity_type": "variant",
        "entity_id": "rs112719330"
    }
)
hv = resp.json()

print(f"Dimensions: {hv['data']['horsevector']['dimensions']}")
print(f"Model: {hv['data']['horsevector']['model_version']}")
print(f"Vector (first 5): {hv['data']['horsevector']['embedding'][:5]}")
const API_KEY = 'eqai_sk_your_api_key';
const BASE = 'https://api.eqaios.com/api/v1';

// Generate HorseVector for the MSTN speed variant
const resp = await fetch(`${BASE}/foundation/embed`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    entity_type: 'variant',
    entity_id: 'rs112719330'
  })
});
const hv = await resp.json();

console.log(`Dimensions: ${hv.data.horsevector.dimensions}`);
console.log(`Model: ${hv.data.horsevector.model_version}`);
console.log(`Vector (first 5):`, hv.data.horsevector.embedding.slice(0, 5));

SDK & Libraries

Official SDKs with full type safety, automatic pagination, and terminology compliance built in.

🐍

eqai-python

Python 3.9+ · Pydantic types

Full-featured SDK with async support, streaming responses, and automatic response envelope parsing.

Planned
pip install eqai
📊

eqai-r

R 4.0+ · S4 classes

Native R integration with built-in Knowledge Graph visualization and statistical analysis tools.

Planned
install.packages("eqai")

@eqai/sdk

TypeScript · Node 18+

TypeScript-first SDK with full type definitions, streaming support, and tree-shakeable modules.

Planned
npm install @eqai/sdk

EQAI CLI

Command-line tool for quick queries, data exploration, and pipeline integration.

Terminal
# Install the CLI
pip install eqai-cli

# Configure your API key
eqai auth login

# Query breed information
eqai breeds list --status production

# Get variant details
eqai variants get rs112719330 --format json

# Search the knowledge graph
eqai knowledge search "MSTN speed" --depth 2

# Generate a HorseVector
eqai embed --entity-type variant --entity-id rs112719330

# Run genetic disease screening
eqai jumphealth screen --breed TB --genotype genotype.vcf

Developer Support

Get help, share feedback, and connect with the equine biology developer community.

Ready to build?

Start integrating equine biological intelligence into your applications today. Free tier available — no credit card required.

Get Your API Key → Browse API Docs

Biology existed before computation. EQAI exists to make biology computable.