API Documentation

Getting Started

The dr.eamer.dev API provides unified access to 15 LLM providers, 17 data sources, multi-agent orchestration workflows, and utility functions through a single REST API.

Base URL

https://api.dr.eamer.dev/v1
Rate Limit: 10,000 requests/day Resets at midnight UTC. Monitor via X-RateLimit headers.

Authentication

All API endpoints require authentication using one of three methods:

Method 1: X-API-Key Header (Recommended)

X-API-Key: your_api_key_here

Method 2: Authorization Bearer Token

Authorization: Bearer your_api_key_here

Method 3: Query Parameter

?api_key=your_api_key_here

Response headers include rate limit information:

X-RateLimit-Limit: 10000
X-RateLimit-Remaining: 9847
X-RateLimit-Reset: 1640995200

AAC (Accessibility)

Search and retrieve Augmentative and Alternative Communication (AAC) symbols from multiple libraries including Blissymbolics, SymbolStix, and ARASAAC. Essential for building accessible communication tools.

13,671+ Symbols Available Blissymbolics, SymbolStix, and ARASAAC libraries with proper attribution.
GET /v1/aac/symbols/search

Search AAC symbols across multiple sources with fuzzy matching. Returns ranked results from Blissymbolics, SymbolStix, and optionally ARASAAC.

Query Parameters
q string (required)
Search term (e.g., "happy", "food", "help")
limit integer
Maximum results to return (default: 10, max: 20)
sources string
Comma-separated sources: local (Blissymbolics/SymbolStix), arasaac. Default: local
language string
Language code for ARASAAC (default: en)
curl "https://api.dr.eamer.dev/v1/aac/symbols/search?q=happy&limit=5" \
  -H "X-API-Key: your_api_key"
import requests

response = requests.get(
    "https://api.dr.eamer.dev/v1/aac/symbols/search",
    headers={"X-API-Key": "your_api_key"},
    params={
        "q": "happy",
        "limit": 10,
        "sources": "local,arasaac"
    }
)

symbols = response.json()
for symbol in symbols["results"]:
    print(f"{symbol['keyword']}: {symbol['icon_url']}")
const params = new URLSearchParams({
  q: 'happy',
  limit: 10,
  sources: 'local,arasaac'
});

const response = await fetch(
  `https://api.dr.eamer.dev/v1/aac/symbols/search?${params}`,
  { headers: { 'X-API-Key': 'your_api_key' } }
);

const { results } = await response.json();
results.forEach(s => console.log(`${s.keyword}: ${s.icon_url}`));
Response
{
  "query": "happy",
  "results": [
    {
      "keyword": "happy",
      "icon_url": "/symbols/happy.svg",
      "source": "Bliss/SymbolStix",
      "license": "See repository documentation",
      "score": 1.0
    },
    {
      "keyword": "happiness",
      "icon_url": "/symbols/happiness.svg",
      "source": "Bliss/SymbolStix",
      "license": "See repository documentation",
      "score": 0.9
    }
  ],
  "total": 2,
  "sources": ["local"],
  "metadata": { "limit": 10, "language": "en" }
}
GET /v1/aac/symbols/arasaac

Search ARASAAC pictograms specifically. ARASAAC provides free pictographic communication resources under CC BY-NC-SA license from the Government of Aragón (Spain).

Query Parameters
q string (required)
Search term
limit integer
Maximum results (default: 10, max: 20)
language string
Language code (default: en). Supports: en, es, fr, de, it, pt, and more.
curl "https://api.dr.eamer.dev/v1/aac/symbols/arasaac?q=food&language=en" \
  -H "X-API-Key: your_api_key"
import requests

response = requests.get(
    "https://api.dr.eamer.dev/v1/aac/symbols/arasaac",
    headers={"X-API-Key": "your_api_key"},
    params={"q": "food", "language": "es"}  # Spanish
)

for symbol in response.json()["results"]:
    print(f"ARASAAC #{symbol['icon_url'].split('/')[-1]}: {symbol['keyword']}")
Response
{
  "query": "food",
  "results": [
    {
      "keyword": "food",
      "icon_url": "https://api.arasaac.org/v1/pictograms/2456",
      "source": "ARASAAC",
      "author": "Sergio Palao",
      "license": "CC BY-NC-SA",
      "attribution": "Pictograms author: Sergio Palao. Origin: ARASAAC...",
      "score": 1.0
    }
  ],
  "total": 10,
  "source": "arasaac",
  "metadata": {
    "attribution": "Pictograms by Sergio Palao under CC BY-NC-SA from ARASAAC",
    "language": "en",
    "limit": 10
  }
}
POST /v1/aac/sentence

Convert a sentence into AAC symbols. Each word is matched to available symbols, creating a "symbol strip" for AAC communication boards.

Request Body
sentence string (required)
The sentence to convert to symbols
sources string
Symbol sources: local (default), arasaac, or local,arasaac
language string
Language code (default: en)
curl -X POST "https://api.dr.eamer.dev/v1/aac/sentence" \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"sentence": "I want water please"}'
import requests

