Indonesian-tuned AI inference, OpenAI-compatible.

Make your first request

1. Sign up at platform.epithre.com and verify your email (unlocks $5 free credit).
2. In the dashboard, create an API key. Copy the esk_live_… token immediately — the full value is shown only once.
3. Replace $EPITHRE_KEY below with your key.

curl https://api.epithre.com/v1/chat/completions \
  -H "Authorization: Bearer $EPITHRE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "epithre-omni",
    "messages": [
      {"role": "system", "content": "Kamu asisten yang menjawab singkat dalam bahasa Indonesia."},
      {"role": "user", "content": "Apa ibu kota Jepang dan apa mata uangnya?"}
    ]
  }'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["EPITHRE_KEY"],
    base_url="https://api.epithre.com/v1",  # ← only line that changes vs OpenAI
)

resp = client.chat.completions.create(
    model="epithre-omni",
    messages=[
        {"role": "system", "content": "Kamu asisten yang menjawab singkat dalam bahasa Indonesia."},
        {"role": "user", "content": "Apa ibu kota Jepang dan apa mata uangnya?"},
    ],
)
print(resp.choices[0].message.content)
# → "Ibu kota Jepang adalah Tokyo. Mata uangnya yen Jepang (JPY)."

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.EPITHRE_KEY,
  baseURL: "https://api.epithre.com/v1",  // ← only line that changes vs OpenAI
});

const resp = await client.chat.completions.create({
  model: "epithre-omni",
  messages: [
    { role: "system", content: "Kamu asisten yang menjawab singkat dalam bahasa Indonesia." },
    { role: "user", content: "Apa ibu kota Jepang dan apa mata uangnya?" },
  ],
});
console.log(resp.choices[0].message.content);

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig(os.Getenv("EPITHRE_KEY"))
    config.BaseURL = "https://api.epithre.com/v1"
    client := openai.NewClientWithConfig(config)

    resp, err := client.CreateChatCompletion(context.Background(), openai.ChatCompletionRequest{
        Model: "epithre-omni",
        Messages: []openai.ChatCompletionMessage{
            {Role: "user", Content: "Apa ibu kota Jepang?"},
        },
    })
    if err != nil { panic(err) }
    fmt.Println(resp.Choices[0].Message.Content)
}

Migrating from OpenAI in 5 lines

Already using OpenAI? Switch to Epithre by changing two settings:

# Before
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
resp = client.chat.completions.create(model="gpt-4o", ...)

# After
client = OpenAI(
    api_key=os.environ["EPITHRE_KEY"],
    base_url="https://api.epithre.com/v1",
)
resp = client.chat.completions.create(model="epithre-omni", ...)

Model mapping

What's the same

• Wire format: identical JSON request and response shapes
• Streaming: SSE format, same delta chunks
• Tool/function calling: same tools + tool_choice contract
• Vision: same image_url content type
• Errors: same {"error": {"message", "type"}} envelope

What's different

