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
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 →

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.