response = requests.post(
    "https://api.dr.eamer.dev/v1/aac/sentence",
    headers={"X-API-Key": "your_api_key"},
    json={
        "sentence": "I want water please",
        "sources": "local"
    }
)

result = response.json()
print(f"Coverage: {result['statistics']['coverage']}%")

for word_data in result["words"]:
    word = word_data["word"]
    if word_data["matched"]:
        symbol = word_data["symbols"][0]
        print(f"  {word} → {symbol['icon_url']}")
    else:
        print(f"  {word} → (no symbol)")
const response = await fetch('https://api.dr.eamer.dev/v1/aac/sentence', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    sentence: 'I want water please'
  })
});

const { words, statistics } = await response.json();
console.log(`Coverage: ${statistics.coverage}%`);
words.forEach(w => {
  const symbol = w.matched ? w.symbols[0].icon_url : 'none';
  console.log(`${w.word}: ${symbol}`);
});
Response
{
  "sentence": "I want water please",
  "words": [
    {
      "word": "i",
      "matched": true,
      "symbols": [
        {"keyword": "i", "icon_url": "/symbols/i.svg", "score": 1.0, "source": "Bliss/SymbolStix"}
      ]
    },
    {
      "word": "want",
      "matched": true,
      "symbols": [
        {"keyword": "want", "icon_url": "/symbols/want.svg", "score": 1.0, "source": "Bliss/SymbolStix"}
      ]
    },
    {
      "word": "water",
      "matched": true,
      "symbols": [
        {"keyword": "water", "icon_url": "/symbols/water.svg", "score": 1.0, "source": "Bliss/SymbolStix"}
      ]
    },
    {
      "word": "please",
      "matched": true,
      "symbols": [
        {"keyword": "please", "icon_url": "/symbols/please.svg", "score": 1.0, "source": "Bliss/SymbolStix"}
      ]
    }
  ],
  "statistics": {
    "total_words": 4,
    "matched": 4,
    "unmatched": 0,
    "coverage": 100.0
  },
  "sources": ["local"],
  "language": "en"
}

Corpus

Search and analyze the Corpus of Contemporary American English (COCA) - a 35M+ token linguistic database spanning 1990-2019, plus historical English corpora.

Available Corpora

COCA (Contemporary) COHA (Historical) Old English Middle English Early Modern English
GET /v1/corpus/search

Search the corpus with KWIC (Key Word In Context) results. Supports wildcards and part-of-speech filtering.

Query Parameters

ParameterTypeDescription
querystringSearch term (supports * wildcards)
corpusstringCorpus to search: coca, coha, old_english, middle_english, early_modern
posstringPart of speech filter: noun, verb, adj, adv, etc.
limitintegerMaximum results (default: 50)
offsetintegerPagination offset
curl "https://api.dr.eamer.dev/v1/corpus/search?query=awesome&limit=20" \
  -H "X-API-Key: your_api_key"
GET /v1/corpus/collocations

Find words that frequently appear together with the target word (collocations and word associations).

Query Parameters

ParameterTypeDescription
wordstringTarget word to find collocations for
limitintegerMaximum collocations to return (default: 10)
curl "https://api.dr.eamer.dev/v1/corpus/collocations?word=make&limit=10" \
  -H "X-API-Key: your_api_key"
GET /v1/corpus/word-stories

Get the historical journey of a word - etymology, usage changes over time, and semantic evolution.

Query Parameters

ParameterTypeDescription
wordstringWord to explore
curl "https://api.dr.eamer.dev/v1/corpus/word-stories?word=computer" \
  -H "X-API-Key: your_api_key"
GET /v1/corpus/ngrams

Search n-gram frequencies (1-5 word sequences) with wildcard patterns.

Query Parameters

ParameterTypeDescription
patternstringN-gram pattern (use + for spaces, * for wildcards)
nintegerN-gram size: 1-5
curl "https://api.dr.eamer.dev/v1/corpus/ngrams?pattern=the+*+of&n=3" \
  -H "X-API-Key: your_api_key"

CORS Proxy

A utility service for safely fetching content from HTTPS URLs that would otherwise be blocked by browser CORS policies. Useful for client-side applications that need to fetch external resources.

⚠️
Note: Separate Service The CORS proxy runs on a separate endpoint and does not require API key authentication.

Base URL

https://dr.eamer.dev/cors-proxy/
GET /cors-proxy/fetch?url={encoded_url}

Fetch content from any HTTPS URL. The proxy adds appropriate CORS headers to allow browser consumption.

Query Parameters
url string (required)
URL-encoded HTTPS URL to fetch (HTTP URLs are automatically upgraded)
Security Restrictions
HTTPS Only security
Only HTTPS URLs are allowed (HTTP is upgraded automatically)
No Private IPs security
Requests to private/internal IP ranges are blocked
No localhost security
Requests to localhost/127.x.x.x are blocked
// Fetch JSON from an external API
const targetUrl = 'https://api.example.com/data.json';
const proxyUrl = `https://dr.eamer.dev/cors-proxy/fetch?url=${encodeURIComponent(targetUrl)}`;

