Try Chat Free Docs Pricing AI Analysis Repo Insights Free Tools About Blog
Sign in Get started free
< Back to blog
Guide Velona Team ·9 September 2026 ·17 min read

How to Pay for AI APIs Using UPI in India: Complete Guide

Paying for an AI API should not be complicated

If you are building an AI application in India, writing the code is often not the hardest part.

The first real problem can be getting the API access and figuring out how to pay for it.

You may want to test a model for a small project. You may be building a college project, a personal chatbot, a coding assistant, a RAG application or an early SaaS product.

But before your first API request, you may have questions like:

For developers using Velona, the process is built around a prepaid INR wallet. You can add credits using supported Indian payment methods, including UPI through Razorpay, and those credits are then used as you make API requests.

This guide walks through the complete process from adding money to your wallet to sending your first API request.

What does paying for an AI API actually mean?

An AI API is a service that lets your application send information to an AI model and receive a response.

For example, your application might send:

{
  "model": "your-model-id",
  "turns": [
    {
      "role": "user",
      "content": "Explain recursion in simple words"
    }
  ]
}

The AI model processes the request and sends a response back to your application.

That request consumes computing resources. API providers therefore charge based on usage.

For many language models, usage is measured using tokens.

You can think about the process like this:


Your Application
       |
       v
   API Request
       |
       v
    AI Model
       |
       v
   AI Response
       |
       v
   Token Usage
       |
       v
  Wallet Deduction

Instead of paying a fixed amount for every request, your balance is used according to the amount of AI processing your application consumes.

Why UPI is useful for Indian developers

UPI has become one of the simplest ways to make digital payments in India.

For a developer testing an API, this can make a big difference.

Imagine that you only want to spend a small amount while testing a new AI application.

You do not necessarily want to deal with international payment settings, foreign currency conversion or a separate payment process just to send a few API requests.

A UPI supported wallet gives you a much simpler flow:


Choose Wallet Amount
        |
        v
    Select UPI
        |
        v
 Complete Payment
        |
        v
 Payment Verified
        |
        v
 INR Wallet Credit
        |
        v
     API Usage

The important idea is that the payment and the API usage are separate steps.

First you add money to your wallet.

Then your application uses that wallet balance when making API requests.

How the Velona wallet works

Velona uses a prepaid wallet model.

You add money to your account before using paid API requests. Your available balance is then reduced according to your API usage.

The minimum wallet top-up is currently ₹10.

This means you can start with a small amount when you are experimenting.

The basic model looks like this:


       ₹ Wallet
          |
          v
   API Request #1
          |
          v
    Small Deduction
          |
          v
   API Request #2
          |
          v
    Small Deduction
          |
          v
      Balance

This is useful for developers who want to control how much they spend while testing an application.

Velona's documentation states that credits are deducted per token used and that the minimum top-up is ₹10.

What you need before making a payment

You do not need a complicated setup to add wallet credits.

Before starting, keep these things ready:

Once your account is ready, you can move to the wallet.

Step 1: Create your Velona account

The first step is creating an account.

Once your account is created, open the dashboard.

The dashboard gives you access to the main developer features including your wallet, API keys, models and usage information.

You do not need to create a separate account for every AI model you want to use through the gateway.

This becomes useful later when you start experimenting with different models.

Step 2: Open the Wallet section

From the dashboard, open the Wallet section.

Your wallet is where you can see your available balance and add more credits.

The general flow is:


Dashboard
   |
   v
 Wallet
   |
   v
 Add Credits
   |
   v
 Select Amount
   |
   v
 Payment

Before adding money, it is a good idea to check the current model pricing page if you already know which model you want to use.

This gives you a rough idea of how far your balance may go.

Step 3: Choose how much you want to add

You do not need to add a large amount simply because you are testing an API.

If you are learning, experimenting or building a small proof of concept, starting with a small wallet balance can be a sensible approach.

Velona currently supports a minimum top-up of ₹10.

For example, your development process might look like this:

