Submit LLM, embedding, document, or container jobs asynchronously. Get results at a fraction of the cost of dedicated GPU instances. No infrastructure to manage, no minimum commitment, pay per compute-second.
Clean, well-documented endpoints. Integrates with any language or framework.
Only pay for compute time. No idle costs, no minimum commitments.
Submit thousands of jobs at once. Built for data pipelines and bulk work.
Llama, Qwen, DeepSeek, Gemma, GPT-OSS. Live catalog with current rates.
Already using the OpenAI SDK? Change base_url and you are done. Want the async queue, file inputs, or encrypted payloads? Use the MicroDC SDK below.
# pip install microdc-client from microdc import Client, LLMComplete client = Client(api_key="mDC_your_api_key") job = LLMComplete(model="llama3.3:70b") job.set_prompt("Explain quantum computing in simple terms") # Returns immediately with a job id. job_id = client.send_job(job) # Block until it lands, or poll get_job_status(job_id). details = client.wait_for_job(job_id) print(details.result)
# Native async queue curl https://api.microdc.ai/api/v1/jobs \ -H "Authorization: Bearer $MDC_KEY" \ -H "Content-Type: application/json" \ -d '{ "type": "llm", "model": "llama3.3:70b", "llm_interaction_type": "generation", "payload": {"prompt": "Explain quantum computing in simple terms"} }' # Returns the job record, including its id. curl https://api.microdc.ai/api/v1/jobs/$JOB_ID/result \ -H "Authorization: Bearer $MDC_KEY" # Or skip the queue entirely — OpenAI-compatible, synchronous: # POST https://api.microdc.ai/v1/chat/completions
| Type | What it runs | Routing | Pricing |
|---|---|---|---|
| llm | Chat completions on any supported LLM | By model name | Token-based |
| embed | Vector embeddings for RAG, search, classification | By model name | Token-based |
| document | Summarize, extract, analyze uploaded files | By model name | Flat-rate |
| container | Any Docker image with your script or code | By capability (docker) | GPU-hour or CPU-core-hour |
Point your existing openai client at MicroDC.ai and keep your code. Multimodal content lists supported. Works with LangChain, LlamaIndex, Instructor, and any OpenAI-shaped library.
base_urlfrom openai import OpenAI
client = OpenAI(
api_key="mDC_your_api_key",
base_url="https://api.microdc.ai/v1",
)
resp = client.chat.completions.create(
model="llama3.3:70b",
messages=[
{"role": "user",
"content": "Summarize quantum tunneling."}
],
)
print(resp.choices[0].message.content)
Submit any image. Upload script files (.py, .sh, .js, .ts, .go, .rs, .java...) as inputs. Live log streaming via per-job heartbeat. Routes only to workers advertising the docker capability.
from microdc import Client, ContainerJob
client = Client(api_key="mDC_your_api_key")
token = client.upload_and_tokenize("report.pdf")
job = ContainerJob()
job.set_image("my-registry/pdf-extract:v2")
job.set_command(["--input", "/data/report.pdf"])
job.set_environment({"LOG_LEVEL": "info"})
job.enable_gpu()
job.add_file(token)
# Route only to hardware that can actually run it.
job.set_min_capabilities({"gpu_vram_gb": 24, "memory_gb": 32})
job_id = client.send_job(job)
details = client.wait_for_job(job_id)
Prompts are encrypted on your machine before they leave it, and results are encrypted to your
public key — MicroDC cannot read them. Be precise about the request path, though: the payload key is
escrowed server-side long enough to hand to the worker that runs the job, and destroyed on acknowledgment.
That makes the request path access-controlled, not zero-knowledge, which is why encrypted jobs route only
to MicroDC-managed workers holding the admin-approved encryption capability — never to
third-party hardware. The result path is genuinely zero-knowledge. For regulated industries, IP-sensitive
workflows, and anyone who simply doesn't want their prompts logged.
Read the full architecture →
Client encrypts the payload with AES-256-GCM on your machine and sends your RSA public key alongside. Your private key never leaves your machine.
Encrypted jobs route only to MicroDC-managed workers with the admin-approved encryption capability. The worker receives the key on claim, decrypts in memory, and runs inference against a local model — your decrypted data never touches an external network.
The worker encrypts the result with a fresh one-time key wrapped to your public key. Only your private key can decrypt it. All key material is deleted on acknowledgment.
Free credits to start. No credit card. No minimum. Full API and SDK access from day one.