const response = await fetch(proxyUrl);
const data = await response.json();

// Fetch HTML content
const htmlUrl = 'https://example.com/page.html';
const htmlResponse = await fetch(
  `https://dr.eamer.dev/cors-proxy/fetch?url=${encodeURIComponent(htmlUrl)}`
);
const html = await htmlResponse.text();
# Fetch external JSON
curl "https://dr.eamer.dev/cors-proxy/fetch?url=https%3A%2F%2Fapi.example.com%2Fdata.json"

# Check health
curl https://dr.eamer.dev/cors-proxy/health
Response
// Returns the proxied content with CORS headers:
// Access-Control-Allow-Origin: *
// Access-Control-Allow-Methods: GET, POST, OPTIONS
// Access-Control-Allow-Headers: Content-Type, Authorization

{
  "data": "whatever the target URL returns"
}

Data Sources

Search and retrieve data from 17 structured sources including academic databases, government data, media APIs, and archives.

Academic Sources

arxiv pubmed semantic_scholar openlibrary

Government Data

census fec judiciary

Science & Research

nasa weather wolfram

Media & Content

news youtube wikipedia

Technical & Archives

github finance archive wayback
GET /v1/data/sources

Get list of all available data sources organized by category.

curl https://api.dr.eamer.dev/v1/data/sources \
  -H "X-API-Key: your_api_key"
GET /v1/data/{source}/search

Search a specific data source.

Query Parameters
query string
Search query
max_results integer
Maximum number of results (default: 10)
# Search arXiv
curl "https://api.dr.eamer.dev/v1/data/arxiv/search?query=quantum+computing&max_results=5" \
  -H "X-API-Key: your_api_key"

# Search Wikipedia
curl "https://api.dr.eamer.dev/v1/data/wikipedia/search?query=artificial+intelligence" \
  -H "X-API-Key: your_api_key"
response = requests.get(
    "https://api.dr.eamer.dev/v1/data/arxiv/search",
    headers={"X-API-Key": "your_api_key"},
    params={
        "query": "quantum computing",
        "max_results": 5
    }
)

results = response.json()["results"]
GET /v1/data/{source}/get/{id}

Retrieve a specific item by its identifier (arXiv ID, DOI, etc.).

# Get arXiv paper by ID
curl https://api.dr.eamer.dev/v1/data/arxiv/get/2301.07041 \
  -H "X-API-Key: your_api_key"

Data Trove

Access ~1.2GB of curated static datasets from dr.eamer.dev visualizations. Includes economic, demographic, geographic, linguistic, and "wild" datasets (UFOs, meteorites, earthquakes).

Available Categories (15)

accessibility attention geographic linguistic quirky wild economic_billionaires economic_boards economic_housing demographic_poverty demographic_veterans retail fips_county accessibility_audit joshua_project
GET /v1/trove

List all Data Trove categories with dataset counts. No API key required.

# List all categories
curl https://api.dr.eamer.dev/v1/trove
GET /v1/trove/{category}

List all datasets in a category with file size information. No API key required.

Path Parameters

ParameterTypeDescription
categorystringCategory name (e.g., quirky, wild, economic_billionaires)
# List datasets in the quirky category
curl https://api.dr.eamer.dev/v1/trove/quirky
GET /v1/trove/{category}/{dataset}

Fetch a specific dataset. Supports pagination for large files. CSV files are automatically converted to JSON.

Path Parameters

ParameterTypeDescription
categorystringCategory name
datasetstringDataset name (without extension)

Query Parameters

ParameterTypeDescription
limitintegerMaximum records to return (default: 100)
offsetintegerNumber of records to skip
# Get USGS earthquake data with pagination
curl "https://api.dr.eamer.dev/v1/trove/wild/usgs_earthquakes?limit=10" \
  -H "X-API-Key: your_api_key"

Generate

Task-specific AI generation endpoints with pre-configured prompts and optimized models. These endpoints handle prompt engineering server-side for consistent, high-quality results.

POST /v1/generate/alt-text

Generate WCAG-compliant alt text for images. Uses xAI Grok Vision with carefully tuned prompts for accessibility compliance.

Request Body
image string (required)
Base64 encoded image data OR an image URL
context string
Optional context about the image (e.g., "product photo", "news article header")
style string
Alt text style: concise (default, ~125 chars), detailed (comprehensive), or functional (focus on purpose/action)
curl -X POST https://api.dr.eamer.dev/v1/generate/alt-text \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "image": "https://example.com/photo.jpg",
    "style": "concise",
    "context": "product photography"
  }'
import requests
import base64

# Using URL
response = requests.post(
    "https://api.dr.eamer.dev/v1/generate/alt-text",
    headers={"X-API-Key": "your_api_key"},
    json={
        "image": "https://example.com/photo.jpg",
        "style": "detailed"
    }
)

