How to Use the Claude API in India: UPI Payment, INR Billing, No Dollar Account

When I tried to sign up for the Anthropic API directly, I got through the account creation, clicked "Add payment method," and hit a wall. The billing page accepts Visa and Mastercard with international transactions enabled — which rules out most Indian debit cards, and many domestic credit cards depending on your bank's default settings. A Wise card works, but that's a separate account to set up and fund in dollars.

Anthropic's API is genuinely one of the best for complex reasoning and long-context tasks. Shutting out Indian developers over a billing quirk is frustrating. Here's the most practical workaround I've found.

The workaround: AICredits.in

AICredits.in is an API gateway that routes calls to Anthropic (and OpenAI, Google, and others) and bills you in INR via Razorpay. You pay with UPI, net banking, or a domestic card — whatever you already use. You get a single OpenAI-compatible API key. You point your existing code at https://api.aicredits.in/v1 instead of Anthropic's endpoint and everything works.

The markup is transparent: live forex rate + 5% forex buffer + 5% platform fee. Around 10–11% over the raw USD price. That's cheaper than the hidden costs of using a Wise card (exchange rate spread + monthly fees) once you account for the convenience.

Supported Claude models

As of March 2026, the Claude models available on AICredits:

Haiku is the one to start with for most tasks — it's fast, cheap, and still substantially better than GPT-4o-mini on instruction-following and structured output tasks in my experience. Sonnet 4 is what you reach for when the task actually requires it: complex multi-step reasoning, long documents, nuanced writing.

Setup walkthrough

Sign up: Create an account at aicredits.in. Email and password, no KYC for standard tiers.

Add credits: Dashboard → Billing → Add Credits. Minimum is ₹100. Razorpay handles the payment — GPay, PhonePe, Paytm, UPI ID, net banking, and most domestic cards all work. Credits are valid for one year.

Create an API key: Dashboard → API Keys → New Key. Give it a name and optionally set a budget cap (covered below). Copy the key.

Your first Claude API call: Let's verify it works.

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-aicredits-key",
    base_url="https://api.aicredits.in/v1"
)

response = client.chat.completions.create(
    model="anthropic/claude-haiku-3-5-20241022",
    messages=[
        {
            "role": "system",
            "content": "You are a concise technical assistant. Answer in 2-3 sentences."
        },
        {
            "role": "user",
            "content": "What's the difference between RAG and fine-tuning?"
        }
    ],
    max_tokens=256
)

print(response.choices[0].message.content)

That's it. The OpenAI SDK works because AICredits exposes an OpenAI-compatible endpoint — the messages format, max_tokens, temperature, system role, all of it maps correctly to Claude's API under the hood.

TypeScript version

Same thing in Node.js / TypeScript:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.AICREDITS_API_KEY!,
  baseURL: "https://api.aicredits.in/v1",
});

async function askClaude(question: string): Promise<string> {
  const response = await client.chat.completions.create({
    model: "anthropic/claude-sonnet-4-20250514",
    messages: [
      {
        role: "system",
        content: "You are a senior software engineer. Be direct and specific.",
      },
      {
        role: "user",
        content: question,
      },
    ],
    max_tokens: 1024,
  });

  return response.choices[0].message.content ?? "";
}

const answer = await askClaude("Review this SQL query for N+1 issues: SELECT * FROM orders WHERE user_id = 1");
console.log(answer);

Streaming responses

Streaming works exactly as you'd expect:

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-aicredits-key",
    base_url="https://api.aicredits.in/v1"
)

with client.chat.completions.create(
    model="anthropic/claude-haiku-3-5-20241022",
    messages=[
        {"role": "user", "content": "Write a Python function to parse a CSV file with error handling"}
    ],
    max_tokens=1024,
    stream=True
) as stream:
    for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)
    print()  # newline at the end

The streaming response format follows the OpenAI SSE protocol, so anything built against that spec — including Vercel AI SDK's useChat hook — works without changes.

Setting budget controls

The per-key budget cap is the feature I use most for team setups. When a teammate needs API access for a project, I create a key with a ₹1,000 cap. When it hits the limit, the key stops working — no surprise bills, no explanation needed, just a natural spending guardrail.

