Why a "Multi-Account Pool" Instead of "Single-Account Farming"

Most API aggregation gateways (relay stations) share two traits for their free tiers: small credits, issued per account. A single account's free credit is usually only enough for a few conversations, but if you pool credits from multiple accounts into a unified entry point, you can form a sustainable token pipeline.

The core idea is not "farm once and leave," but treating free credits as infrastructure to operate: register, pool, failover, monitor — forming a closed loop.

Steps

Step 1: Select Aggregation Gateways That Offer Free Credits

Not all relay stations provide free credits. You need to filter for platforms that meet these conditions:

  1. Sign-up bonus: New accounts automatically receive a certain amount of free tokens (usually measured in USD credits or token counts).
  2. Standard API protocol: Compatible with the OpenAI-format /v1/chat/completions endpoint for unified integration.
  3. Credits don't expire, or have a long expiry: Some platforms have 7-day or 30-day validity; prioritize long-lasting ones.
  4. Reasonable multi-account use allowed: Check the platform's terms to avoid violating the service agreement.

Common qualifying directions include:

  • International aggregation gateways (e.g., free tiers from OpenRouter, Together, Fireworks)
  • Domestic relay stations (some offer sign-up credits, usually equivalent to a few to tens of RMB)
  • Self-hosted gateways + multiple upstream free tiers (LiteLLM, One API, etc.)

Step 2: Bulk Registration and Credit Pooling

Prepare separate registration info (email, phone number, etc.) for each platform. After registering, record:

  • Platform name
  • API Base URL
  • API Key
  • Free credit amount
  • Credit expiry
  • Supported model list

Use a spreadsheet (Excel or Notion) to manage everything centrally.

Step 3: Unify Access with a Self-Hosted Gateway

We recommend building a local gateway with LiteLLM or One API, configuring multiple upstream API keys:

```yaml

# LiteLLM config.yaml example

model_list:

  • model_name: gpt-4o-mini

litellm_params:

model: openai/gpt-4o-mini

api_base: https://api.openrouter.ai/v1

api_key: sk-or-xxx

  • model_name: gpt-4o-mini

litellm_params:

model: openai/gpt-4o-mini

api_base: https://api.together.xyz/v1

api_key: xxx

```

Now your application only needs to request the local gateway, and the gateway routes to upstreams that still have credit.

Step 4: Configure Automatic Failover and Credit Monitoring

When one upstream's credit runs out, the gateway should automatically switch to the next. LiteLLM supports fallbacks and retry:

```yaml

router_settings:

fallbacks: [{"gpt-4o-mini": ["gpt-4o-mini"]}]

num_retries: 3

```

Also connect usage monitoring (e.g., LiteLLM's built-in spend tracking) and periodically check remaining credits on each upstream.

Step 5: Replenish After Credits Run Out

When an account's credit is exhausted, you can:

  • Register a new account to top up (mind platform rules)
  • Switch to another upstream that still has credit
  • Participate in platform activities for extra credits

Caveats

  1. Follow platform terms: Multi-account use may violate some platforms' service agreements. Read the terms first. This article only discusses technical feasibility and does not encourage rule-breaking.
  2. Credit expiry: Some credits expire and are voided; check regularly.
  3. API key security: When managing multiple keys centrally, encrypt storage to prevent leaks.
  4. Model differences: Different aggregation gateways support different models; watch compatibility when switching.
  5. Rate limits: Free credits usually come with strict rate limits (e.g., requests per minute); design retry logic accordingly.

Use Cases

  • Daily testing and prototype development for individual developers
  • Low-frequency calls for small-team internal tools
  • Model comparison testing for learning and research
  • Backup channel for paid APIs

Summary

Free credits from API aggregation gateways are inherently scattered, but through multi-account registration + self-hosted gateway pooling + automatic failover + credit monitoring, you can turn them into a relatively stable token pipeline. The key is not "farming once," but treating free credits as infrastructure that needs operating.