# Or using base64 encoded image
with open("image.jpg", "rb") as f:
    img_data = base64.b64encode(f.read()).decode()

response = requests.post(
    "https://api.dr.eamer.dev/v1/generate/alt-text",
    headers={"X-API-Key": "your_api_key"},
    json={
        "image": img_data,
        "style": "functional",
        "context": "e-commerce listing"
    }
)

print(response.json()["alt_text"])
const response = await fetch('https://api.dr.eamer.dev/v1/generate/alt-text', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    image: 'https://example.com/photo.jpg',
    style: 'concise'
  })
});

const { alt_text, style } = await response.json();
document.querySelector('img').alt = alt_text;
Response
{
  "alt_text": "A ceramic coffee mug with steam rising, placed on a wooden table with morning sunlight streaming through a nearby window",
  "style": "concise",
  "provider": "xai",
  "model": "grok-2-vision-1212"
}
POST /v1/generate/story

Generate interactive story flows with branching choices. Returns structured JSON with nodes and connections for building choose-your-own-adventure style narratives.

Request Body
description string (required)
Natural language description of the story (e.g., "A detective investigating a haunted mansion")
complexity string
Story complexity: simple (5-8 nodes), medium (10-15 nodes), or complex (20+ nodes with multiple endings)
provider string
LLM provider to use (default: xai)
curl -X POST https://api.dr.eamer.dev/v1/generate/story \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "description": "A detective investigating a haunted mansion",
    "complexity": "simple"
  }'
import requests

response = requests.post(
    "https://api.dr.eamer.dev/v1/generate/story",
    headers={"X-API-Key": "your_api_key"},
    json={
        "description": "A space explorer discovering an ancient alien artifact",
        "complexity": "medium"
    }
)

story = response.json()
print(f"Title: {story['title']}")
print(f"Nodes: {len(story['nodes'])}")
print(f"Connections: {len(story['connections'])}")

# Find the starting node
start_node = next(n for n in story['nodes'] if n['id'] == 'start')
print(f"Beginning: {start_node['text']}")
const response = await fetch('https://api.dr.eamer.dev/v1/generate/story', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    description: 'A time traveler stuck in medieval times',
    complexity: 'simple'
  })
});

const story = await response.json();

// Build a simple story engine
let currentNode = story.nodes.find(n => n.id === 'start');
console.log(currentNode.text);

// Get available choices
const choices = story.connections
  .filter(c => c.from === currentNode.id)
  .map(c => ({
    text: c.label,
    nextNode: story.nodes.find(n => n.id === c.to)
  }));
Response
{
  "title": "The Haunted Mansion Investigation",
  "nodes": [
    {
      "id": "start",
      "text": "You stand before the decrepit Blackwood Manor...",
      "type": "start"
    },
    {
      "id": "node_1",
      "text": "The front door creaks open, revealing a dusty foyer...",
      "type": "story"
    },
    {
      "id": "ending_good",
      "text": "You've uncovered the truth and freed the spirits!",
      "type": "ending"
    }
  ],
  "connections": [
    {
      "from": "start",
      "to": "node_1",
      "label": "Enter through the front door"
    },
    {
      "from": "start",
      "to": "node_2",
      "label": "Search around the back"
    }
  ],
  "complexity": "simple",
  "provider": "xai"
}
POST /v1/generate/lesson-plan

Generate comprehensive EFL/ESL lesson plans with structured components including warm-up activities, presentations, practice exercises, production tasks, and assessment strategies. Returns CEFR-aligned lesson plans with ready-to-use handout content.

Request Body
topic string (required)
Lesson topic or theme (e.g., "ordering food at restaurants", "job interview skills")
level string
CEFR level: "A1", "A2", "B1", "B2", "C1", "C2" (default: "B1")
duration string
Class duration: "30min", "45min", "60min", "90min" (default: "60min")
focus string
Primary skill focus: "grammar", "vocabulary", "speaking", "listening", "reading", "writing", "pronunciation", "communication" (default: "speaking")
provider string
LLM provider to use (default: "xai")
curl -X POST https://api.dr.eamer.dev/v1/generate/lesson-plan \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "ordering food at restaurants",
    "level": "B1",
    "duration": "60min",
    "focus": "speaking"
  }'
import requests

response = requests.post(
    "https://api.dr.eamer.dev/v1/generate/lesson-plan",
    headers={"X-API-Key": "your_api_key"},
    json={
        "topic": "job interview skills",
        "level": "B2",
        "duration": "90min",
        "focus": "communication"
    }
)

lesson = response.json()
print(f"Title: {lesson['title']}")
print(f"Objectives: {lesson['objectives']}")
print(f"Warm-up: {lesson['outline']['warm_up']}")
const response = await fetch('https://api.dr.eamer.dev/v1/generate/lesson-plan', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    topic: 'making complaints politely',
    level: 'B1',
    duration: '45min',
    focus: 'speaking'
  })
});