Stage Possible approach
Learning Start with a small balance
Prototype Add credits based on expected testing
Development Monitor usage regularly
Production Estimate usage before funding the wallet

The important thing is to understand your expected usage instead of blindly adding credits.

Step 4: Select UPI

During the payment process, select UPI when it is available as your payment method.

Velona processes wallet payments through Razorpay and supports UPI along with other supported Indian payment methods.

The exact payment screen can change as the payment provider updates its interface, but the basic process remains straightforward.


Wallet
  |
  v
Add Money
  |
  v
Payment Gateway
  |
  v
UPI
  |
  v
Payment Confirmation
  |
  v
Wallet Updated

Step 5: Complete the UPI payment

Complete the payment using your preferred UPI payment flow.

Once the payment is successfully processed and verified, the wallet balance is updated.

At this point, you have credits available for API usage.

It is important to wait for the payment to be confirmed before assuming that the balance has changed.

Step 6: Check your wallet balance

After completing the payment, return to the Wallet section.

You should be able to see your available balance and your wallet transaction information.

Think of this balance as your prepaid API budget.


₹100 Added
     |
     v
API Request
     |
     v
Usage Cost
     |
     v
₹100 - Usage Cost
     |
     v
Remaining Balance

As you make more API requests, the balance changes according to your usage.

Step 7: Create an API key

Adding money to your wallet is only one part of the process.

Your application also needs an API key so the API can identify and authenticate your requests.

Open the API Keys section in your dashboard and create a new key.

Give the key a useful name.


Development
Testing
Production
My Chatbot
RAG Project
Coding Assistant

A descriptive name makes it easier to understand which application is using the key later.

Keep your API key private.

Do not put it directly into a public GitHub repository.

Do not place a private API key inside browser JavaScript.

Do not share it in screenshots or public tutorials.

Step 8: Store your API key safely

For a Python project, environment variables are a simple way to keep the key outside your source code.

Create a file called:

.env

Then add:

VELONA_API_KEY=your_api_key_here

Your Python application can then read the value from the environment.

import os

api_key = os.getenv("VELONA_API_KEY")

print(api_key)

For a real project, never print the key in production logs.

Step 9: Install the Python SDK

If you are using Python, you can use the OpenAI Python SDK with Velona's OpenAI compatible endpoint.

Install the required packages:

pip install openai python-dotenv

The SDK handles much of the HTTP communication for you.

Step 10: Connect Python to the API

Create a Python file such as:

main.py

Then load your API key:

from dotenv import load_dotenv
import os

load_dotenv()

api_key = os.getenv("VELONA_API_KEY")

Create the client:

from openai import OpenAI

client = OpenAI(
    api_key=api_key,
    base_url="https://velona.in/gateway/openai/v1"
)

You can then send a request to a supported model.

response = client.chat.completions.create(
    model="deepseek/deepseek-v3.2",
    messages=[
        {
            "role": "user",
            "content": "Explain recursion in simple words."
        }
    ]
)

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

That is the complete path from wallet payment to an actual AI request.

What happens when you send an API request?

There are several things happening behind the scenes.


Your Python Application
          |
          v
      API Key
          |
          v
    Velona Gateway
          |
          v
     Selected Model
          |
          v
    AI Processing
          |
          v
       Response
          |
          v
   Usage Calculation
          |
          v
    Wallet Deduction

Your application sends the request with your API key and selected model.

The gateway routes the request to the selected model.

The model generates a response.

The request usage is then measured and the corresponding amount is deducted from your available balance.

How are AI API costs calculated?

Many AI models charge according to token usage.

A token is a small unit of text processed by the model.

You can think about a request as having two major parts:


Input Tokens
     +
Output Tokens
     |
     v
Total Usage
     |
     v
Model Pricing
     |
     v
Request Cost

The exact cost depends on the model and the number of tokens processed.

This is why two API requests can have different costs even when they are sent to the same model.

A short question with a short response consumes much less than a large document followed by a long generated response.

Why token usage matters

