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.
[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);
}
}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.

catalog.searchFinds the right operation among the 2,845 in Oracle’s published OHIP specifications, and your existing functions.ohip.operationGives the exact contract: path, request and response types, and the typed StayFn call to use.function.scaffoldWrites the function, its tests and its documentation in your project.function.validateCompiles the result and checks it against StayFn’s rules before anyone runs it.
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.
Write the logic. StayFn does the rest.
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.
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.
See every call
The operations dashboard shows each invocation with its OHIP call timeline, events, dead letters, usage and audit.
One platform, three teams that win
Revenue
Live pickup, rules for high-demand dates, repeat guests, upsells and add-ons, restriction audits across every property.
For revenue managers →Finance
Correct numbers during the day, cost controls on comps and commissions, audit-ready integrations and usage you can charge back.
For finance teams →IT and operations
One governed way to build every OPERA Cloud integration: typed OHIP calls, events, retries, audit and isolation built in.
Integration use cases →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.
- Tenant resolution
- Quotas
- Input validation
- Idempotency
- OHIP rate-limit budget
- Retries
- Dead letters and replay
- Metering
- Audit
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.
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
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.
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.