const lesson = await response.json();
console.log('Title:', lesson.title);
console.log('Handout:', lesson.handout_content);
Response
{
  "title": "Ordering Food at Restaurants",
  "level": "B1",
  "duration": "60min",
  "objectives": [
    "Use restaurant vocabulary confidently",
    "Order food and drinks politely",
    "Handle common restaurant situations"
  ],
  "outline": {
    "warm_up": "Restaurant vocabulary matching game...",
    "presentation": "Key phrases and expressions...",
    "practice": "Controlled practice activities...",
    "production": "Role-play restaurant scenarios...",
    "wrap_up": "Review and homework assignment..."
  },
  "handout_content": "Ready-to-print student handout...",
  "video_suggestions": ["YouTube video links..."],
  "visual_aids": ["Suggested images and materials..."],
  "assessment_ideas": ["Formative assessment strategies..."],
  "differentiation": {
    "struggling": "Support strategies...",
    "advanced": "Extension activities..."
  },
  "provider": "xai"
}
POST /v1/generate/business-plan

Generate comprehensive business plans with executive summaries, market analysis, competitive assessment, financial projections, and action plans. Supports different business stages and detail levels.

Request Body
idea string (required)
Business idea description (e.g., "AI-powered plant care app for urban gardeners")
industry string
Industry or sector (e.g., "AgriTech", "SaaS", "Food & Beverage")
location string
Target location or market (e.g., "Portland, Oregon", "Southeast Asia")
stage string
Business stage: "idea", "startup", "growth", "expansion" (default: "startup")
detail_level string
Detail level: "brief", "standard", "comprehensive" (default: "standard")
provider string
LLM provider to use (default: "xai")
curl -X POST https://api.dr.eamer.dev/v1/generate/business-plan \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "idea": "Vegan meal prep delivery service",
    "industry": "Food & Beverage",
    "location": "Portland, Oregon",
    "stage": "startup",
    "detail_level": "comprehensive"
  }'
import requests

response = requests.post(
    "https://api.dr.eamer.dev/v1/generate/business-plan",
    headers={"X-API-Key": "your_api_key"},
    json={
        "idea": "AI tutoring platform for K-12 students",
        "industry": "EdTech",
        "stage": "growth",
        "detail_level": "comprehensive"
    }
)

plan = response.json()
print(f"Executive Summary: {plan['executive_summary']}")
print(f"Market Size: {plan['market_analysis']['market_size']}")
const response = await fetch('https://api.dr.eamer.dev/v1/generate/business-plan', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    idea: 'Sustainable packaging marketplace',
    industry: 'E-commerce',
    location: 'US West Coast',
    stage: 'idea'
  })
});

const plan = await response.json();
console.log('Financial Projections:', plan.financial_projections);
Response
{
  "business_name": "GreenMeal Co.",
  "executive_summary": "A plant-based meal prep service targeting...",
  "market_analysis": {
    "market_size": "$15.7 billion plant-based food market",
    "target_segments": ["Health-conscious professionals", "..."],
    "trends": ["Growing vegan population", "..."],
    "opportunities": ["Underserved suburban areas", "..."]
  },
  "competitive_analysis": {
    "direct_competitors": [{"name": "...", "strengths": "...", "weaknesses": "..."}],
    "competitive_advantage": "Local sourcing and customization..."
  },
  "business_model": {
    "revenue_streams": ["Subscription meals", "A la carte orders"],
    "pricing_strategy": "Premium positioning at $12-18/meal",
    "cost_structure": ["Ingredients 35%", "Labor 25%", "..."]
  },
  "operations_plan": {
    "key_activities": ["Menu development", "..."],
    "resources_needed": ["Commercial kitchen", "..."],
    "milestones": [{"month": 1, "goal": "..."}, "..."]
  },
  "financial_projections": {
    "startup_costs": "$75,000",
    "monthly_burn": "$8,500",
    "break_even": "Month 8",
    "year_1_revenue": "$180,000",
    "year_3_revenue": "$650,000"
  },
  "risk_assessment": [
    {"risk": "Supply chain disruption", "mitigation": "..."}
  ],
  "action_plan": {
    "immediate": ["Secure kitchen space", "..."],
    "short_term": ["Launch MVP", "..."],
    "long_term": ["Expand to Seattle", "..."]
  },
  "provider": "xai"
}
POST /v1/generate/resume

Generate optimized, ATS-friendly resumes with professional formatting. Tailors content based on industry, role, and style preferences. Returns structured data with keyword optimization.

Request Body
name string (required)
Full name for the resume
title string
Professional title or target role
summary string
Brief professional summary or background
experience array
Work experience entries with title, company, dates, and highlights
education array
Education entries with degree, institution, and year
skills array
List of skills and competencies
style string
Resume style: "professional", "creative", "technical", "executive" (default: "professional")
provider string
LLM provider to use (default: "xai")
curl -X POST https://api.dr.eamer.dev/v1/generate/resume \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Jane Smith",
    "title": "Senior Software Engineer",
    "summary": "10 years building scalable web applications",
    "experience": [
      {"title": "Tech Lead", "company": "StartupCo", "dates": "2020-Present"}
    ],
    "skills": ["Python", "React", "AWS", "Team Leadership"],
    "style": "technical"
  }'
