Vihaya SDK for Ruby — Official vihaya-events Gem

vihaya-events is the official Ruby SDK for the Vihaya Events platform. Build event listings, attendee registration flows, Razorpay payment verification, ticketing dashboards, Rails apps, Sinatra apps, Hanami services, Sidekiq background jobs, and CLI tools — all with idiomatic Ruby ergonomics and zero runtime dependencies.

Vihaya is the modern events platform for India — a single stack for event organisers, ticketing, sponsor management, attendee registration, live check-in, and real-time analytics. This gem is the fastest way to integrate the Vihaya Events API (https://events.vihaya.app) into any Ruby 3.0+ codebase.

• What is Vihaya?
• Why the Vihaya Ruby SDK?
• The Vihaya SDK family
• Installation
• Get your Vihaya API key
• Quick start
• Configuration
• Core concepts
• Usage guide
• Framework integrations
• Mega events & sub-events
• Razorpay payment flow
• API reference
• Error handling
• Security best practices
• FAQ
• Keywords
• Development
• Contributing
• License

Vihaya is an all-in-one events platform for India, built for organisers who run college fests, hackathons, conferences, workshops, meetups, bootcamps, summits, and corporate events. The Vihaya platform provides:

• 🎟️ Event creation & ticketing with pricing tiers, promo codes, and a hosted checkout.
• 🏢 Mega events — bundle dozens of sub-events under one parent fest.
• 💳 Razorpay payments — end-to-end with server-side signature verification.
• 📋 Custom registration fields — T-shirt size, college, team members, dietary preferences, accommodation.
• 👥 Attendee management — real-time registrations, broadcasts, CSV exports.
• 📱 Live check-in with mobile QR scanning.
• 👩‍🏫 Speakers, agenda, sponsors, FAQs.
• 📊 Analytics — registrations, revenue, funnel tracking.

This vihaya-events Ruby gem lets developers embed the Vihaya Events API into Rails apps, Sinatra microservices, Hanami projects, Sidekiq jobs, Jekyll plugins, Bridgetown sites, Pakyow apps, and any Ruby script.

Production URL: https://events.vihaya.app · Marketing site: https://vihaya.app · Developer dashboard: https://events.vihaya.app/profile/developer

• 📦 Zero runtime dependencies — built entirely on the Ruby standard library (net/http + json). No Faraday, no HTTParty, no Typhoeus, no transitive dependency tree to audit.
• 💎 Idiomatic Ruby — snake_case everywhere, predicate methods (event.mega_event?, sub.free?), keyword arguments, blocks-friendly.
• 🪄 Tiny — 10 tests, 44 assertions, runs in milliseconds against an in-process TCP stub server.
• 🔐 Type-safe-ish — every response is a typed value object with attribute readers.
• 🧩 Rails ready — drop into a Rails initializer or Sidekiq worker without ceremony.
• 🛡️ MFA-protected — rubygems_mfa_required = true so every release is two-factor authenticated.
• 💳 Razorpay ready — vh.events.register → Razorpay → vh.payments.verify.

All Vihaya SDKs target the same API base URL (https://events.vihaya.app), authenticate with the same x-api-key header, and expose the same methods.

Install the gem directly:

gem install vihaya-events

Or add it to your Gemfile:

gem "vihaya-events"

Then run:

bundle install

Requirements:

• Ruby 3.0, 3.1, 3.2, 3.3, 3.4+
• No other dependencies — pure stdlib

Gem name: vihaya-events. Require path: vihaya.

require "vihaya"

1. Sign up or log in at events.vihaya.app.
2. Open the Developer Dashboard.
3. Click Generate API Key and copy the vh_live_... token.
4. Store it in ENV["VIHAYA_API_KEY"], Rails credentials, or a secrets manager — never commit it.

require "vihaya"

vh = Vihaya::Client.new(ENV.fetch("VIHAYA_API_KEY"))

vh.events.list.each do |event|
  puts "#{event.title} — #{event.location} on #{event.date}"
end

registration = Vihaya::RegisterData.new(
  name: "Anjali Mehta",
  email: "anjali@example.com",
  phone: "+919820012345",
  custom_fields: {
    "T-Shirt Size" => "L",
    "College"      => "Vihaya Institute"
  }
)

result = vh.events.register("evt_8x42j9", registration)

if result[:isPaid]
  puts "Razorpay order: #{result[:orderId]}"
else
  puts "Free registration: #{result[:registrationId]}"
end

vh.payments.verify(
  payment_id: "pay_O8K2...",
  order_id:   result[:orderId],
  signature:  "signature_from_razorpay"
)

vh = Vihaya::Client.new(
  ENV.fetch("VIHAYA_API_KEY"),
  base_url: "https://events.vihaya.app",   # override for staging
  headers:  { "X-Trace-Id" => "abc123" },
  timeout:  60                              # seconds
)

• Events — the root record. Title, description, date, venue, tiers, custom fields, speakers, agenda, sponsors, FAQs, sub-events.
• Mega events — parent events containing sub-events. Detect with event.mega_event?, iterate via event.sub_events.
• Registrations — free or paid attendee entries with optional custom fields and team members.
• Payments — Razorpay orders created during events.register, verified via payments.verify.
• API key — vh_live_... token from the developer dashboard.

event = vh.events.get("evt_8x42j9")

puts event.title
puts "Mode: #{event.event_mode}  Timezone: #{event.timezone}"
puts "Location: #{event.location}"
puts "Date: #{event.date} #{event.time}"

event.speaker_list.each do |speaker|
  puts "- #{speaker.name} (#{speaker.role}) @ #{speaker.company}"
end

event.agenda_list.each do |item|
  puts "[#{item.time}] #{item.title}"
end

event.sponsors.each do |sponsor|
  puts "#{sponsor.name} (#{sponsor.tier})"
end

event.faqs.each do |faq|
  puts "Q: #{faq.question}\nA: #{faq.answer}\n\n"
end

event.special_prices.each do |tier|
  puts "  #{tier.name}: ₹#{tier.amount}"
end

event.custom_fields.each do |field|
  puts "  #{field.name} [#{field.type}] required=#{field.required}"
end

events = vh.events.list

upcoming = events.select { |e| Date.parse(e.date) > Date.today }
mega     = events.select(&:mega_event?)
free     = events.select(&:free?)
online   = events.select { |e| e.event_mode == "online" }

data = Vihaya::RegisterData.new(
  name:  "Priya Raj",
  email: "priya@example.com",
  phone: "+919820012345",
  tier:  "Early Bird",
  promo_code: "LAUNCH10",
  custom_fields: {
    "College"       => "IIT Bombay",
    "T-Shirt Size"  => "M",
    "Year of Study" => "3rd"
  }
)

vh.events.register("evt_conf_2026", data)

result = vh.events.register("evt_hackathon_2026",
  name:  "Team Lead",
  email: "lead@example.com",
  phone: "+919820012345",
  teamName: "Byte Squad",
  teamMembers: [
    { name: "Alice", email: "alice@example.com", phone: "+91..." },
    { name: "Bob",   email: "bob@example.com",   phone: "+91..." },
    { name: "Carol", email: "carol@example.com", phone: "+91..." }
  ]
)

You can pass a plain Hash instead of RegisterData — use camelCase keys for that path since the SDK sends it as-is.

# config/initializers/vihaya.rb
require "vihaya"

VIHAYA = Vihaya::Client.new(Rails.application.credentials.vihaya[:api_key])

class EventsController < ApplicationController
  def index
    @events = VIHAYA.events.list
  end

  def show
    @event = VIHAYA.events.get(params[:id])
  rescue Vihaya::Error => e
    redirect_to events_path, alert: e.message
  end

  def register
    result = VIHAYA.events.register(
      params[:id],
      Vihaya::RegisterData.new(**registration_params)
    )
    render json: result
  rescue Vihaya::Error => e
    render json: { error: e.message }, status: e.status || 500
  end

  private

  def registration_params
    params.permit(:name, :email, :phone, custom_fields: {})
  end
end

require "sinatra"
require "vihaya"
require "json"

vh = Vihaya::Client.new(ENV.fetch("VIHAYA_API_KEY"))

get "/events" do
  content_type :json
  vh.events.list.map(&:to_h).to_json
end

post "/events/:id/register" do
  content_type :json
  data = JSON.parse(request.body.read, symbolize_names: true)
  vh.events.register(params[:id], Vihaya::RegisterData.new(**data)).to_json
end

class ProcessRegistrationJob
  include Sidekiq::Job

  def perform(event_id, payload)
    vh = Vihaya::Client.new(ENV.fetch("VIHAYA_API_KEY"))
    vh.events.register(event_id, Vihaya::RegisterData.new(**payload.symbolize_keys))
  end
end

module Web
  module Actions
    module Events
      class Register < Web::Action
        def handle(req, res)
          vh = Vihaya::Client.new(ENV.fetch("VIHAYA_API_KEY"))
          result = vh.events.register(req.params[:id], req.params.to_h)
          res.body = result.to_json
        end
      end
    end
  end
end

#!/usr/bin/env ruby
require "vihaya"

vh = Vihaya::Client.new(ENV.fetch("VIHAYA_API_KEY"))

vh.events.list.each do |event|
  puts "#{event.title.ljust(40)} #{event.date}  #{event.location}"
end

fest = vh.events.get("evt_mega_fest_2026")

if fest.mega_event?
  puts "#{fest.title} — #{fest.sub_events.size} sub-events"

  fest.sub_events.each do |sub|
    price = sub.free? ? "Free" : "₹#{sub.price}"
    puts "  - #{sub.title} (#{price})"

    sub.custom_fields.each do |field|
      puts "    * #{field.name} [#{field.type}]"
    end
  end
end

Register for a specific sub-event:

vh.events.register("evt_sub_workshop_ml",
  Vihaya::RegisterData.new(
    name:  "Rahul",
    email: "rahul@example.com",
    phone: "+91..."
  )
)

1. Backend — vh.events.register(id, data) → Vihaya creates a Razorpay order and returns :orderId.
2. Frontend — launch Razorpay Checkout with that order ID.
3. Razorpay callback — hands back razorpay_payment_id, razorpay_order_id, razorpay_signature.
4. Backend — vh.payments.verify(...) confirms the signature and marks the registration paid.

result = vh.events.register("evt_conf_2026",
  Vihaya::RegisterData.new(
    name:  "Attendee",
    email: "a@example.com",
    phone: "+91..."
  )
)
order_id = result[:orderId]

# Frontend: Razorpay Checkout with order_id ...

vh.payments.verify(
  payment_id: razorpay_payment_id,
  order_id:   razorpay_order_id,
  signature:  razorpay_signature
)

⚠️ Always verify payments on the server. Never trust a signature checked only in the browser.

The main client. api_key is required and positional; everything else is keyword.

• Vihaya::Event — root event with all metadata + predicate methods (mega_event?, free?, online?)
• Vihaya::Speaker, Vihaya::Sponsor, Vihaya::AgendaItem, Vihaya::FAQItem, Vihaya::Contact
• Vihaya::CustomField, Vihaya::SpecialPrice, Vihaya::PromoCode
• Vihaya::RegisterData — registration payload with keyword constructor
• Vihaya::Error — raised on every API failure

All API failures raise Vihaya::Error with the HTTP status and raw body:

begin
  vh.events.get("evt_does_not_exist")
rescue Vihaya::Error => e
  puts "#{e.message} (status=#{e.status})"
  puts e.data.inspect

  case e.status
  when 404 then puts "Not found"
  when 401, 403 then puts "Auth error"
  when 429 then puts "Rate limited"
  end
end

Never hard-code a vh_live_... key in code that ships to a client.

• Use ENV, Rails encrypted credentials (Rails.application.credentials.vihaya), dotenv, or a secrets manager.
• Call events.register and payments.verify from backend code only.
• Always verify Razorpay signatures server-side.
• Rotate keys via the Vihaya developer dashboard if you suspect a leak.
• Use separate keys for staging and production.

Vihaya is an events platform for India — ticketing, registrations, payments, check-in, analytics, and attendee management. Platform: vihaya.app. Dashboard: events.vihaya.app.

You install with gem install vihaya-events but require with require "vihaya". The gem name reflects what it does on the platform; the require path is short and ergonomic.

No — and that's intentional. Pure stdlib means no transitive dependencies, smaller install footprint, and no version conflicts with whatever HTTP library your Rails app already uses.

Yes — the client is just a Ruby object. Build it once at startup, share it across workers.

Yes — use a test API key from the Vihaya developer dashboard.

Yes. RegisterData is a convenience wrapper. A plain Hash works too — just use camelCase keys (teamMembers, customFields, etc.) on that path.

vihaya · vihaya sdk · vihaya ruby · vihaya events · vihaya gem · vihaya-events · vihaya rails · vihaya sinatra · vihaya hanami · ruby events api · ruby ticketing gem · rails events sdk · ruby razorpay events · vihaya razorpay ruby · events api india ruby · event management gem · sidekiq vihaya · vihaya client ruby · rubygems vihaya · events.vihaya.app ruby · vihaya official ruby sdk

git clone https://github.com/Vishnu252005/vihaya-sdk-ruby.git
cd vihaya-sdk-ruby
ruby test/test_client.rb               # Minitest suite (10 tests, 44 assertions)
gem build vihaya-events.gemspec        # build the .gem file

The test suite uses an in-process TCP stub server — no Bundler, WebMock, or VCR required, no network calls.

Ruby version note: the gemspec requires Ruby ≥ 3.0. Use /opt/homebrew/opt/ruby/bin/ruby on macOS — system Ruby (/usr/bin/ruby 2.6) is too old.

Contributions to the Vihaya Ruby SDK are very welcome. The project is open source and MIT-licensed.

1. Fork Vishnu252005/vihaya-sdk-ruby.
2. Create a feature branch.
3. Run ruby test/test_client.rb.
4. Commit, push, and open a Pull Request.

Found a bug or have a feature request? Open an issue at github.com/Vishnu252005/vihaya-sdk-ruby/issues.

MIT © Vihaya. See LICENSE.

• 📧 Email: support@vihaya.app
• 🌐 Website: vihaya.app
• 🛠️ Dashboard: events.vihaya.app
• 👨‍💻 Developer docs: events.vihaya.app/profile/developer/docs
• 💎 RubyGems: rubygems.org/gems/vihaya-events
• 🐛 Issues: github.com/Vishnu252005/vihaya-sdk-ruby/issues

Built with ❤️ by the Vihaya team.

• Ruby: vihaya-sdk-ruby — you are here
• JavaScript / TypeScript: vihaya-sdk
• Python: vihaya-sdk-python
• Go: vihaya-sdk-go
• Java: vihaya-sdk-java
• PHP: vihaya-sdk-php
• Flutter: vihaya-sdk-flutter