To set this: API Keys → New Key → "Budget Limit (INR)" field. You can also set it on existing keys by editing them in the dashboard.

For scripts running unattended — cron jobs, background workers, automated pipelines — always set a cap. Claude's context window is 200K tokens. A bug that sends a 150K-token document in a loop will eat credits fast.

# Good practice: check your remaining credits programmatically
# (if AICredits exposes a balance endpoint — check the dashboard docs)
# Otherwise, monitor via the usage logs in the dashboard

# For production, wrap your calls with a budget-aware retry pattern:
import os
from openai import OpenAI, RateLimitError

def call_claude_safe(messages: list, model: str = "anthropic/claude-haiku-3-5-20241022") -> str:
    client = OpenAI(
        api_key=os.environ["AICREDITS_API_KEY"],
        base_url="https://api.aicredits.in/v1"
    )

    try:
        response = client.chat.completions.create(
            model=model,
            messages=messages,
            max_tokens=2048
        )
        return response.choices[0].message.content
    except RateLimitError as e:
        # This fires when budget cap is hit
        raise Exception(f"Budget cap reached or rate limited: {e}")

Cost comparison: Claude Haiku via AICredits vs direct Anthropic

Direct Anthropic pricing for Claude 3.5 Haiku: $0.80 input / $4.00 output per 1M tokens.

At a USD/INR rate of ~84:

• Direct (if you could pay): ₹67.20 input / ₹336.00 output per 1M tokens
• Via AICredits (with ~11% markup): ₹96.30 input / ₹481.50 output per 1M tokens

The difference is ₹29 per million input tokens — about ₹0.03 per thousand tokens. For most workloads, that's negligible. A 1,000-token prompt costs about ₹0.096 via AICredits vs ₹0.067 directly. The extra ₹0.03 per call is the price of not needing an international card.

For context: a typical RAG pipeline call with a 2,000-token context and 500-token response costs roughly ₹0.43 via AICredits Haiku. Running 1,000 such calls a day is ₹430/day — well within the range of a ₹10,000 monthly credit top-up.

If you want to go deeper on how to structure your prompts to get the most out of Claude's reasoning capabilities, best Claude system prompts covers the patterns that consistently improve output quality. For long-document work specifically, context engineering is worth reading before you start burning tokens on poorly structured prompts.

System prompt support

One thing to confirm: the system role in the messages array maps correctly to Claude's system prompt parameter. This matters because Claude's behavior is highly sensitive to system prompt design.

response = client.chat.completions.create(
    model="anthropic/claude-sonnet-4-20250514",
    messages=[
        {
            "role": "system",
            "content": """You are an expert code reviewer specializing in Python.

Rules:
- Identify security vulnerabilities first
- Then performance issues
- Then style/readability
- Provide specific line references
- Show corrected code for each issue"""
        },
        {
            "role": "user",
            "content": f"Review this code:\n\n```python\n{code_to_review}\n```"
        }
    ],
    max_tokens=2048
)

The system message works exactly as it does in direct Anthropic calls — AICredits passes it through unchanged.

What doesn't work (yet)

A few Anthropic-specific features aren't available through the OpenAI-compatible endpoint:

• Vision with PDFs: You can send image URLs, but Anthropic's native PDF processing isn't exposed in the OpenAI compatibility layer
• Extended thinking: Claude's extended thinking mode requires Anthropic's native API format
• Citations: Anthropic's document citations feature isn't available through the proxy

For most applications — chat, code generation, text analysis, RAG — none of these limitations matter. If you need extended thinking specifically, you'd need to find a different path.

Bottom line

Getting Claude access in India via AICredits takes about 5 minutes and ₹100. The API is drop-in compatible with anything built on the OpenAI SDK. The 10–11% markup is fair for what you're getting: INR billing, no international card, transparent pricing.

If you're building something with Claude and haven't thought through your system prompt design yet, start with best Claude system prompts — the quality delta between a mediocre and a well-structured system prompt is bigger with Claude than with any other model I've used.