import requests

response = requests.post(
    "https://api.dr.eamer.dev/v1/generate/resume",
    headers={"X-API-Key": "your_api_key"},
    json={
        "name": "Alex Johnson",
        "title": "Product Manager",
        "experience": [
            {
                "title": "Senior PM",
                "company": "TechCorp",
                "dates": "2021-Present",
                "highlights": ["Launched 3 products", "Grew team to 12"]
            }
        ],
        "education": [
            {"degree": "MBA", "institution": "Stanford", "year": 2019}
        ],
        "style": "executive"
    }
)

resume = response.json()
print(resume['professional_summary'])
print(resume['keywords'])
const response = await fetch('https://api.dr.eamer.dev/v1/generate/resume', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: 'Sam Wilson',
    title: 'UX Designer',
    skills: ['Figma', 'User Research', 'Prototyping'],
    style: 'creative'
  })
});

const resume = await response.json();
console.log('ATS Keywords:', resume.keywords);
Response
{
  "header": {
    "name": "Jane Smith",
    "title": "Senior Software Engineer",
    "contact": "Formatted contact section..."
  },
  "professional_summary": "Results-driven software engineer with 10+ years...",
  "experience": [
    {
      "title": "Tech Lead",
      "company": "StartupCo",
      "dates": "2020-Present",
      "bullets": [
        "Led team of 8 engineers to deliver $2M platform",
        "Reduced deployment time by 60% through CI/CD improvements",
        "Mentored 5 junior developers to promotion-ready level"
      ]
    }
  ],
  "education": [
    {
      "degree": "B.S. Computer Science",
      "institution": "UC Berkeley",
      "year": 2013,
      "honors": "Cum Laude"
    }
  ],
  "skills": {
    "technical": ["Python", "React", "AWS", "PostgreSQL"],
    "soft": ["Team Leadership", "Agile/Scrum", "Cross-functional Collaboration"]
  },
  "keywords": ["software engineer", "tech lead", "Python", "React", "AWS", "scalable", "leadership"],
  "ats_score": 85,
  "provider": "xai"
}
POST /v1/generate/itinerary

Generate detailed travel itineraries with day-by-day activities, local recommendations, practical travel tips, and cost estimates. Customizable by interests, budget, and travel style.

Request Body
destination string (required)
Travel destination (e.g., "Tokyo, Japan", "Tuscany, Italy")
duration integer
Number of days (default: 3)
interests array
Travel interests (e.g., ["food", "history", "nature", "art", "nightlife"])
budget string
Budget level: "budget", "moderate", "luxury" (default: "moderate")
travelers string
Travel group: "solo", "couple", "family", "group" (default: "couple")
pace string
Trip pace: "relaxed", "moderate", "packed" (default: "moderate")
provider string
LLM provider to use (default: "xai")
curl -X POST https://api.dr.eamer.dev/v1/generate/itinerary \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": "Tokyo, Japan",
    "duration": 5,
    "interests": ["food", "technology", "anime"],
    "budget": "moderate",
    "travelers": "couple",
    "pace": "moderate"
  }'
import requests

response = requests.post(
    "https://api.dr.eamer.dev/v1/generate/itinerary",
    headers={"X-API-Key": "your_api_key"},
    json={
        "destination": "Barcelona, Spain",
        "duration": 4,
        "interests": ["architecture", "food", "beaches"],
        "budget": "moderate",
        "pace": "relaxed"
    }
)

itinerary = response.json()
for day in itinerary['daily_itinerary']:
    print(f"Day {day['day']}: {day['theme']}")
    for activity in day['activities']:
        print(f"  - {activity['time']}: {activity['activity']}")
const response = await fetch('https://api.dr.eamer.dev/v1/generate/itinerary', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    destination: 'Iceland',
    duration: 7,
    interests: ['nature', 'photography', 'adventure'],
    budget: 'moderate',
    travelers: 'solo',
    pace: 'packed'
  })
});