Consider these two requests.

Request Input Output
Simple question Small Small
Large document analysis Large Large

The second request can consume significantly more tokens.

This is why developers should look at actual usage rather than trying to estimate every request based only on the number of API calls.

How to estimate your monthly AI API spending

You can make a simple estimate before building a production application.

Start with four numbers:

For example, imagine an application that receives 1,000 requests per day.

Each request uses around 500 input tokens and 300 output tokens.

Your approximate daily token usage would be:


1,000 requests × 500 input tokens
= 500,000 input tokens

1,000 requests × 300 output tokens
= 300,000 output tokens

You can then use the current model pricing to estimate the expected cost.

Always check the current pricing page before making a production budget because model prices can change.

Why INR pricing makes budgeting easier

If your application is being built in India, thinking about your API costs in Indian Rupees can make budgeting easier.

Instead of mentally converting every amount into another currency, your wallet balance is already displayed in INR.

For a small project, this can make the development process easier to understand.


Project Budget
     |
     v
₹ Wallet
     |
     +---- API Request
     |
     +---- API Request
     |
     +---- API Request
     |
     v
Remaining ₹ Balance

You can also use the current model pricing information to estimate how much usage your balance can support.

What happens when your wallet balance becomes low?

As your application makes requests, your available balance decreases.

If your balance becomes too low to cover a request, the request cannot continue normally.

This is one reason it is useful to monitor your wallet and usage instead of waiting until an application suddenly stops working.

For production applications, you should also think about what your application should display when an API request cannot be completed because the available balance is insufficient.


API Request
     |
     v
Balance Check
     |
     +------ Enough ------> Process Request
     |
     +------ Not enough --> Handle Error

How to keep your AI API spending under control

Adding money to an API wallet is easy.

Knowing how to control usage is even more important.

1. Start with small tests

Do not immediately send thousands of requests while your application is still being developed.

Start with a few real examples.

2. Check your prompts

Long prompts consume more input tokens.

If your application repeatedly sends unnecessary information, your usage can increase without improving the result.

3. Watch output length

Very long responses consume more output tokens.

If your application only needs a short answer, tell the model to keep the response concise.

4. Monitor usage

Look at your API usage regularly during development.

This helps you understand which features are consuming the most credits.

5. Use appropriate models

Not every task needs the same type of model.

A simple extraction task may not need the same model configuration as a complex reasoning task.

A practical development workflow

A simple workflow for an Indian developer can look like this:


Create Account
      |
      v
Add ₹10 or More
      |
      v
Create API Key
      |
      v
Choose Model
      |
      v
Send Test Request
      |
      v
Check Response
      |
      v
Check Usage
      |
      v
Build Application

This approach keeps the first stage simple.

You do not need to build the entire application before checking whether your API integration works.

Testing your API before writing your application

One useful habit is to test the API independently before connecting it to a large codebase.

You can use cURL for this.

curl -X POST https://velona.in/gateway/v1/inference/run \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek/deepseek-v3.2",
    "turns": [
      {
        "role": "user",
        "content": "Explain APIs in simple words."
      }
    ]
  }'

If this request works, you know that the basic API connection is working.

You can then move the same logic into Python, JavaScript or your application framework.

UPI payment and API usage are two different things

This distinction is useful for beginners.

Your UPI payment does not directly pay for one individual AI request.

Instead, the payment adds credits to your wallet.

Your API requests then consume those credits.


        UPI Payment
             |
             v
        Wallet Credit
             |
             v
     +-------+-------+
     |       |       |
     v       v       v
 Request  Request  Request
     |       |       |
     +-------+-------+
             |
             v
       Usage Deduction

Think of the wallet as prepaid credit for your development work.

Can students use this for projects?

Yes. A prepaid wallet can be useful when building small experiments and academic projects because you can start with a small amount.

For example, a student might build:

The student can first test the application with a small number of requests and then increase usage when the project becomes more useful.

Can freelancers use UPI for AI API projects?

Freelancers often need to test an API before delivering a project.