• Indonesian quality: trained on Indonesian data, fluency on par with native speaker
• Data residency: all inference happens in Jakarta data center — no data leaves Indonesia
• Pricing: ~30-50% cheaper across the board (see Pricing)
• Rerank: Cohere-compatible /v1/rerank endpoint (OpenAI doesn't have this)

Authentication

Send your API key in the Authorization header on every request to /v1/*:

Authorization: Bearer esk_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Key types

Best practices

• Store keys in environment variables; never hardcode them in source
• Use a separate key per service/environment; one app, one key
• Revoke immediately on suspected leak (one click in dashboard)
• Set per-key spending caps in the dashboard (monthly USD cap)

Endpoints

Base URL: https://api.epithre.com

{
  "object": "list",
  "data": [
    {
      "id": "epithre-omni",
      "object": "model",
      "owned_by": "epithre",
      "tier": "flagship",
      "context_window": 49152,
      "max_output_tokens": 16384,
      "modalities": ["text", "image"],
      "capabilities": ["chat", "tool_use", "vision", "thinking"],
      "description": "...",
      "pricing_model": "per_token"
    },
    ...
  ]
}

{
  "id": "chatcmpl-xxxxxx",
  "object": "chat.completion",
  "created": 1778455870,
  "model": "epithre-omni",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Ibu kota Jepang adalah Tokyo."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 9,
    "total_tokens": 27
  }
}

data: {"id":"chatcmpl-x","choices":[{"index":0,"delta":{"role":"assistant","content":""}}]}

data: {"id":"chatcmpl-x","choices":[{"index":0,"delta":{"content":"Ibu kota "}}]}

data: {"id":"chatcmpl-x","choices":[{"index":0,"delta":{"content":"Jepang adalah "}}]}

data: {"id":"chatcmpl-x","choices":[{"index":0,"delta":{"content":"Tokyo."}}]}

data: {"id":"chatcmpl-x","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: {"id":"chatcmpl-x","choices":[],"usage":{"prompt_tokens":18,"completion_tokens":9,"total_tokens":27}}

data: [DONE]

curl https://api.epithre.com/v1/chat/completions \
  -H "Authorization: Bearer $EPITHRE_KEY" \
  -H "Content-Type: application/json" \
  -N \
  -d '{
    "model": "epithre-omni",
    "messages": [{"role": "user", "content": "Tulis 3 fakta tentang Jakarta"}],
    "stream": true,
    "max_tokens": 200
  }'

stream = client.chat.completions.create(
    model="epithre-omni",
    messages=[{"role": "user", "content": "Tulis 3 fakta tentang Jakarta"}],
    stream=True,
    max_tokens=200,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

const stream = await client.chat.completions.create({
  model: "epithre-omni",
  messages: [{ role: "user", content: "Tulis 3 fakta tentang Jakarta" }],
  stream: true,
  max_tokens: 200,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || "");
}

import base64
img_b64 = base64.b64encode(open("invoice.jpg", "rb").read()).decode()

resp = client.chat.completions.create(
    model="epithre-omni",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Ekstrak total pembayaran dari invoice ini sebagai angka."},
            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img_b64}"}},
        ]
    }],
)
print(resp.choices[0].message.content)

IMG=$(base64 -w0 invoice.jpg)
curl https://api.epithre.com/v1/chat/completions \
  -H "Authorization: Bearer $EPITHRE_KEY" \
  -H "Content-Type: application/json" \
  -d "$(jq -n --arg img "$IMG" '{
    "model": "epithre-omni",
    "messages": [{
      "role": "user",
      "content": [
        {"type": "text", "text": "Ekstrak total pembayaran sebagai angka."},
        {"type": "image_url", "image_url": {"url": ("data:image/jpeg;base64," + $img)}}
      ]
    }]
  }')"

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city in Indonesia",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name in Indonesian"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            },
            "required": ["city"]
        }
    }
}]

resp = client.chat.completions.create(
    model="epithre-omni",
    messages=[{"role": "user", "content": "Cuaca Jakarta sekarang gimana?"}],
    tools=tools,
)

# Model decides to call the tool:
tool_call = resp.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # → "get_weather"
print(tool_call.function.arguments)  # → '{"city": "Jakarta", "unit": "celsius"}'

# Execute your function, return result:
followup = client.chat.completions.create(
    model="epithre-omni",
    messages=[
        {"role": "user", "content": "Cuaca Jakarta sekarang gimana?"},
        resp.choices[0].message,
        {"role": "tool", "tool_call_id": tool_call.id, "content": '{"temp": 31, "unit": "C", "condition": "cerah berawan"}'},
    ],
    tools=tools,
)
print(followup.choices[0].message.content)
# → "Jakarta sekarang 31°C, cerah berawan."

resp = client.chat.completions.create(
    model="epithre-omni",
    messages=[
        {"role": "system", "content": "Selalu balas dalam JSON."},
        {"role": "user", "content": "Ekstrak nama, umur, pekerjaan dari: 'Pak Budi, 45 tahun, dokter di RSCM'"},
    ],
    response_format={"type": "json_object"},
)
import json
data = json.loads(resp.choices[0].message.content)
# → {"nama": "Pak Budi", "umur": 45, "pekerjaan": "dokter"}

{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "embedding": [0.0107, -0.0022, 0.0152, ...],  // 4000 floats (or `dimensions` if set)
      "index": 0
    },
    {
      "object": "embedding",
      "embedding": [...],
      "index": 1
    }
  ],
  "model": "epithre-embed",
  "usage": {"prompt_tokens": 24, "total_tokens": 24}
}

resp = client.embeddings.create(
    model="epithre-embed",
    input=[
        "penebangan liar di hutan lindung",
        "perlindungan satwa dilindungi UU 5/1990",
        "kebijakan ekspor batubara 2024",
    ],
    dimensions=1024,  # Truncate for smaller storage; still good quality
)
import numpy as np
vecs = np.array([e.embedding for e in resp.data])
print(vecs.shape)  # → (3, 1024)
print("cost:", resp.usage.prompt_tokens, "input tokens")

curl https://api.epithre.com/v1/embeddings \
  -H "Authorization: Bearer $EPITHRE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "epithre-embed",
    "input": ["penebangan liar di hutan lindung", "perlindungan satwa dilindungi UU 5/1990"],
    "dimensions": 1024
  }'

resp = client.embeddings.create(
    model="epithre-embed",
    input=["UU 41/1999 tentang Kehutanan pasal 50"],
    instruction="Given a legal query, retrieve relevant Indonesian regulations",
)

{
  "id": "2b475d38-c17c-43b9-ba9a-7f485af38e0f",
  "results": [
    {"index": 3, "relevance_score": 0.1480, "document": {"text": "..."}},
    {"index": 0, "relevance_score": 0.0567, "document": {"text": "..."}},
    {"index": 1, "relevance_score": 0.0000}
  ],
  "meta": {"billed_units": {"search_units": 1}}
}

resp = httpx.post(
    "https://api.epithre.com/v1/rerank",
    headers={"Authorization": f"Bearer {EPITHRE_KEY}"},
    json={
        "model": "epithre-rerank",
        "query": "perlindungan hutan lindung dari penebangan",
        "documents": [
            "UU 41/1999 pasal 50 — perusakan hutan",
            "Permen LHK satwa dilindungi",
            "Keppres pemilu 2024",
            "Pasal pengelolaan hutan lindung",
        ],
        "top_n": 3,
        "return_documents": True,
    },
).json()

for r in resp["results"]:
    print(f'{r["relevance_score"]:.3f}  {r["document"]["text"]}')

# → 0.148  Pasal pengelolaan hutan lindung
# → 0.057  UU 41/1999 pasal 50 — perusakan hutan
# → 0.000  Permen LHK satwa dilindungi   ← irrelevant, low score

{
  "created": 1778455000,
  "data": [
    {"b64_json": "iVBORw0KGgoAAAANSUhEUgAA..."}  // base64-encoded PNG
  ]
}

resp = client.images.generate(
    model="epithre-iris",
    prompt="a serene Indonesian beach at sunset, photorealistic, golden hour",
    size="768x768",
)

import base64
img_bytes = base64.b64decode(resp.data[0].b64_json)
with open("output.png", "wb") as f:
    f.write(img_bytes)

resp = httpx.post(
    "https://api.epithre.com/v1/images/generations",
    headers={"Authorization": f"Bearer {EPITHRE_KEY}"},
    json={
        "model": "epithre-iris",
        "prompt": "a young samurai in a bamboo forest, cherry blossoms falling",
        "size": "768x768",
        "lora": "anime",
        "lora_strength": 0.8,
        "seed": 42,
    },
).json()

import base64
src = base64.b64encode(open("original.png", "rb").read()).decode()

resp = httpx.post(
    "https://api.epithre.com/v1/images/edits",
    headers={"Authorization": f"Bearer {EPITHRE_KEY}"},
    json={
        "model": "epithre-iris",
        "prompt": "change the sky to dramatic stormy clouds with lightning",
        "image": src,
        "size": "512x512",
        "strength": 0.7,
    },
).json()

imgs = [base64.b64encode(open(f"ref_{i}.png", "rb").read()).decode()
        for i in range(3)]

resp = httpx.post(
    "https://api.epithre.com/v1/images/edits",
    headers={"Authorization": f"Bearer {EPITHRE_KEY}"},
    json={
        "model": "epithre-iris",
        "prompt": "the product from image 1, displayed in the studio setting from image 2, in the photography style of image 3",
        "images": imgs,
        "size": "640x640",
    },
).json()

Recipes

RAG: embed + rerank + chat

The canonical pattern: index your knowledge base with embed, retrieve top-K with vector search, narrow with rerank, then synthesize an answer with chat.

import httpx, numpy as np
from openai import OpenAI

EK = os.environ["EPITHRE_KEY"]
client = OpenAI(api_key=EK, base_url="https://api.epithre.com/v1")

# 1) ONE-TIME: embed your corpus
corpus = [
    "UU 41/1999 pasal 50 — barangsiapa merusak hutan akan dipidana...",
    "Permen LHK No. 92/2018 tentang pengelolaan satwa liar...",
    "PP No. 23/2021 tentang penyelenggaraan kehutanan...",
    # ... thousands of docs
]
e = client.embeddings.create(model="epithre-embed", input=corpus, dimensions=1024)
corpus_vecs = np.array([row.embedding for row in e.data])  # (N, 1024)

# 2) AT QUERY TIME: embed the question, find top-K nearest
question = "Apa hukuman untuk perusakan hutan lindung?"
qe = client.embeddings.create(model="epithre-embed", input=question, dimensions=1024)
qv = np.array(qe.data[0].embedding)
scores = corpus_vecs @ qv  # cosine sim (already L2-normalized)
top_k_idx = np.argsort(-scores)[:10]
candidates = [corpus[i] for i in top_k_idx]

# 3) Rerank to push the most relevant to the top
r = httpx.post("https://api.epithre.com/v1/rerank",
    headers={"Authorization": f"Bearer {EK}"},
    json={"model": "epithre-rerank", "query": question, "documents": candidates, "top_n": 3, "return_documents": True},
).json()
context = "\n\n".join(item["document"]["text"] for item in r["results"])

# 4) Generate answer with retrieved context
resp = client.chat.completions.create(
    model="epithre-omni",
    messages=[
        {"role": "system", "content": "Jawab berdasarkan konteks yang diberikan. Sebutkan pasal/peraturan yang relevan."},
        {"role": "user", "content": f"Konteks:\n{context}\n\nPertanyaan: {question}"},
    ],
)
print(resp.choices[0].message.content)

Vision QA on documents

Extract structured data from invoices, receipts, KTP, or any document image:

import base64, json
img = base64.b64encode(open("invoice.jpg", "rb").read()).decode()

resp = client.chat.completions.create(
    model="epithre-omni",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Ekstrak data invoice ini sebagai JSON dengan field: vendor, tanggal, nomor_invoice, item (list), subtotal, ppn, total."},
            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img}"}}
        ]
    }],
    response_format={"type": "json_object"},
)
data = json.loads(resp.choices[0].message.content)
print(data["total"])

Build an image generation app

def generate_thumbnail(topic: str) -> bytes:
    """Generate a marketing thumbnail for a given topic."""
    resp = httpx.post("https://api.epithre.com/v1/images/generations",
        headers={"Authorization": f"Bearer {EPITHRE_KEY}"},
        json={
            "model": "epithre-iris",
            "prompt": f"professional marketing thumbnail for: {topic}, vibrant colors, no text",
            "size": "768x768",
            "num_steps": 8,  # higher quality
            "guidance_scale": 1.5,
        },
        timeout=60,
    ).json()
    return base64.b64decode(resp["data"][0]["b64_json"])

thumb = generate_thumbnail("Indonesian food blog — rendang recipe")
open("thumb.png", "wb").write(thumb)

Function calling for agents

Build an agent that can call functions. Loop until finish_reason == "stop" or no tool calls remain:

def get_weather(city: str) -> dict:
    # your real implementation
    return {"city": city, "temp_c": 31, "condition": "cerah berawan"}

def search_news(query: str) -> list:
    return [...]

tool_handlers = {"get_weather": get_weather, "search_news": search_news}
tool_defs = [...]  # OpenAI tools schema

messages = [{"role": "user", "content": "Cuaca Jakarta + berita terbaru tentang banjir"}]

for _ in range(5):  # max 5 rounds
    resp = client.chat.completions.create(model="epithre-omni", messages=messages, tools=tool_defs)
    msg = resp.choices[0].message
    messages.append(msg)

    if not msg.tool_calls:
        print(msg.content)
        break

    for tc in msg.tool_calls:
        args = json.loads(tc.function.arguments)
        result = tool_handlers[tc.function.name](**args)
        messages.append({
            "role": "tool",
            "tool_call_id": tc.id,
            "content": json.dumps(result),
        })

Error handling

All errors return JSON with this envelope (same as OpenAI):

{
  "error": {
    "message": "Human-readable description",
    "type": "error_category",
    "code": "specific_error_code"
  }
}

Full error catalog

Recommended retry pattern

import time

def call_with_retry(call_fn, max_retries=4):
    for attempt in range(max_retries):
        try:
            return call_fn()
        except openai.APIError as e:
            if e.status_code in (429, 502, 503, 504):
                if attempt == max_retries - 1: raise
                wait = (2 ** attempt) + random.uniform(0, 1)  # jitter
                time.sleep(wait)
                continue
            raise  # don't retry 400/401/402/403

Rate limits

Two layers of limits apply to every request:

Per-key limits (yours to control)

Exceed any → HTTP 429 with code indicating which limit.

Backend capacity (shared)

Each chat model has an aggregate concurrent cap across all Epithre customers, to reserve capacity for other services. When hit, you get HTTP 429 with code: "backend_busy". Wait ~1 second and retry — these clear quickly.

Pricing

All prices in USD. Billed per request, deducted from your active API key's credit balance immediately.

Topping up

During alpha, top-up is handled by email: send to hello@epithre.com with the amount and we'll reply with payment details (BCA/Wise/etc). Credit usually applied within 1 business day after payment clears. Stripe/Midtrans integration is planned for general availability.

SDKs & clients

Epithre is OpenAI-wire-compatible. Use any OpenAI SDK and override base_url:

• Python — pip install openai (v1.0+)
• Node.js / TypeScript — npm install openai
• Go — go get github.com/sashabaranov/go-openai
• Java / Kotlin — com.openai:openai-java or Spring AI
• Ruby — gem install ruby-openai
• PHP — openai-php/client on Composer
• Rust — async-openai crate

LangChain

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="epithre-omni",
    api_key=os.environ["EPITHRE_KEY"],
    base_url="https://api.epithre.com/v1",
)
llm.invoke("Halo!")

LlamaIndex

from llama_index.llms.openai_like import OpenAILike
from llama_index.embeddings.openai_like import OpenAILikeEmbedding

Settings.llm = OpenAILike(
    model="epithre-omni",
    api_key=os.environ["EPITHRE_KEY"],
    api_base="https://api.epithre.com/v1",
)
Settings.embed_model = OpenAILikeEmbedding(
    model_name="epithre-embed",
    api_key=os.environ["EPITHRE_KEY"],
    api_base="https://api.epithre.com/v1",
)

For endpoints not in OpenAI SDK (rerank, image edit)

Use plain HTTP via your language's standard client (Python httpx, JS fetch, Go net/http). See examples above.

Data policy (summary)

• We do not log prompts or responses. Only metadata: token counts, timestamps, costs, HTTP status.
• Images submitted to /v1/images/edits are discarded after the response is returned.
• Account data (email, hashed password, API key hashes) retained for account lifetime + 30 days.
• Usage metadata retained 90 days for billing & abuse detection.
• All infrastructure physically in Jakarta, Indonesia — your data never leaves the country.
• TLS 1.2+ enforced on all endpoints.

Full policy: privacy.html.

FAQ

Can I use Epithre to power a customer-facing product?

Yes. The standard ToS allows commercial use. Don't resell raw API access as your own product without a separate reseller agreement (contact us). See Terms.

How does Indonesian quality compare to OpenAI?

Our models are specifically fine-tuned on Indonesian data and outperform comparable OpenAI tier models on Indonesian benchmarks (semantic similarity, instruction following, cultural context). Run your own A/B on real production traffic — that's the only honest benchmark.

What's your uptime SLA?

Best-effort during alpha (no contractual SLA). We monitor 24/7 via Uptime Kuma. In practice we target 99.5%+. For mission-critical workloads with hard SLA, contact us for enterprise terms.

Can I run Epithre on-prem?

Not yet — the platform is currently cloud-only. On-prem licensing is on the roadmap for enterprise.

How do I report abuse or a security issue?

Email hello@epithre.com. For security issues, use subject "Security disclosure". We'll respond within 1 business day.

What happens if I hit my monthly spend cap?

Your key returns 402 insufficient_quota for the rest of the month. Raise the cap in the dashboard or top up to continue.

Can I get my data exported / account deleted?

Yes. Email hello@epithre.com. Export typically delivered as CSV within 7 days. Account deletion erases all linked data within 30 days, except billing records (retained 7 years per Indonesian tax law).