const trip = await response.json();
console.log('Overview:', trip.overview);
console.log('Must-Try:', trip.must_try);
Response
{
  "destination": "Tokyo, Japan",
  "duration": 5,
  "overview": "An immersive 5-day journey through Tokyo...",
  "daily_itinerary": [
    {
      "day": 1,
      "theme": "Traditional Tokyo",
      "activities": [
        {
          "time": "9:00 AM",
          "activity": "Senso-ji Temple & Asakusa",
          "duration": "2 hours",
          "cost_estimate": "$0",
          "tips": "Arrive early to avoid crowds..."
        },
        {
          "time": "12:00 PM",
          "activity": "Lunch at Nakamise Shopping Street",
          "duration": "1 hour",
          "cost_estimate": "$15-25",
          "tips": "Try the ningyo-yaki (sweet cakes)..."
        }
      ],
      "meals": {
        "breakfast": "Hotel or convenience store onigiri",
        "lunch": "Street food at Nakamise",
        "dinner": "Izakaya experience in Shinjuku"
      }
    }
  ],
  "practical_info": {
    "best_time_to_visit": "March-May or Sept-Nov",
    "transportation": "Get a 72-hour metro pass (~$15)",
    "accommodation_areas": ["Shinjuku", "Shibuya", "Asakusa"],
    "estimated_daily_budget": "$150-200",
    "essential_apps": ["Google Maps", "Hyperdia", "Tabelog"],
    "etiquette_tips": ["Remove shoes indoors", "..."]
  },
  "must_try": {
    "foods": ["Ramen at Ichiran", "Tsukiji market sushi"],
    "experiences": ["Robot Restaurant", "Shibuya Crossing"],
    "neighborhoods": ["Akihabara", "Harajuku", "Shimokitazawa"]
  },
  "provider": "xai"
}

Generators

Lightweight content generators for random jokes, insults, colors, and compliments. Perfect for adding personality to applications, testing, or entertainment. All use shuffle-bag algorithms to prevent immediate repetition.

Available Content Types

Dad Jokes Anti-Jokes Rare Insults Compliments Colors
GET /v1/generators/{type}/random

Get a random item of the specified content type. Uses shuffle-bag algorithm to avoid repetition.

Path Parameters

ParameterTypeDescription
typestringContent type: dadjokes, antijokes, insults, compliments, colors
# Get a random dad joke
curl https://api.dr.eamer.dev/v1/generators/dadjokes/random

# Get a random color (29,956 named colors)
curl https://api.dr.eamer.dev/v1/generators/colors/random

# Get a random rare insult
curl https://api.dr.eamer.dev/v1/generators/insults/random
GET /v1/generators/{type}/multiple/{count}

Get multiple items at once (1-50). For colors, use /palette/{count} instead.

Path Parameters

ParameterTypeDescription
typestringContent type: antijokes, insults, compliments
countintegerNumber of items (1-50)
# Get 5 anti-jokes
curl https://api.dr.eamer.dev/v1/generators/antijokes/multiple/5

# Get a color palette (2-10 colors)
curl https://api.dr.eamer.dev/v1/generators/colors/palette/5

LLM

Access 15 AI providers through a unified interface: Anthropic (Claude), OpenAI (GPT-4), xAI (Grok), Mistral, Cohere, Gemini, Perplexity, Groq, HuggingFace, Gradient, ElevenLabs, Manus, and Ollama.

Anthropic
OpenAI
xAI
Mistral
Cohere
Gemini
Perplexity
Groq
HuggingFace
Gradient
ElevenLabs
Manus
Ollama
POST /v1/llm/chat

Generate chat completions using any supported LLM provider.

Request Body
provider string
Provider name (default: xai). Options: anthropic, openai, xai, mistral, cohere, gemini, perplexity, groq, huggingface, gradient, ollama, manus
messages array
Array of message objects with role and content: [{role: "user", content: "Hello"}]
model string
Model name (optional, uses provider default)
stream boolean
Enable SSE streaming (default: false)
temperature number
Sampling temperature (0.0-2.0, optional)
curl -X POST https://api.dr.eamer.dev/v1/llm/chat \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "xai",
    "messages": [
      {"role": "user", "content": "Explain quantum computing"}
    ],
    "temperature": 0.7
  }'
import requests

response = requests.post(
    "https://api.dr.eamer.dev/v1/llm/chat",
    headers={"X-API-Key": "your_api_key"},
    json={
        "provider": "anthropic",
        "messages": [
            {"role": "user", "content": "Explain quantum computing"}
        ],
        "temperature": 0.7
    }
)

data = response.json()
print(data["content"])
const response = await fetch('https://api.dr.eamer.dev/v1/llm/chat', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    provider: 'openai',
    messages: [
      {role: 'user', content: 'Explain quantum computing'}
    ],
    temperature: 0.7
  })
});

const data = await response.json();
console.log(data.content);
Response
{
  "content": "Quantum computing uses quantum mechanics principles...",
  "model": "grok-3",
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 150,
    "total_tokens": 162
  },
  "provider": "xai"
}
POST /v1/llm/chat?stream=true

Stream chat completions using Server-Sent Events (SSE).

curl -N -X POST https://api.dr.eamer.dev/v1/llm/chat \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "xai",
    "messages": [{"role": "user", "content": "Hello"}],
    "stream": true
  }'
import requests
import json

response = requests.post(
    "https://api.dr.eamer.dev/v1/llm/chat",
    headers={"X-API-Key": "your_api_key"},
    json={
        "provider": "xai",
        "messages": [{"role": "user", "content": "Hello"}],
        "stream": True
    },
    stream=True
)

for line in response.iter_lines():
    if line and line.startswith(b"data: "):
        data = json.loads(line[6:])
        if "content" in data:
            print(data["content"], end="", flush=True)
