SeatLayer 0.9.0
dotnet add package SeatLayer --version 0.9.0
NuGet\Install-Package SeatLayer -Version 0.9.0
<PackageReference Include="SeatLayer" Version="0.9.0" />
<PackageVersion Include="SeatLayer" Version="0.9.0" />
<PackageReference Include="SeatLayer" />
paket add SeatLayer --version 0.9.0
#r "nuget: SeatLayer, 0.9.0"
#:package SeatLayer@0.9.0
#addin nuget:?package=SeatLayer&version=0.9.0
#tool nuget:?package=SeatLayer&version=0.9.0
SeatLayer .NET Server SDK for Reserved Seating
The official .NET client for the SeatLayer API. The SeatLayer NuGet package lets a C# backend inspect seat holds, price orders from server data, book reserved seats and verify webhooks, with no package dependencies. SeatLayer is seating chart and reserved-seat ticketing software built for venues up to stadium scale.
SeatLayer's official .NET server SDK is the trusted side of its reserved seating and seat
booking API: inspect the holds a buyer created, price from server data, and book with a stable
bookingRef. From C# you manage seating charts, events, sales channels, and live seat inventory
through one typed ticketing API client.
SeatLayer package on NuGet · .NET server SDK guide · SeatLayer developer platform · SeatLayer JavaScript seat map SDK · Server API reference
Server-side only. This library authenticates with your secret key. Never ship it in a client application. Browser surfaces get short-lived, origin-bound tokens that you mint here.
Two-step shape: the buyer picks and holds seats in the client with your public key, then this SDK confirms the booking from your server with your secret key while your platform keeps checkout and its own payment provider.
Start here: Quickstart · Holds and checkout · .NET server SDK guide · SDK catalog · Pricing: $0 entry, 100 free confirmed-sold-seat credits per organization each month, then $0.10 down to $0.05 a credit, and credits never expire.
Scale evidence
Benchmarked on public 100,000-, 150,000- and 200,000-seat venue fixtures on 15 September 2026: 200,000 seats chart-ready in 1.95 s, desktop, local production build. Fixtures, method and run logs: https://github.com/seatlayer/seatlayer-performance. Live 200,000-seat stadium demo: https://app.seatlayer.io/demo/play/century-stadium-200k. This is renderer evidence, not a concurrent-buyer claim.
Install the .NET seat booking SDK
dotnet add package SeatLayer
Or pin it in your project file:
<PackageReference Include="SeatLayer" Version="0.9.0" />
SeatLayer is published on NuGet; 0.9.0 is the current release. Requires .NET 8 or newer. No package dependencies: HttpClient, System.Text.Json and
HMACSHA256 all ship with the framework, so the SDK forces no version on your application.
Quick start
using SeatLayer;
var client = new SeatLayerClient(Environment.GetEnvironmentVariable("SEATLAYER_SECRET_KEY")!);
// 1. Materialize a published catalog template as a draft for this organiser.
// Replace this placeholder with a template id from your catalog.
var chart = (IReadOnlyDictionary<string, object?>)(
await client.Templates.InstantiateTemplateAsync("your-published-template"))["meta"]!;
await client.Charts.PublishAsync((string)chart["id"]!);
// 2. Create an event on it.
var created = await client.Events.CreateAsync(new EventCreateRequest
{
ChartId = (string)chart["id"]!,
Name = "Spring Gala",
Currency = "EUR", // leave unset to inherit the workspace currency
Region = EventHostingRegions.WesternEurope, // India: AsiaPacific
});
var meta = (IReadOnlyDictionary<string, object?>)created["meta"]!;
var eventKey = (string)meta["key"]!;
// 3. Sell four seats over the phone.
var held = await client.Inventory.HoldBestAvailableAsync(eventKey, new BestAvailableRequest { Qty = 4 });
// … take payment against held["items"], which carry authoritative prices …
await client.Inventory.BookAsync(eventKey, (string)held["holdId"]!, bookingRef: "order-8842");
Event hosting region
Set EventCreateRequest.Region based on the event venue, not your API server or office. It
controls the initial placement of the Event's live inventory; an existing Event
cannot be moved later. Leave it unset to inherit the workspace default (western-europe for new accounts).
Set that default with the named defaultRegion argument to Workspaces.CreateAsync or
Workspaces.UpdateDefaultRegionAsync; changing it affects only future Events.
western-europe,eastern-europe,north-america-east,north-america-west,south-americaasia-pacific,northeast-asia,southeast-asia,oceania,africa,middle-east
The hint is best effort, not a data-residency guarantee. See the full Event region guide.
Register the client as a singleton. It is thread-safe, and its HttpClient is meant to be
long-lived: constructing one per request exhausts sockets.
builder.Services.AddSingleton(_ =>
new SeatLayerClient(builder.Configuration["SeatLayer:SecretKey"]!));
Using IHttpClientFactory? Pass the client in and the SDK will not dispose it, because it does not
own its lifetime:
new SeatLayerClient(secretKey, new SeatLayerClientOptions { HttpClient = factory.CreateClient() });
Fixed renewable Seasons
client.Seasons exposes all 87 trusted organiser operations: the 48 from version 0.7.0,
plus performances, package prices (SeasonPackagePrice.PriceTypeKey: adult, child,
concession, senior or student), publishing, checkout tests, occurrence returns, holders,
Season orders, hosted renewal links and notices, renewal quotes, intents and checkouts, sales and
seat reports with CSV exports, and the
bulk refund of a cancelled date (RefundSeasonPerformanceAsync) and the release of lapsed
renewal offers (ReleaseSeasonLapsedOffersAsync) with their jobs
(ListSeasonBulkJobsAsync, RetrieveSeasonBulkJobAsync).
Validate compatible events before creation, then keep the secret key on your server and give the
browser SeasonPicker only the show-once, origin-bound buyer token.
After the test hold/book/cancel journey and matching webhook deliveries,
ValidateSeasonBuyerRehearsalAsync(seasonKey) sends no evidence body; SeatLayer discovers the
retained chain automatically. Retrieved Season holds contain inventory identity, not an
authoritative amount. Your platform owns package price, payment, order, tax, refunds, benefits,
and ticket or pass delivery.
var validation = await client.Seasons.ValidateSeasonAsync(new SeasonSelectionRequest
{
EventKeys = new[] { "show-friday", "show-saturday" },
});
var created = await client.Seasons.CreateSeasonAsync(new SeasonCreateRequest
{
Name = "2027 subscription",
EventKeys = new[] { "show-friday", "show-saturday" },
IdempotencyKey = "season-2027-create",
});
Season lifecycle, booking, cancellation, and renewal commits are domain-idempotent and therefore remain single-attempt. The 26 Season operations with exact header replay are retried; the full client has 41 exact-header-replay mutations.
When SeatLayer takes the Season's payments, renew a holder with no hosted page: read the price,
start a checkout, and send the holder to payment.url. For a renewal taken by phone or at the box
office, CreateSeasonRenewalIntentAsync records the holder's intent before you commit the offer.
A decline can carry the holder's reason.
var quote = await client.Seasons.RetrieveSeasonRenewalQuoteAsync(seasonKey, offerId);
if (quote["problem"] is null)
{
var started = await client.Seasons.CreateSeasonRenewalCheckoutAsync(
seasonKey, offerId, new SeasonRenewalCheckoutRequest
{
ReturnUrl = "https://tickets.yourclub.example/renewed",
IdempotencyKey = $"renew-{offerId}",
});
// Send the holder to the "url" under started["payment"].
}
await client.Holders.DeclineHolderRenewalOfferAsync("holder_123", offerId, "Moving away");
Renewal works at scale. Above 100 contracts, CreateSeasonRenewalOffersAsync answers
202 {job, batchId} instead of 201 {offers}, and a commit of more than 100 holders from
CreateSeasonHolderImportFromSeasonAsync answers 202 {job}: follow the job with
RetrieveSeasonBulkJobAsync. ListSeasonRenewalOffersAsync and
RetrieveSeasonHostedRenewalsAsync take a SeasonRenewalOfferPageRequest and answer a
nextCursor, null on the last page.
The three CSV exports (Seasons.ExportSeasonHoldersCsvAsync, Seasons.ExportSeasonOrdersCsvAsync
and Orders.ExportEventOrdersCsvAsync) return the CSV as a raw string. Seasons.DeleteSeasonPlanAsync
and Events.DeleteEventDiscountCodeAsync return a plain Task, because the API answers 204 with
no body. On request types where a field can be cleared (SeasonRenewalContactRequest, HolderUpdateRequest,
EventPaymentGatewayReplaceRequest, EventDiscountCodeUpdateRequest, and the cutoffs on
SeasonUpdateRequest), assigning null sends
null, and leaving the property unassigned leaves the field out.
Season seats
Season seats are the seats a season sets aside on every date before its sales open. A season
buyer's hold then doesn't have to ask each date, and single-ticket buyers see those seats as
unavailable. They are off for every season until you set InventoryMode = "block" on
SeasonCreateRequest or SeasonUpdateRequest. The season needs one package, and its sales must
not have opened. Turning them on keeps the season's revision.
await client.Seasons.UpdateSeasonAsync(seasonKey,
new SeasonUpdateRequest { ExpectedRevision = revision, InventoryMode = "block" });
var answer = await client.Seasons.SetAsideSeasonBlockAsync(seasonKey, new SeasonBlockSetAsideRequest
{
ExpectedRevision = revision,
KeepForSingleTickets = new SeasonSeatSelection { SectionIds = new[] { "sec_family" } },
});
var job = (IReadOnlyDictionary<string, object?>)answer["job"]!;
while (job["state"] is "planning" or "running")
{
await Task.Delay(TimeSpan.FromSeconds(2));
var read = await client.Seasons.RetrieveSeasonBulkJobAsync(seasonKey, (string)job["jobId"]!);
job = (IReadOnlyDictionary<string, object?>)read["job"]!;
}
var block = await client.Seasons.RetrieveSeasonBlockAsync(seasonKey);
// Release unsold season seats to single sale. Leave At null to release now.
await client.Seasons.ReleaseSeasonBlockAsync(seasonKey, new SeasonBlockReleaseRequest
{
ExpectedRevision = revision,
Scope = new SeasonBlockReleaseScope { All = true },
At = "2026-12-01T09:00:00Z",
});
- On an active season, block mode turns on by itself once every date has the seats, and
season.block.readyis sent once. On a draft,PublishSeasonAsyncturns it on.season.block.releasedis sent once a release has run. - In block mode, a date cancel (
CreateSeasonAmendmentAsync, kindcancel) orMarkSeasonPerformancePastAsyncfirst takes the date off every season seat. Until that finishes the answer is a202: check it withSeasonsService.IsDateLeavePending(answer), then send the same request again afterRetry-After. - Refusals come through
SeatLayerExceptionwithCode, and nothing changes. For example409 season_block_packages(more than one package),409 season_block_on_sale(sales have opened), or409 block_not_readyfromOpenSeasonSalesAsyncbefore block mode is on. - A partner's seat on a date (one a sales channel sells there) stays out of the block. It is
listed in the block's
notFreeOnEveryDatewith reasonchannel.
The Season seats docs list every refusal.
Test vs live
Keys carry their own mode. sk_test_… keys can only touch test-mode events and sk_live_… only
live ones; crossing them returns 403 mode_mismatch, surfaced as SeatLayerAuthException with
IsModeMismatch.
if (env.IsProduction() && client.Mode != "live")
{
throw new InvalidOperationException("Refusing to boot production against test-mode seating data.");
}
A publishable pk_ key is rejected at construction with a message naming the mistake, rather than
failing as a 401 three round-trips later.
Book reserved seats from .NET
Buyer picks seats in the browser. Your frontend holds them; your backend confirms the price and
books. Never price from what the browser sent you: RetrieveHoldAsync is authoritative.
var hold = await client.Inventory.RetrieveHoldAsync(eventKey, holdId);
var items = ((IEnumerable<object?>)hold["items"]!)
.Cast<IReadOnlyDictionary<string, object?>>()
.ToList();
var currencies = items.Select(item => (string)item["currency"]!).Distinct().ToArray();
if (currencies.Length != 1)
{
throw new InvalidOperationException("A hold must use one currency.");
}
var currency = currencies[0];
var total = items.Sum(item =>
Convert.ToDecimal(item["unitPrice"]) *
Convert.ToDecimal(item.TryGetValue("quantity", out var quantity) ? quantity : 1));
// … charge `total` in `currency` …
await client.Inventory.BookAsync(eventKey, holdId, bookingRef: charge.Id);
Your backend picks the seats. Phone orders, box office, comps.
// Payment already taken: book outright, so nothing is stranded if a second call fails.
await client.Inventory.BookBestAvailableAsync(eventKey,
new BestAvailableRequest { Qty = 2, BookingRef = "phone-1183" });
// Or name the seats yourself.
await client.Inventory.BoxOfficeBookAsync(eventKey, new[] { "A-1", "A-2" }, "comp-14");
Private and partner sales
Channels reserve inventory for a partner, member group, presale, or other private allocation. A buyer access session is short-lived and origin-bound, so the browser receives only the allocation it is allowed to sell; your secret key remains on your server.
var channel = await client.Channels.CreateAsync(eventKey, new CreateChannelRequest
{
Name = "Venue members",
AccessIntent = "private",
});
await client.Channels.UpdateAssignmentsAsync(
eventKey,
new[] { "A-1", "A-2" },
assignmentVersion: 1,
targetChannelId: "ch_members");
var access = await client.Channels.CreateBuyerAccessSessionAsync(
eventKey,
new BuyerAccessSessionRequest
{
IncludePublic = false,
AllowedOrigin = "https://members.example",
ChannelIds = new[] { "ch_members" },
MaxQuantity = 2,
});
Pass the returned token to the buyer SDK. For trusted backend sales, provide ChannelIds on a
BestAvailableRequest, or use the named channelIds argument on HoldAsync, BookAsync, or
BookLabelsAsync. IgnoreChannelRestrictions = true is an explicit privileged override and
should be accompanied by an audit Reason.
Listing and pagination
ListAsync returns one Page plus a cursor. ListAllAsync is an async stream that pages as you
consume it. It is deliberately not a List, because the point of paginating is to not hold an
unbounded result set in memory.
// One page, your own paging.
var page = await client.Events.ListAsync(new EventListRequest { Limit = 50 });
page.Items;
page.NextCursor; // null once exhausted
// Or let the SDK walk it.
await foreach (var seatEvent in client.Events.ListAllAsync())
{
await SyncAsync(seatEvent);
}
Listing events includes live availability counts by default, which costs the server one round-trip
per event. ListAllAsync drops them automatically, since walking a whole catalogue is exactly when
you don't want that, and you can control it explicitly:
await client.Events.ListAsync(new EventListRequest { Limit = 50, Counts = false });
Set SeriesKey to list only the dates of one event series.
Keeping a hold alive
When an order takes longer than the checkout window (an invoice, a phone sale), extend rather than release and re-hold. Releasing first hands the seats to whoever is racing for them in between.
try
{
await client.Inventory.ExtendHoldAsync(eventKey, holdId, ttlMs: 10 * 60_000);
}
catch (SeatLayerConflictException)
{
// Gone, expired, or at its renewal cap: the buyer has to re-pick.
}
Embedding the control room
Your secret key never reaches a browser. Mint a scoped token instead.
var session = await client.Sessions.CreateManageSessionAsync(
eventKey,
"https://box-office.yourplatform.com",
new[] { SessionsService.CapabilityView, SessionsService.CapabilityBlock },
expiresInSeconds: 3600);
capabilities is required by this SDK even though the raw API safely defaults an omitted list
to view-only (event:view). Keeping the argument required makes browser authority visible at every
call site. Grant the smallest set the page needs. For Platform/SDK events, event:cancel returns a
booking's inventory to sale but does not move gateway money; eligible Managed Ticketing refunds use
the separate event:refund capability.
Webhooks
Verify every delivery against the raw body. Model binding and re-serialising changes the bytes, so verification will fail.
app.MapPost("/webhooks/seatlayer", async (HttpRequest request) =>
{
using var buffer = new MemoryStream();
await request.Body.CopyToAsync(buffer); // raw bytes, never a bound model
IReadOnlyDictionary<string, object?> seatEvent;
try
{
seatEvent = Webhook.Verify(
buffer.ToArray(),
request.Headers["X-SeatLayer-Signature"],
Environment.GetEnvironmentVariable("SEATLAYER_WEBHOOK_SECRET")!);
}
catch (SeatLayerWebhookVerificationException)
{
return Results.BadRequest();
}
// The signed body carries "at", but nothing enforces a freshness window, so a
// captured delivery stays valid indefinitely. Deduplicate on occurrenceId:
// this is your replay protection, not an optimisation.
if (await AlreadyProcessedAsync((string)seatEvent["occurrenceId"]!))
{
return Results.Ok();
}
await ProcessAsync(seatEvent);
return Results.Ok();
});
Errors
try
{
await client.Inventory.HoldBestAvailableAsync(eventKey, new BestAvailableRequest { Qty = 6 });
}
catch (SeatLayerConflictException e) when (e.IsSoldOut)
{
return OfferAlternativeDates(); // a business outcome, not a bug
}
catch (SeatLayerRateLimitException e)
{
return RetryAfter(e.RetryAfterSeconds);
}
catch (SeatLayerAuthException e) when (e.IsModeMismatch)
{
throw new InvalidOperationException("Test key pointed at a live event, or the reverse.");
}
when filters read especially well here: a sold-out result and a genuine conflict are the same
exception type but different outcomes.
| Type | Status | Means |
|---|---|---|
SeatLayerAuthException |
401, 403 | Bad, revoked, or wrong-mode key |
SeatLayerNotFoundException |
404 | No such resource for this organisation |
SeatLayerConflictException |
409 | Inventory moved, or a guard rejected the change |
SeatLayerValidationException |
422 | Understood and rejected |
SeatLayerRateLimitException |
429 | Over budget; carries RetryAfterSeconds |
SeatLayerConnectionException |
none | No answer: DNS, TLS, socket, timeout |
Every API exception carries Status, Code, Body and RequestId. Quote the request id in
support requests.
Reliability
Retries. Reads (GET/HEAD) retry 429, 408 and 5xx with exponential backoff and full jitter;
Retry-After wins when the server sends it. 41 mutations use exact header replay:
Charts.CreateAsync,Charts.CopyAsync,Templates.InstantiateTemplateAsync,Events.CreateAsync,Workspaces.CreateAsync,PerformanceGroups.CreateAsync- 26 on
Seasons:CreateSeasonAsync,UpdateSeasonAsync,DeleteSeasonAsync,CreateSeasonPlanAsync,DuplicateSeasonToLiveAsync,CreateSeasonHolderImportAsync,CreateSeasonRenewalOffersAsync,CreateSeasonAmendmentAsync,CreateSeasonHolderImportFromSeasonAsync,CreateSeasonPerformancesAsync,AttachSeasonPerformancesAsync,DeleteSeasonPerformanceAsync,UpdateSeasonPlanAsync,DeleteSeasonPlanAsync,PublishSeasonAsync,CreateSeasonCheckoutTestAsync,ReplaceSeasonPackagePricesAsync,AttachSeasonPlanPerformanceAsync,DeleteSeasonPlanPerformanceAsync,MarkSeasonPerformancePastAsync,RefundSeasonOrderAsync,CancelSeasonOrderAsync,CancelSeasonOrderDateAsync,RefundSeasonPerformanceAsync,CreateSeasonRenewalCheckoutAsync, andReleaseSeasonLapsedOffersAsync Holders.UpdateHolderAsync,Holders.CreateHolderTransferAsync,Holders.CreateHolderReturnAsync,Holders.CreateHolderRenewalCheckoutAsync,Orders.RefundEventOrderAsync, andOrders.CancelEventOrderAsyncEventSeries.CreateEventSeriesAsync,EventSeries.AddEventSeriesDatesAsync, andEventSeries.UpdateEventSeriesAsync
Other 4xx responses are never retried. A cancelled CancellationToken stops the loop immediately
rather than being treated as a transient fault.
Idempotency. Those 41 replay-backed operations carry an Idempotency-Key, generated when you
do not supply one and reused across attempts. All remaining SDK mutations are single-attempt. Some
have a server-side domain idempotency contract, but the SDK does not retry them automatically. This
includes inventory holds and bookings, show-once credential or secret creation, unsupported
operations, and raw SendAsync mutations. Keep the booking reference in the booking body for
reconciliation, but handle an unknown network outcome explicitly instead of automatically
repeating the sale.
new SeatLayerClient(secretKey, new SeatLayerClientOptions
{
MaxRetries = 3, // total attempts
Timeout = TimeSpan.FromSeconds(30), // per attempt
});
Escape hatch
For surface this SDK does not wrap yet, SendAsync keeps auth and error mapping. Raw reads retain
the read retry policy; raw mutations are always single-attempt because their replay contract is unknown:
await client.SendAsync(HttpMethod.Post, "/v1/events/ev_1/some-new-route",
body: new Dictionary<string, object?> { ["qty"] = 2 });
API surface
The client exposes these services. Performance Groups cover runs, sessions, holds, and bookings;
Seasons cover catalogue, plan, sales, buyer-session, booking, renewal, occurrence, reporting,
outbox, and support operations. Events also carries event sales setup: who takes payment, the
payment gateway, sales readiness and state, the booking fee, and discount codes.
| Service | Methods |
|---|---|
Charts |
ListAsync ListAllAsync CreateAsync RetrieveAsync UpdateAsync DeleteAsync CopyAsync ArchiveAsync UnarchiveAsync PublishAsync |
Templates |
InstantiateTemplateAsync |
Events |
ListAsync ListAllAsync CreateAsync RetrieveAsync RetrieveConfigurationBindingAsync UpdateConfigurationBindingAsync UpdateAsync DeleteAsync UpdateChartAsync CloseAsync ReopenAsync ArchiveAsync RetrieveHoldTtlAsync UpdateHoldTtlAsync ListTicketReleasesAsync UpdateTicketReleasesAsync CloseTicketReleaseAsync RetrieveReportAsync RetrieveLogAsync RetrieveEventBuyerCheckoutAsync ReplaceEventBuyerCheckoutAsync RetrieveEventPaymentGatewayAsync ReplaceEventPaymentGatewayAsync RetrieveEventSalesReadinessAsync PreflightEventSalesAsync TransitionEventSalesAsync RetrieveEventBookingFeeAsync ReplaceEventBookingFeeAsync ListEventDiscountCodesAsync CreateEventDiscountCodeAsync UpdateEventDiscountCodeAsync EndEventDiscountCodeAsync DeleteEventDiscountCodeAsync |
EventSeries |
CreateEventSeriesAsync ListEventSeriesAsync RetrieveEventSeriesAsync AddEventSeriesDatesAsync UpdateEventSeriesAsync |
Channels |
ListAsync CreateAsync UpdateAsync UpdateAssignmentsAsync ListAllocationAsync RetrieveAccessPreviewAsync RetrieveReportAsync PauseAsync UnpauseAsync ArchiveAsync CreateBuyerAccessSessionAsync ListBuyerAccessSessionsAsync RevokeBuyerAccessSessionAsync |
Holders |
ListCustomersAsync RetrieveHolderAsync UpdateHolderAsync RevokeHolderSessionsAsync ListHolderSeasonsAsync ListHolderTicketsAsync RetrieveHolderTicketAsync CreateHolderTransferAsync ListHolderTransfersAsync CancelHolderTransferAsync AcceptHolderTransferAsync CreateHolderReturnAsync CreateHolderRenewalCheckoutAsync DeclineHolderRenewalOfferAsync |
Inventory |
HoldAsync HoldBestAvailableAsync BookBestAvailableAsync ExtendHoldAsync RetrieveHoldAsync ReleaseAsync BookAsync BookLabelsAsync BoxOfficeBookAsync UnbookAsync BlockAsync UnblockAsync UnblockAllAsync RetrieveAvailabilityAsync UpdateAvailabilityAsync ListBookingsAsync RetrieveBookingAsync |
Orders |
ListOrdersAsync RetrieveOrderAsync ListOrderTicketsAsync ListEventOrdersAsync RetrieveEventOrderAsync ExportEventOrdersCsvAsync RefundEventOrderAsync CancelEventOrderAsync ResendEventOrderTicketsAsync |
Sessions |
CreateManageSessionAsync RevokeManageSessionAsync CreateDesignerSessionAsync RevokeDesignerSessionAsync |
Webhooks |
ListAsync CreateAsync UpdateAsync DeleteAsync ListDeliveriesAsync |
Workspaces |
ListAsync CreateAsync RetrieveAsync UpdateAsync |
PerformanceGroups |
ListAsync CreateAsync RetrieveAsync DeleteAsync ActivateAsync CloseAsync RetrieveLifecycleAsync CreateBuyerAccessSessionAsync ListBuyerAccessSessionsAsync RevokeBuyerAccessSessionAsync RetrieveHoldAsync BookHoldAsync RetrieveBookingAsync |
Seasons |
83 operations for catalogue and Plan lifecycle, performances and package prices, publishing and checkout tests, sales windows, buyer access and booking, holder imports, holders and Season orders, renewals and hosted renewal links, occurrence amendments, returns and reclaims, bulk refunds and jobs, reports and CSV exports, audit, outbox, and support export |
Full reference: SeatLayer .NET server SDK guide
Frequently asked questions
How do I book seats from a .NET application?
Install the SeatLayer NuGet package, construct a
SeatLayerClient with your secret key, and call Inventory.BookAsync with the hold id and a
stable bookingRef. When your own backend picks the seats (phone orders, box office, comps),
Inventory.BookBestAvailableAsync and Inventory.BoxOfficeBookAsync book outright with no prior
hold. Every booking method requires a booking reference, so each sale is tied to an immutable
order id you can reconcile against later.
What does the server SDK do that the buyer SDK does not?
The buyer SDK runs in the browser or mobile app and only selects and holds seats. This .NET
SDK runs on your trusted server and inspects and books them. Your secret key never reaches a
buyer surface: browsers receive short-lived, origin-bound tokens minted here through
Sessions.CreateManageSessionAsync or Channels.CreateBuyerAccessSessionAsync. Always price a
sale from Inventory.RetrieveHoldAsync, never from values the browser sent you.
How do temporary seat holds work server-side?
A hold reserves seats against concurrent buyers for a limited checkout window. From .NET you
retrieve it with Inventory.RetrieveHoldAsync, whose item-level price, quantity, and currency are
authoritative, and confirm it with Inventory.BookAsync. Use Inventory.ExtendHoldAsync for a long
checkout instead of releasing and re-holding, which would hand the seats to whoever is racing for
them. Booking is a single automatic attempt: after an unknown network outcome you may reconcile
and repeat the exact same event, hold, and bookingRef; seats already booked under that
reference are not sold again.
Can I use my own payment provider?
Yes. This server SDK does not process payment in a Platform/SDK integration. Charge through the
provider you already use, calculating the total from each server-inspected hold item's
unitPrice, quantity, and currency, then call Inventory.BookAsync with your charge or order
id as the bookingRef. Managed Ticketing is a separate product path with organizer-connected
payments. The holds and checkout guide
walks through the full handoff.
Continue your .NET integration
- Follow the .NET server SDK guide for installation, authentication, and the full hold-to-booking flow.
- Handle errors, retries, and safe booking repeats before connecting a production order flow.
- Verify SeatLayer webhooks to react to holds, expiry, and bookings on your server.
- Browse the SeatLayer server API reference for every endpoint behind this SDK.
- Generate clients from the SeatLayer OpenAPI description or explore the raw API surface.
- Point AI coding agents at the SeatLayer docs index
(
llms.txt) for an agent-readable map of the documentation. - Explore every SeatLayer SDK on GitHub across web, mobile, and server.
SeatLayer SDK ecosystem
| Surface | Package or source |
|---|---|
| JavaScript | @seatlayer/js |
| React | @seatlayer/react |
| React Native | @seatlayer/react-native |
| iOS | seatlayer-ios |
| Flutter | seatlayer |
| Android | seatlayer-android |
| Server SDKs | Node.js, Python, PHP, Ruby, .NET, Java, and Go |
| Node.js (server) | @seatlayer/server |
| Python (server) | seatlayer |
| PHP (server) | seatlayer/seatlayer-php |
| Ruby (server) | seatlayer |
| .NET (server) | SeatLayer (this package) |
| Java (server) | io.seatlayer:seatlayer-java |
| Go (server) | github.com/seatlayer/seatlayer-go |
Development
dotnet build # warnings are errors
dotnet test
dotnet pack -c Release
License
MIT
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net8.0 is compatible. net8.0-android was computed. net8.0-browser was computed. net8.0-ios was computed. net8.0-maccatalyst was computed. net8.0-macos was computed. net8.0-tvos was computed. net8.0-windows was computed. net9.0 was computed. net9.0-android was computed. net9.0-browser was computed. net9.0-ios was computed. net9.0-maccatalyst was computed. net9.0-macos was computed. net9.0-tvos was computed. net9.0-windows was computed. net10.0 was computed. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. |
-
net8.0
- No dependencies.
NuGet packages
This package is not used by any NuGet packages.
GitHub repositories
This package is not used by any popular GitHub repositories.