Free Providers vs Providers with Trial Credits: Key Differences Explained

Free Providers offer permanently free API tiers with defined rate limits, while Providers with trial credits supply temporary monetary allowances (e.g., "$1", "$5") that require registration or verification to claim.

The cheahjs/free-llm-api-resources repository organizes LLM API access into two distinct categories to help developers navigate the landscape of no-cost AI inference. Understanding the architectural and functional differences between free providers vs providers with trial credits ensures you select the appropriate integration method for your project's longevity and budget constraints. This analysis examines the source code implementation that powers these categorizations.

Core Architectural Differences in the Source Code

Dynamic Discovery vs Static Configuration

Free Providers are built through dynamic model-discovery logic that actively scans cloud-provider SDKs and APIs. In src/pull_available_models.py, the script constructs the model_list_markdown variable by iterating over live endpoints from OpenRouter, Google Vertex AI, NVIDIA NIM, and other platforms (lines 936-964). This approach captures real-time availability of models and their current rate limits.

Providers with trial credits are defined as a static Python list named trial_providers_static within the same file (lines 939-1012). Each entry is a dictionary containing hardcoded fields: name, url, credits, requirements, and models_desc. This static structure reflects the fixed nature of promotional credit offers rather than fluctuating free tiers.

Data Structure Variations

The free providers leverage MODEL_TO_NAME_MAPPING from src/data.py to translate model identifiers into human-readable names during markdown generation. Conversely, trial providers embed their model descriptions directly in the static list entries, as seen in fields like "models_desc": "Various open models".

Access Models: Permanent Tiers vs Temporary Credits

Rate Limits and Quotas

Free providers expose their constraints as operational rate limits rather than monetary caps. The generated README.md displays these as concrete usage boundaries—such as "20 requests/minute" for OpenRouter or daily token quotas for Google AI Studio—allowing developers to architect applications around predictable throughput ceilings.

Trial providers express limitations as monetary or token-based credits displayed verbatim in the documentation. The credits field from trial_providers_static renders directly into the README (e.g., "Credits: $1" or "Credits: 1M tokens/model"), indicating a finite resource pool that depletes with usage rather than a time-based throttle.

Verification and Longevity Requirements

While free providers may require phone verification for abuse prevention (notably NVIDIA NIM and Mistral), they impose no upfront monetary commitment and maintain indefinite availability subject to provider policy changes.

Trial credits demand active claim processes including payment method registration or phone verification before the credits become usable. For example, NLP Cloud offers "$15" credits specifically contingent upon phone number verification. These allowances are time-bounded (often expiring after 3 months) and finite by design, transitioning to paid usage once exhausted.

Implementation in pull_available_models.py

The rendering logic distinguishes these categories through separate template placeholders in src/README_template.md. Free provider content injects via {{MODEL_LIST}}, while trial providers populate {{TRIAL_LIST_MARKDOWN}} (lines 1013-1018).

Extracting Trial Provider Configuration

# Parse the static trial provider definitions from the source

from pathlib import Path
import ast

script_path = Path("src/pull_available_models.py")
source = script_path.read_text()

tree = ast.parse(source)
for node in ast.iter_child_nodes(tree):
    if isinstance(node, ast.Assign) and any(
        t.id == "trial_providers_static" for t in node.targets
    ):
        trial_providers = ast.literal_eval(node.value)
        break

# Display provider credit structures

for p in trial_providers:
    print(f"{p['name']}: {p['credits']} (requirements: {p['requirements'] or 'none'})")

Sample output:

Fireworks: $1 (requirements: none)
Baseten: $30 (requirements: none)
Nebius: $1 (requirements: none)
Novita: $0.5 for 1 year (requirements: none)
AI21: $10 for 3 months (requirements: none)

Generating Free Provider Markdown

The dynamic construction occurs around line 688-720, where the script aggregates provider-specific model lists into model_list_markdown:

def build_free_providers_section():
    markdown = ""
    # OpenRouter example from the implementation

    markdown += "### [OpenRouter](https://openrouter.ai)\n\n"

    markdown += "**Limits:** 20 requests/minute, 50 requests/day\n\n"
    markdown += "| Model | Context | Notes |\n"
    markdown += "|-------|---------|-------|\n"
    # Dynamic model insertion from API scan...

    return markdown

Key Files and Their Roles

File	Function
src/pull_available_models.py	Core orchestration script containing trial_providers_static (lines 939-1012) and model_list_markdown generation logic (lines 936-964)
src/data.py	Maintains MODEL_TO_NAME_MAPPING for translating model IDs to display names in free provider tables
src/README_template.md	Template with {{MODEL_LIST}} and {{TRIAL_LIST_MARKDOWN}} placeholders for final document assembly
README.md	Generated output displaying both categories in distinct sections

Summary

• Free Providers are discovered dynamically from live SDKs and offer permanent access with rate limits (requests per minute/day) rather than monetary caps.
• Trial Providers are statically defined with credit amounts (dollar values or token counts) that expire after a set period or upon depletion.
• Trial credits frequently require verification steps (phone numbers or payment methods) that free tiers do not mandate.
• The repository renders these categories separately using distinct template placeholders in the markdown generation pipeline.

Frequently Asked Questions

How does the repository discover free providers dynamically?

The script src/pull_available_models.py queries live APIs from services like OpenRouter, Google Vertex AI, and NVIDIA NIM to build the model_list_markdown variable (lines 936-964). This dynamic approach captures current model availability and rate limits directly from provider endpoints rather than relying on static configuration files.

What happens when trial credits expire?

Once the temporary credits listed in trial_providers_static are exhausted or reach their time limit (e.g., "3 months"), the provider transitions to standard paid billing. The repository documentation marks these as time-limited offers, and users must add payment methods to continue accessing the API beyond the trial period.

Do free providers require credit card verification?

Generally no. While some free providers in the list require phone number verification for abuse prevention (such as NVIDIA NIM), they do not require payment method registration. In contrast, many trial credit providers mandate adding a payment method before releasing the promotional credits, as noted in the requirements field of the static provider list.

Where is the trial provider data stored?

Trial provider configurations reside in the static list trial_providers_static inside src/pull_available_models.py (lines 939-1012). This Python list contains dictionaries with provider metadata including name, url, credits, and requirements, which the script walks to generate the {{TRIAL_LIST_MARKDOWN}} output injected into the final README.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}