const eventSource = new EventSource(
  'https://api.dr.eamer.dev/v1/llm/chat?stream=true',
  {
    headers: {'X-API-Key': 'your_api_key'}
  }
);

eventSource.onmessage = (event) => {
  const data = JSON.parse(event.data);
  if (data.content) {
    console.log(data.content);
  }
  if (data.done) {
    eventSource.close();
  }
};
POST /v1/llm/vision

Analyze images using vision-capable models.

Request Body
image string
Base64 encoded image or image URL
prompt string
Analysis prompt (default: "Describe this image in detail.")
provider string
Provider name (default: xai). Supports: xai, openai, anthropic, gemini
import requests
import base64

with open("image.jpg", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = requests.post(
    "https://api.dr.eamer.dev/v1/llm/vision",
    headers={"X-API-Key": "your_api_key"},
    json={
        "provider": "xai",
        "image": image_data,
        "prompt": "What's in this image?"
    }
)

print(response.json()["content"])
// Using image URL
const response = await fetch('https://api.dr.eamer.dev/v1/llm/vision', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    provider: 'anthropic',
    image: 'https://example.com/image.jpg',
    prompt: 'What objects are in this image?'
  })
});

const data = await response.json();
console.log(data.content);
POST /v1/llm/embed

Generate text embeddings for semantic search and similarity.

Request Body
text string | array
Text or array of texts to embed
provider string
openai or ollama (default: openai)
model string
Embedding model (optional, defaults: text-embedding-3-small for openai, nomic-embed-text for ollama)
response = requests.post(
    "https://api.dr.eamer.dev/v1/llm/embed",
    headers={"X-API-Key": "your_api_key"},
    json={
        "provider": "openai",
        "text": ["Document 1", "Document 2", "Document 3"]
    }
)

embeddings = response.json()["embedding"]  # List of vectors
POST /v1/llm/speech

Convert text to speech using ElevenLabs or OpenAI.

Request Body
text string
Text to convert to speech
provider string
elevenlabs or openai (default: elevenlabs)
voice string
Voice ID or name (optional)
GET /v1/llm/models

List available models for each provider.

# List all provider capabilities
curl https://api.dr.eamer.dev/v1/llm/models \
  -H "X-API-Key: your_api_key"

# Get models for specific provider
curl "https://api.dr.eamer.dev/v1/llm/models?provider=xai" \
  -H "X-API-Key: your_api_key"

Orchestration

Execute multi-agent AI workflows for complex research and search tasks.

POST /v1/orchestrate/dream-cascade

Execute hierarchical research workflow with 3-tier synthesis (Belters → Drummer → Camina).

Request Body
task string
Research task description
num_agents integer
Number of Belter agents (default: 8)
provider_name string
LLM provider (default: xai)
response = requests.post(
    "https://api.dr.eamer.dev/v1/orchestrate/dream-cascade",
    headers={"X-API-Key": "your_api_key"},
    json={
        "task": "Analyze the impact of AI on education",
        "num_agents": 8,
        "provider_name": "xai"
    }
)

result = response.json()
print(result["result"])  # Final synthesized output
POST /v1/orchestrate/dream-swarm

Execute parallel multi-domain search workflow with specialized agents.

Request Body
query string
Search query
num_agents integer
Number of search agents (default: 5)
provider_name string
LLM provider (default: xai)
response = requests.post(
    "https://api.dr.eamer.dev/v1/orchestrate/dream-swarm",
    headers={"X-API-Key": "your_api_key"},
    json={
        "query": "Latest developments in quantum computing",
        "num_agents": 5
    }
)

result = response.json()
print(result["result"])

Utilities

Image processing and PDF text extraction utilities.

POST /v1/utils/images/resize

Resize images while optionally maintaining aspect ratio.

Request Body
image string
Base64 encoded image
width integer
Target width (optional if height provided)
height integer
Target height (optional if width provided)
maintain_aspect boolean
Maintain aspect ratio (default: true)
format string
Output format: png, jpeg, webp (default: png)
POST /v1/utils/images/convert

Convert image between different formats.

Request Body
image string
Base64 encoded image
format string
Target format: png, jpeg, webp, gif, bmp
quality integer
Quality for lossy formats (1-100, default: 95)
POST /v1/utils/pdf/extract

Extract text content from PDF files.

Request Body
pdf string
Base64 encoded PDF
pages array
Specific page numbers to extract (1-indexed, optional)
include_metadata boolean
Include document metadata (default: false)
import base64

with open("document.pdf", "rb") as f:
    pdf_data = base64.b64encode(f.read()).decode()

response = requests.post(
    "https://api.dr.eamer.dev/v1/utils/pdf/extract",
    headers={"X-API-Key": "your_api_key"},
    json={
        "pdf": pdf_data,
        "pages": [1, 2, 3],  # Extract first 3 pages
        "include_metadata": True
    }
)

result = response.json()
print(result["text"])  # Combined text from all pages