Build your own event site in Lovable, v0, Bolt, Replit, Cursor, Claude Code, Webflow, WordPress or by hand, with your own brand. Vihaya runs everything behind it: payments, tickets, QR check-in and payouts. No payment gateway to set up. No ticketing code to write.
In short
Vihaya Events is an event ticketing API for India that works as the backend for your own website. It handles Razorpay payments, QR tickets, ticket emails, gate check-in and organiser payouts. You build the front end in any framework or AI builder. API access is free; paid tickets carry a 1.75–4.5% fee.
Last updated
What you skip
This is what building ticketing yourself looks like. With Vihaya, each line is already done.
Build it yourself
With Vihaya
Open a payment gateway account, finish KYC, wait for website approval
Nothing to open. Payments run through Vihaya’s Razorpay account
Create orders on your server, verify signatures, handle the payment webhook
One call returns the order. We verify the payment before anything is confirmed
Buyer pays and closes the tab before your callback runs
Our webhook still confirms the booking and sends the ticket
Generate ticket ids, QR codes and the ticket email
Issued and emailed on every confirmed booking
Build a scanner for the gate
Scan tickets from any phone in the Vihaya dashboard
Seat counts, ticket tiers, sold-out handling
Tiers, capacity and live availability come with the event
Collect the money, work out fees, pay the organiser
Withdraw from the dashboard. UPI lands in about two working days
How it works
A free event is a single call and the booking is confirmed straight away. A paid one is two, around Razorpay Checkout.
Sign up, open Developer → API keys and create a test key. It only ever touches test events, so nothing real happens while you build.
# test keys start with vihaya_test_sk_
curl -X POST https://events.vihaya.app/api/v1/events \
-H "x-api-key: $VIHAYA_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"title": "Launch Night",
"description": "Doors at 7",
"startDate": "2026-12-12T19:00:00+05:30",
"price": 499
}'List your events and render them however you like. Your design, your domain.
npm install vihaya-sdk
import { VihayaClient } from 'vihaya-sdk';
const vihaya = new VihayaClient(process.env.VIHAYA_API_KEY);
const events = await vihaya.events.list();Post the attendee and get an order back. Open Razorpay Checkout with it, then send us the payment id. We verify it, confirm the booking and email the ticket.
// 1. register → we return an order
POST https://events.vihaya.app/api/v1/events/{eventId}/register
{ "name": "Asha Menon", "email": "asha@example.com", "phone": "+919000000000" }
→ { "orderId": "order_…", "registrationId": "pNd1m0…", "amount": 49900, "key": "rzp_live_…" }
// 2. open Razorpay Checkout in the browser with key + orderId
// 3. confirm → ticket + QR issued, email sent
POST https://events.vihaya.app/api/v1/events/{eventId}/register
{ "registrationId": "pNd1m0…", "orderId": "order_…", "paymentId": "pay_…" }No code
Paste two lines and buyers pick tickets and pay without leaving your site. No API key and no Vihaya account for the buyer.
data-vihaya-event element. The checkout grows to fit, so it never scrolls inside itself.data-vihaya-button opens the checkout over your page.data-vihaya-mode="popup" always uses the window.vihaya:registered event on your page with the event slug and a status (confirmed, or pending while it waits for your approval). It does not carry the ticket or registration id, because every script on your page can read it. The buyer gets the ticket on screen and by email.<div data-vihaya-event="your-event"></div>
<script src="https://events.vihaya.app/embed.js" async></script>
<!-- or a button that opens it -->
<button type="button" data-vihaya-button="your-event">Get tickets</button>
<script src="https://events.vihaya.app/embed.js" async></script>
<script>
window.addEventListener('vihaya:registered', (e) => {
console.log('booked', e.detail.eventSlug, e.detail.status);
});
</script>Building with AI?
Lovable, v0, Bolt, Replit, Cursor, Windsurf, Claude Code or Copilot. Point it at our docs and the OpenAPI spec and it has everything it needs to wire up a real ticketing site. Change the brand line and go.
Prefer to run your events by chatting? Connect Vihaya to Claude. How to connect
Build me an event ticketing website for <my brand>.
Use the Vihaya Events API as the whole backend. Do not add a payment gateway, a database or auth for tickets.
- API reference: https://events.vihaya.app/docs
- OpenAPI spec: https://events.vihaya.app/api/v1/openapi.json
- List events with GET /api/v1/events and show them as cards.
- Event page: GET /api/v1/events/{id}, with a booking form.
- Booking: POST /api/v1/events/{id}/register, open Razorpay Checkout with the
returned key and orderId, then POST register again with the paymentId.
- Keep the API key on the server (an API route), never in the browser.What you get
UPI, cards, net banking and wallets through Razorpay Checkout. You open it with the key and order we return.
Every confirmed booking gets a ticket id that is also its QR code, and a ticket email.
Organisers scan tickets at the entrance from a phone. Team bookings get one ticket per member.
Signed registration.confirmed delivery to your server, so you can run your own post-booking flow.
Want your template and your domain? Send it from the webhook. The QR is just the registration id.
A test key gets its own sandbox: test events, no real money, no emails. Swap the key to go live.
One event with many sessions, each with its own date, price and seats.
Pull the attendee list and sales numbers into your own admin screens.
Preview and send an update to your attendees through the API.
Good to know
Questions
The Vihaya Events API is a REST API that works as the backend for your own event website. It handles events, bookings, Razorpay payments, QR tickets, ticket emails, gate check-in and organiser payouts, so you only build the front end.
No. Buyers pay through Vihaya’s Razorpay account. The organiser withdraws from the Vihaya dashboard and the money lands by UPI in about two working days. You never open, verify or integrate a payment gateway of your own.
API access is free and there is no monthly plan. Free events cost nothing. Paid tickets carry a 1.75–4.5% platform fee, minimum ₹3 and maximum ₹75 per ticket, plus Razorpay’s 3% gateway charge.
Yes. You design and host the front end on your own domain, in any framework. Vihaya Events runs behind it. The ticket email can come from Vihaya, or from your own server using the registration.confirmed webhook.
Yes. Any app builder or coding assistant whose code can make HTTP requests can use the Vihaya Events API. Point it at the API reference and the OpenAPI spec, and use a checkout key if the code runs in the browser.
Use a checkout key in the browser. A Vihaya checkout key can list events, book tickets and read seat counts, but never the attendee list. It can be locked to your domain. Keep full keys on a server.
Vihaya Events has official SDKs for JavaScript / TypeScript, Python, PHP, Ruby, Go, Java / Kotlin, Flutter / Dart. The SDKs cover listing events, booking and verifying payment. Every other endpoint is plain REST with an x-api-key header.
Yes. A Vihaya test key only works on test events. No payment gateway is called, no email is sent, no fee is charged and nothing is public. Swap in a live key when you launch.
A free booking is one call to POST /events/{id}/register and is confirmed immediately. A paid booking is two calls: one returns a Razorpay order, and the second confirms it with the payment id after Checkout.
Vihaya Events still confirms the booking. Razorpay notifies Vihaya’s webhook when the order is paid, and Vihaya confirms the registration and emails the ticket even if the buyer’s browser never comes back.
Every confirmed booking gets a ticket whose QR code is the registration id. Organisers scan it at the entrance from any phone using the Vihaya dashboard. Team bookings get one ticket per member.
Yes. Vihaya sends a signed registration.confirmed webhook when a booking is confirmed and its ticket issued. It is the only webhook event today. Set the URL and secret in the dashboard or through the API.
Organisers request a withdrawal from the Vihaya dashboard to their UPI ID. Transfers land in about two working days, and the minimum withdrawal is ₹100. Payments do not settle directly into the developer’s own gateway account.
Yes. Vihaya Events has an MCP server, so Claude can create, publish and track events and read sales by chatting. It uses the same API key and permissions as the REST API. The setup guide is at events.vihaya.app/connect.
Sign up at events.vihaya.app, verify your email, and open Developer, then API keys. Create a free test key and follow the three steps on this page. Switch to a live key when you are ready to sell.
Guides
Each one has the exact steps, the prompt or code to paste, and the answers to the questions people ask.
Start with a test key today. Switch to a live key when you are ready to sell.