Create markets

An approved app can list its own player-prop markets on STX events: you name the event, the player, the stat and the line, and STX builds the market, settles it from its stats feed and tells you what happened to each one. How it works and how to get access are on List your own markets on STX.

Creating markets needs an app token with the markets.write scope, which STX grants on request, sent from an address on your app’s IP allow-list. An API key or a member token cannot create markets. On an exchange that does not offer it, CreateMarketsAsync throws STXNotAvailableException (markets.create); see What you can do.

1. Give the client your app

Set the app’s client id and secret, and the client mints an app token (the OAuth client_credentials grant) when a call needs one. It keeps the token and mints a new one shortly before it expires. See App tokens for the other ways to pass them.

using STX.Sdk;
using STX.Sdk.Models;

using var writer = new STXClient(new STXClientOptions
{
    Region = STXRegion.US,
    Environment = STXEnvironment.Demo,
    ClientId = configuration["Stx:ClientId"],
    ClientSecret = configuration["Stx:ClientSecret"],
    Scope = "events markets.write",
});

2. Find the event and its players

EventPlayers? players = null;
Event? hockey = null;
await foreach (var e in writer.GetAllEventsAsync(status: "scheduled", sports: ["Hockey"]))
{
    players = await writer.GetEventPlayersAsync(e.EventId!);
    if (players.Teams.Count > 0) { hockey = e; break; }
}
Console.WriteLine($"{hockey!.Title} {hockey.EventId}");
Console.WriteLine(string.Join(", ", players!.StatKeys()));
foreach (var team in players.Teams)
    Console.WriteLine($"{team.Team}: {string.Join(", ", team.Players.Take(2).Select(p => $"{p.PlayerId} {p.Name} {p.Position}"))}");

Sample output:

Buffalo Sabres at San Jose Sharks 3f71fcfc-53fa-4888-b63b-c0d850055ce7
ASSISTS, GOALS, GOAL_SO, POINTS, SAVES
Buffalo Sabres: 3654006 Alex Lyon G, 4063240 Beck Malenstyn LW
San Jose Sharks: 3942868 Adam Gaudette RW, 3114994 Alex Nedeljkovic G

GetEventPlayersAsync(eventId) is the event’s rosters and the stats a market on it can use. Teams is empty until the rosters are published. GetMarketTypesAsync() lists every market type by rule; the ones with PartnerCreate set are the ones you can create, with the fields they take and the stats per event type:

var types = await writer.GetMarketTypesAsync();
foreach (var (rule, type) in types.Where(t => t.Value.PartnerCreate == true))
    Console.WriteLine($"{rule}: {string.Join(", ", type.Fields!.AsObject().Select(f => f.Key))}");
// player_stat_line: line, player_id, stat

It changes only when STX adds a rule or a stat, so read it once and keep it.

3. Check with a dry run

var results = await writer.CreateMarketsAsync(hockey.EventId!,
[
    new STXNewMarket("3654006", "GOAL_SO", 2.5),
    new STXNewMarket("3654006", "ASSISTS", 0.75),
    new STXNewMarket("not-a-player", "GOALS", 0.5),
], dryRun: true);

foreach (var r in results)
    Console.WriteLine($"{r.Index} {r.Status} {r.Reason}");

Sample output:

0 valid
1 rejected invalid_line
2 rejected unknown_player

dryRun: true runs every check on the exchange and creates nothing: a market that would be created comes back valid. A line is a positive number ending in .5; STXNewMarket.IsValidLine(line) checks one.

4. Create

Send the same list without dryRun. Each result is an STXCreateMarketResult with the market’s Index in your list and the Market as you sent it:

Status	Meaning
created	Listed now; MarketId is set
exists	Already listed (by you or anyone); MarketId is set. Resending is always safe
valid	A dry run that would create it
rejected	Not created; Reason says why: invalid_line, unsupported_stat, unknown_player, unsupported_rule, event_not_open, not_created

STXCreateMarketStatus and STXMarketRejectionReason name these values, and Listed is true for created and exists. A rejected market is a result, not an exception, so one bad entry never stops the others. Up to 25 markets go in one call (STXClient.MaxMarketsPerRequest); more throws ArgumentException before anything is sent.

validate: true checks each market against GetEventPlayersAsync first and returns failures as rejected without sending them; it also matches the stat key’s case to the event’s:

var checkedResults = await writer.CreateMarketsAsync(hockey.EventId!,
[
    new STXNewMarket("3654006", "goal_so", 2.5),
    new STXNewMarket("3654006", "HITS", 1.5),
    new STXNewMarket("3654006", "POINTS", 2.0),
], dryRun: true, validate: true);

Console.WriteLine(string.Join(", ", checkedResults.Select(r => $"{r.Status} {r.Reason}".Trim())));
// valid, rejected unsupported_stat, rejected invalid_line

When a call is refused

The whole request can be refused, as an exception:

Exception	When
STXIpNotAllowedException	The call came from an address not on your app’s IP allow-list
STXInsufficientScopeException	The app token lacks markets.write
STXForbiddenException	An API key or a member token
STXNotFoundException	No such event
STXRejectedException	The event is not open for new markets; ErrorCode is event_not_open, unsupported_event or roster_unavailable
STXNotAvailableException	This exchange does not create markets (Feature == "markets.create")
STXConfigException	No app configured: ClientId and ClientSecret are not set

From an address the app does not list, captured on US demo:

STX.Sdk.STXIpNotAllowedException: this app does not allow writes from this IP address
status 403 body {"error":"ip_not_allowed","error_description":"this app does not allow writes from this IP address"}

Reads keep working from any address; only writes are checked. Add the address in STX Apps; see IP allow-list. A create request is never retried after a server error; resend it yourself, which is safe because a market already listed comes back exists.