SeatLayer 0.9.0

dotnet add package SeatLayer --version 0.9.0
                    
NuGet\Install-Package SeatLayer -Version 0.9.0
                    
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="SeatLayer" Version="0.9.0" />
                    
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="SeatLayer" Version="0.9.0" />
                    
Directory.Packages.props
<PackageReference Include="SeatLayer" />
                    
Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add SeatLayer --version 0.9.0
                    
#r "nuget: SeatLayer, 0.9.0"
                    
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package SeatLayer@0.9.0
                    
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=SeatLayer&version=0.9.0
                    
Install as a Cake Addin
#tool nuget:?package=SeatLayer&version=0.9.0
                    
Install as a Cake Tool

SeatLayer .NET Server SDK for Reserved Seating

CI NuGet License: MIT

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-america
  • asia-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.ready is sent once. On a draft, PublishSeasonAsync turns it on. season.block.released is sent once a release has run.
  • In block mode, a date cancel (CreateSeasonAmendmentAsync, kind cancel) or MarkSeasonPerformancePastAsync first takes the date off every season seat. Until that finishes the answer is a 202: check it with SeasonsService.IsDateLeavePending(answer), then send the same request again after Retry-After.
  • Refusals come through SeatLayerException with Code, and nothing changes. For example 409 season_block_packages (more than one package), 409 season_block_on_sale (sales have opened), or 409 block_not_ready from OpenSeasonSalesAsync before 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 notFreeOnEveryDate with reason channel.

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, and ReleaseSeasonLapsedOffersAsync
  • Holders.UpdateHolderAsync, Holders.CreateHolderTransferAsync, Holders.CreateHolderReturnAsync, Holders.CreateHolderRenewalCheckoutAsync, Orders.RefundEventOrderAsync, and Orders.CancelEventOrderAsync
  • EventSeries.CreateEventSeriesAsync, EventSeries.AddEventSeriesDatesAsync, and EventSeries.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

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 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. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.
  • 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.

Version Downloads Last Updated
0.9.0 97 11/11/2026
0.8.0 152 9/10/2026
0.7.0 135 8/30/2026
0.6.1 135 8/25/2026
0.6.0 147 8/23/2026
0.5.0 133 8/21/2026
0.4.0 139 8/17/2026
0.3.0 126 8/13/2026
0.2.0 129 8/12/2026
0.1.0 133 8/7/2026