A prepaid wallet can make this easier because the development account can be funded before the project starts using the API.

You can also create separate API keys for different applications so that your development work remains easier to organize.

For example:


Client A
   |
   +-- API Key A

Client B
   |
   +-- API Key B

Personal Project
   |
   +-- API Key C

This becomes especially useful when you are working on several applications at the same time.

How to keep your API key secure

Payment security is only one part of API security.

Your API key should also be treated like a password.

Follow these basic rules:

A simple Python project might look like:


my-ai-project/
|
+-- main.py
+-- .env
+-- .gitignore
+-- requirements.txt

Your .env file contains the secret.

Your source code reads the secret from the environment.

Add .env to .gitignore

If you use Git, make sure the environment file is not accidentally committed.

.env

For example, your .gitignore can contain:

.env
__pycache__/

This small step can prevent a very common API security mistake.

How to know where your money is going

Once your application is making requests, usage information becomes important.

You should be able to answer questions such as:

Usage logs turn API spending from a guess into something you can actually inspect.

A simple way to think about your AI API budget

Instead of asking only:

How much does one API request cost?

Ask:

How much does my application cost to run?

Those are different questions.

An application with 10 requests per day behaves very differently from one with 10,000 requests per day.

Your real cost depends on:


Requests
   ×
Tokens per Request
   ×
Model Pricing
   =
Estimated Usage Cost

This simple way of thinking is useful when planning an AI product.

Common mistakes when paying for an AI API

Mistake 1: Adding too much money immediately

If you are only testing an API, start small.

Mistake 2: Not checking model pricing

Different models can have very different usage costs.

Mistake 3: Hardcoding the API key

Keep your API key outside your source code.

Mistake 4: Ignoring token usage

A large prompt and a long response can consume significantly more tokens than a short request.

Mistake 5: Never checking usage

Regular usage checks help you understand how your application behaves.

Frequently Asked Questions

Can I pay for AI APIs using UPI in India?

Yes. Velona supports UPI wallet top-ups through Razorpay. The wallet uses INR credits for API usage.

What is the minimum wallet top-up?

The current minimum wallet top-up is ₹10.

Do I need an international card?

No. Velona supports Indian payment methods including UPI. This means you can fund the wallet without depending on an international card for the wallet top-up.

Is the wallet prepaid?

Yes. You add credits before making paid API requests. API usage is then deducted from the available balance.

Can I use the wallet for different AI models?

Yes. Velona provides access to hundreds of AI models through its gateway, so the same wallet can be used while working with supported models.

Can I use Python?

Yes. You can use Python with the native Velona API or the OpenAI compatible interface.

Can I use cURL?

Yes. cURL is useful for testing the API before integrating it into a larger application.

How are API costs calculated?

Costs depend on the model and usage. For language models, token usage is an important part of the calculation.

Should I start with a large wallet balance?

Not necessarily. If you are experimenting, starting with a small balance can help you understand your application's actual usage before adding more credits.

Final Thoughts

For an Indian developer, paying for an AI API should be a small part of building the application, not the thing that stops the project before it starts.

A prepaid INR wallet gives you a straightforward workflow.


Create Account
      ↓
Add INR Credits
      ↓
Use UPI
      ↓
Create API Key
      ↓
Choose Model
      ↓
Send Request
      ↓
Track Usage
      ↓
Build Your Application

With Velona, you can currently start with a ₹10 minimum wallet top-up and use supported Indian payment methods such as UPI through Razorpay. The wallet credits are then used for your API requests based on actual usage.

That makes the setup useful for students, developers, freelancers and teams who want to experiment with AI APIs without making the payment process the hardest part of the project.

The best way to start is simple.

Add a small amount, create an API key, send one request and look at the actual usage.

Once you understand that first request, the rest of your AI application becomes much easier to build.

Ready to make your first AI API request?

Create your Velona account, add INR credits using a supported payment method and start building with AI APIs.

Read the API Documentation

Check Current AI API Pricing