RedPill
Phala · Other
RedPill is a confidential AI platform that gives developers and teams one OpenAI-compatible API for 200+ models, all routed through a gateway running inside a Trusted Execution Environment. Instead of asking you to trust a privacy policy, it attaches an attestation report and a signed receipt to every response so you can check how the answer was served. There's also a consumer chat app for people who want a private assistant without writing code.
About RedPill
What Is RedPill
RedPill is a confidential AI service built around a simple idea: private AI should be provable, not promised. It works as a private AI gateway. That gateway aggregates hundreds of models from verified providers like Phala, Tinfoil, NEAR AI, and Chutes, and runs inside a TEE, a secure slice of hardware that isolates workloads from the host. Requests and responses travel over encrypted paths, and the platform says it doesn't retain prompt or completion bodies.
The main draw is verifiability. Every call returns an attestation report identifying the measured workload plus a signed receipt binding your request to the response. This covers TEE inference end to end. Developers can fetch that receipt and confirm the gateway ran inside genuine hardware, and for confidential models, that the upstream enclave was verified before the prompt was forwarded. That's a real difference from services that simply state a zero-retention policy and leave it at that.
The limits matter too. RedPill isn't a model lab, so it depends on partner providers for the actual weights and uptime. Its strongest privacy guarantees apply to confidential models served by TEE providers; requests routed to third parties like OpenAI or Anthropic fall outside that set. And the verified tooling asks for some setup if you want to run the checks end to end. Worth knowing before you commit.
Getting Started
- Create an API key in the RedPill dashboard and store it as an environment variable such as REDPILL_AI_API_KEY.
- Point any OpenAI or Anthropic client library at the base URL https://api.redpill.ai/v1 and send the key as a bearer token.
- Make a first chat completion call, then read the x-receipt-id header from the response.
- Fetch the receipt from the receipts endpoint and check for an upstream.verified event marked result: verified.
- For agent tools like Claude Code, Codex, or Pi, install the Private AI Proxy desktop app and switch on Protected mode instead of calling the API directly.
Product Information
A quick look at RedPill's pricing, supported platforms, and performance.
Best for
The users, tasks, and scenarios where this tool fits best.
Users
- Developers building private AI features
- Privacy-focused professionals
- Security and legal teams
- Startups avoiding minimum spend
Tasks
- Running confidential inference on sensitive text
- Calling open models such as Qwen, GLM, or NVIDIA Nemotron
- Connecting coding agents to private models
- Verifying AI output integrity
Scenarios
- Reviewing contracts or medical notes with AI where content can't sit on a shared server
- Ship an app that needs a drop-in OpenAI replacement
- Auditing a vendor's privacy claims
- Running high-volume agent workloads
Key features
Verifiable privacy with attestation and receipts
Every response carries an attestation report identifying the workload and a signed receipt tying your request to it. You can fetch the receipt and confirm locally that the gateway ran in a genuine TEE, and that a confidential model ran on a verified upstream enclave. It's a claim you can check. That turns a privacy promise into evidence after a single request.
One OpenAI-compatible gateway for 200+ models
RedPill puts verified TEE providers behind a single API endpoint, so you don't rebuild your app for each network. Chat, completions, and embeddings work unchanged when you point an OpenAI or Anthropic client at the base URL. Model names follow a simple provider/model pattern like z-ai/glm-5.3 or qwen/qwen3.8-27b.
TEE-secured gateway routing
The gateway itself runs inside a Trusted Execution Environment, with encrypted paths for prompts and responses. Routing decisions happen in that isolated environment, and the platform says it doesn't keep request or response bodies. No logs, no stored prompts. That combination matters when you need the routing layer to be as private as the models.
Unified per-token pricing
One price list covers every provider, so you compare models without converting between billing systems. Rates start low on small models and scale with capability, and there's no minimum spend. Smart routing can pick providers by price, speed, or uptime.
Private AI Proxy for agents
For agent tools that don't speak the API directly, the desktop Proxy wraps traffic in a verified session. Install it, turn on Protected mode, and connect tools like Claude Code, Codex, or Pi. Traffic stays protected while the session is active, which covers coding assistants that would otherwise leak prompts to their default backend.
Confidential chat app with private document search
That private AI chat app is a ChatGPT-style client backed by the same private models. Free use gives 10 messages a day, while the $50/month Pro tier unlocks unlimited messaging, file upload, 10 GB storage, and 30 Deep Research queries a month. Need private AI without touching an API? This is the simplest way in.
Honest tri-state claims on verification
Rather than marking everything as verified, RedPill reports each claim as proven, unknown, or unestablished depending on what a provider's verifier can back. A provider might show hardware-proven tee_attested but an unknown serving_software_known_good claim. That honesty is useful when you need to know exactly what's proven and what isn't.
Pros and cons
Pros
- One OpenAI-compatible endpoint covers 200+ models from multiple verified providers, so integration work stays minimal.
- Attestation reports and signed receipts let you verify privacy claims per request instead of trusting a policy page.
- Transparent per-token pricing with no minimum spend and no extra cost for TEE processing.
- The free chat tier and pay-as-you-go API both start at $0, which lowers the cost of testing.
- Zero data retention is offered on confidential providers, and you can enforce it per request.
Cons
- The strongest privacy guarantees only cover confidential models served by TEE providers; requests routed to OpenAI or Anthropic sit outside that set.
- RedPill depends on partner providers for model availability and uptime. So it inherits their outages and catalog changes.
- Running the full verification workflow calls for installing an ACI client, which is more setup than most casual users want.
- The consumer app's free tier caps you at 10 messages a day, so heavier chat use needs the $50/month plan.
Frequently asked questions
RedPill gives you a single confidential API and chat app for running AI models with verifiable privacy. Developers use it to add private inference to apps, while individuals use the chat app for an encrypted assistant.
Related content
Explore related tools, skills, and articles for RedPill.
RedPill Alternatives
BinkBink
BinkBink · OtherBinkBink is a free online game platform and AI game maker that lets anyone turn a short text description into a playable browser game. You can jump into hundreds of community-made games. Or describe your own idea and play it in seconds, then share it with friends. Want to create your own game? You don't need to code. No engine setup, no download, no hassle.
Audiogen
Audiogen Inc. · OtherAudiogen is an AI music generator built by Audiogen Inc., a small research team that spent about 2.5 years training its own generative music model and designing a web interface around it. Instead of a plain text box, this AI music tool turns the timeline into a beginner-friendly Generative Audio Workstation, or GAW, where inpainting, extending, remixing and stem editing work more like painting on a canvas. The product is still in beta, so access runs through a waitlist or an invite. Paid plans aren't published yet.
Aiml API
AIMLAPI OÜ · OtherAiml API is a unified AI model API that puts more than 1000 models from OpenAI, Google, Anthropic, and others behind one endpoint and one bill. You write code against a single OpenAI-compatible schema, then switch between chat, image, video, and audio models by changing a model string. It suits developers and small teams who want multi-model access without juggling a dozen separate provider accounts, and it removes the usual billing headache that comes with testing several vendors. One key covers it all.