For hotel groups on Oracle OPERA Cloud

Custom OPERA Cloud integrations in days, not quarters.

Your developers write small C# functions. StayFn runs them against OHIP with authentication, rate limits, retries, events, audit and tenant isolation already built.

AI-assisted: describe an integration to Claude Code and StayFn’s MCP server turns it into validated code on the real OPERA Cloud API. Managed in the EU or US, or self-hosted.

TomorrowsArrivals.cs
[OhipFunction("tomorrows-arrivals", Area = "rsv")]
public sealed partial class TomorrowsArrivals
{
  public async Task<ArrivalsOutput> Run(
      ArrivalsInput input, IFunctionContext ctx)
  {
    var day = input.Date ?? Tomorrow();
    var body = new SearchHotelReservationsRequest
    {
      ArrivalStartDate = day,
      ArrivalEndDate = day,
      Limit = 200,
    };

    // Auth, rate limits and retries are the platform's job.
    var rsv = await ctx.Ohip.Api.Rsv
      .SearchHotelReservationsAsync(body, ct: ctx.Cancellation);

    return Map(day, rsv, input);
  }
}
200 OK · 806 ms · 1 OHIP call · 21 arrivals
Overview

StayFn in a minute and a half

What StayFn is, what it handles for your team, and how to try it, explained in a short video with captions.

AI authoring with the StayFn MCP server

Describe the integration. Get working, validated code.

StayFn ships an MCP server that gives Claude Code, and other MCP clients, the real OPERA Cloud API to work from. The assistant searches the catalog, reads the exact contract, scaffolds the function and validates it, so invented endpoints never make it into your code.

A terminal running Claude Code. The prompt asks for a StayFn function that returns tomorrow's arrivals with their VIP flag. Claude calls the StayFn MCP tools catalog.search (176 matches, searchHotelReservations), ohip.operation, function.scaffold (three files) and function.validate (compiles: true), then a call to the new function answers 200 OK in 806 ms with 21 arrivals.
Replay of a real session: the published StayFn 0.8.1 tool against the OHIP sandbox, output trimmed.
  1. catalog.searchFinds the right operation among the 2,845 in Oracle’s published OHIP specifications, and your existing functions.
  2. ohip.operationGives the exact contract: path, request and response types, and the typed StayFn call to use.
  3. function.scaffoldWrites the function, its tests and its documentation in your project.
  4. function.validateCompiles the result and checks it against StayFn’s rules before anyone runs it.

How to set up the MCP server → · Run these functions in the live demo →

Live demo

Try StayFn yourself

A running StayFn for a fictional hotel group with three hotels. Open the operations dashboard, watch invocations and business events arrive, and run the functions behind the use cases on this site: tomorrow's arrivals and VIPs, the restriction audit and the comp review.

  • Real StayFn, read-only dashboard, functions you can run
  • OPERA Cloud simulated with synthetic data: no real hotel or guest
  • Access for 14 days, approved within one business day

Get access

Ask with your work email. You sign in with a one-time code we email you; no password, no account to create.

Request access

Already approved? Open the live demo →

Free sandbox

Build your own functions today

The StayFn Sandbox is a hosted, synthetic OPERA Cloud. Every OHIP operation answers, with curated data for three fictional hotels, so you can write and run functions on your machine with the VS Code extension and Claude Code before you have Oracle credentials. When you get them, change your .env: your functions stay the same.

  • Sign up with your email, get an API token in a minute
  • Your code runs on your machine, never on ours
  • Free: 5 requests per second, 5,000 per day

Get a sandbox token

Create an account, verify your email and copy the token: it is shown once. Then run StayFn: Connect to StayFn Sandbox in VS Code.

Create a free account

From a terminal instead: stayfn sandbox connect. How the sandbox works →

The problem

Every OHIP integration rebuilds the same plumbing

The business logic is often a few dozen lines. Everything around it takes months, and each team builds it again.

OAuth and tokens

Password and client-credentials flows, token refresh and per-environment app keys, for every integration.

Rate limits

OHIP limits per app key. One noisy job can starve every other integration on the chain.

Retries and failures

Transient errors, idempotency, dead letters and replay, built again for each project.

Many hotels, many tenants

Hotel codes, variables and secrets per property and environment, kept apart from each other.

How it works

Write the logic. StayFn does the rest.

1

Write a function

Plain C# against typed clients for 22 OHIP modules, or just describe it: Claude Code, through StayFn’s MCP server, finds the operation, scaffolds the function and validates it.

2

StayFn runs it

Call it over HTTP, on a schedule or from an OPERA Cloud business event. Every invocation takes the same governed path to OHIP.

3

See every call

The operations dashboard shows each invocation with its OHIP call timeline, events, dead letters, usage and audit.

One pipeline

Every invocation, the same guarantees

HTTP, schedule, event or internal call: each one passes through the same steps before it reaches OPERA Cloud, so no integration can skip them.

  1. Tenant resolution
  2. Quotas
  3. Input validation
  4. Idempotency
  5. OHIP rate-limit budget
  6. Retries
  7. Dead letters and replay
  8. Metering
  9. Audit
Use cases

What hotel groups build with StayFn

Arrivals and VIP lists

Tomorrow’s arrivals with VIP flags, per hotel or across the group, as an API your apps and reports call.

Guest lookups for your apps

Reservation and profile search for guest apps, call centres and kiosks, behind your own API keys and limits.

Event-driven rules

React to reservation and profile changes in OPERA Cloud, in order, and write the result back through OHIP.

Write-back from your systems

Let other systems push signed events to StayFn and turn them into checked, audited OHIP updates.

Group roll-ups

One function, every property: chain-level answers without a script per hotel.

Your own typed APIs

Expose functions as documented endpoints with generated C# and TypeScript clients.

More use cases →

Security

Built for multi-property data

  • Each tenant isolated by PostgreSQL row-level security
  • Secrets stored as references to your vault, never as values
  • Guest data masked in every log line
  • Full audit trail of admin and function activity
Security details →
Deployment

Your cloud or ours

StayFn Cloud

Managed by us in the EU or US. Connect your OHIP environment and start writing functions.

Self-hosted

Docker or Kubernetes in your own account. One .NET host and PostgreSQL 16 is all it needs.

Compare options →

See StayFn run against OPERA Cloud

A 30-minute walkthrough: we connect to the OHIP sandbox, write a function together and watch it run in the dashboard.