Compare

apiToken.sale vs Portkey: key supplier vs AI gateway

People searching for a Portkey alternative usually want one of two things: cheaper GPT and Gemini tokens, or gateway features without separate OpenAI and Google billing. Portkey solves the second problem; apiToken.sale solves the first. This guide shows how to tell which one you need — and how to run both together.

·

Portkey manages keys you already own — it does not sell them

apiToken.sale and Portkey are not two flavors of the same product. Portkey is an AI gateway: it sits in front of provider API keys you already own and adds routing, caching and observability on top. apiToken.sale is where the key and balance come from in the first place — OpenAI-compatible and native Gemini endpoints with a flat 50% discount and no OpenAI or Google Cloud billing account required.

That distinction decides everything else. With Portkey alone you still bring funded OpenAI and Google accounts, which means passing each provider's own sign-up, billing-country and payment checks, and paying full official token rates. The gateway changes how your requests travel; it never changes what the provider behind it charges per token.

See also: apiToken.sale vs OpenRouter: which gateway fits your GPT and Gemini stack

What an AI gateway earns its keep doing

If you operate several provider accounts or run production traffic, the gateway layer is genuinely useful. The feature set is about control, not price:

  • Fallbacks and load balancing across targets when a provider errors or rate-limits.
  • Automatic retries, plus response caching for repeated prompts.
  • Request logs, traces and usage analytics across every provider you connect.
  • Guardrails and virtual keys, so teammates and services get scoped credentials instead of your raw provider key.

Portkey's gateway is open source, so you can self-host it next to your app, or use the hosted cloud and skip the ops work. Either way, the model tokens themselves are billed by whichever provider account sits behind the gateway — that bill is exactly what a gateway cannot improve.

Where the discounted key actually comes from

apiToken.sale is the supplier side of the stack. You top up a prepaid balance — any whole-dollar amount, by bank card or cryptocurrency — and call the OpenAI-compatible API at https://router.apitoken.sale/v1 or native Gemini generateContent at https://router.apitoken.sale with a key that looks like sk-pool-•••. Every request is metered at official OpenAI or Google rates, then a flat 50% B2C discount is subtracted before the charge touches your balance. The balance never expires, and no provider billing account is involved at any point.

ModelOfficial in / out ($ per 1M)Here (−50%)
GPT-6.1 Terra$1 / $5$0.50 / $2.50
GPT-6.1 Sol$2 / $10$1 / $5
Gemini 3.8 Flash (promotional through 2026)$0.75 / $3.75$0.375 / $1.875

Because the endpoints speak the providers' own protocols, the OpenAI SDKs, the Google GenAI SDK, Codex CLI and Cursor work with a two-line change: the base URL and the key. One key covers both model families, so the same balance follows you across GPT and Gemini.

Full per-model pricing, including cache rates →

Estimate your monthly spend in the free calculator →

Point Portkey at an apiToken.sale key

The two products compose cleanly: Portkey keeps doing routing and observability, while the discounted apiToken.sale key sits underneath as an OpenAI-compatible provider. You keep the gateway's dashboards and fallbacks, and the spend it logs is already 50% lower.

  1. 01Create an apiToken.sale account and generate a key in the dashboard — it looks like sk-pool-••• and works on every supported GPT and Gemini model.
  2. 02In Portkey, add an OpenAI target and override its base URL with a custom host pointing at https://router.apitoken.sale/v1, then paste the sk-pool key as the credential.
  3. 03Send your application traffic through Portkey as usual. Requests arrive at the apiToken.sale endpoint in standard OpenAI format, so model IDs, streaming and tool calls behave as they would against OpenAI. Gemini models ride the same target under their namespaced IDs, such as google/gemini-3.8-flash.
// Portkey gateway config: OpenAI provider, discounted endpoint underneath
{
  "targets": [
    {
      "provider": "openai",
      "api_key": "sk-pool-•••",
      "custom_host": "https://router.apitoken.sale/v1",
      "override_params": { "model": "gpt-6.1-terra" }
    }
  ]
}

Keep catalog model IDs in the target — gpt-6.1-terra, gpt-6.1-sol, or google/gemini-3.8-flash for Gemini through the OpenAI-compatible lane — and keep the /v1 suffix on the custom host. The exact override field lives on the target in gateway configs and on the provider credential in the hosted dashboard; the idea is the same: Portkey forwards OpenAI-format calls to the apiToken.sale base URL.

Same traffic, two different bills

Take a realistic month of agentic coding on gpt-6.1-sol: 10M input tokens and 2M output tokens. At official rates of $2 / $10 per million, that is $20 + $20 = $40. Routing that traffic through a gateway with your own OpenAI key leaves the $40 untouched — you get better logs, not a smaller invoice. The same traffic on an apiToken.sale key costs $20, because the discount applies at the key supplier, where the metering happens.

  • Gateway alone: full official provider bill, plus routing and observability.
  • Discounted key alone: half the bill, called directly with no extra hop.
  • Gateway in front of the discounted key: half the bill and the gateway's controls.

Which layer do you actually need?

  • You just want cheaper GPT and Gemini with working tools — apiToken.sale alone. Change the base URL and key, done.
  • You already fund several provider accounts and need fallbacks, tracing and guardrails across them — Portkey alone, and accept official token prices.
  • You want production controls and a lower bill — run Portkey in front of an apiToken.sale key as described above.

Most individual developers and small teams comparing the two are in the first group: the pain is provider billing accounts and the token price, not a missing routing layer. Start with the discounted key, and add a gateway only when multi-provider operations actually demand one.

Frequently asked questions

Does Portkey give me a GPT or Gemini API discount?

No. Portkey is a gateway over keys you already own, so you keep paying your provider's official rates. The discounted key and balance come from apiToken.sale, which meters official spend and subtracts a flat 50% B2C discount.

Can I use Portkey and apiToken.sale together?

Yes. Add an OpenAI target in Portkey, override its base URL with https://router.apitoken.sale/v1 as the custom host, and paste your sk-pool key — you keep Portkey's observability while the spend underneath is discounted.

Do I still need OpenAI or Google accounts if I use Portkey?

With Portkey alone, yes — it routes requests through provider keys you bring, so funded provider accounts sit behind it. With an apiToken.sale key, no OpenAI or Google billing account is required at all.

Is Portkey a GPT or Gemini API provider?

No. It never sells model access or token balance; it is a control layer between your application and providers you pay directly. apiToken.sale is the opposite: it supplies the key and prepaid balance and adds no routing layer of its own.

Will my OpenAI SDK code still work if I switch key suppliers?

Yes. apiToken.sale serves the OpenAI-compatible API at https://router.apitoken.sale/v1 and native Gemini at https://router.apitoken.sale, so the official SDKs, Codex CLI and Cursor keep working — you change only the base URL and the API key.

Create an account, top up your balance, and generate an API key to use supported GPT and Gemini models.