Prediction Markets API Reference

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query markets($pager: PagerInput, $date_range: DateRangeInput, $opened_at_range: DateRangeInput, $expires_at_range: DateRangeInput, $market_id: String, $event_id: String, $market_venue_id: String, $external_id: String, $is_active: ToggleSwitch, $is_closed: ToggleSwitch, $result: MarketResult, $search: String, $sort: MarketSortInput) { markets(pager: $pager, date_range: $date_range, opened_at_range: $opened_at_range, expires_at_range: $expires_at_range, market_id: $market_id, event_id: $event_id, market_venue_id: $market_venue_id, external_id: $external_id, is_active: $is_active, is_closed: $is_closed, result: $result, search: $search, sort: $sort) { market_id event_id market_venue_id external_id is_active is_closed result opened_at expires_at closed_at resolved_at created_at updated_at title question volume image } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query markets($pager: PagerInput, $date_range: DateRangeInput, $opened_at_range: DateRangeInput, $expires_at_range: DateRangeInput, $market_id: String, $event_id: String, $market_venue_id: String, $external_id: String, $is_active: ToggleSwitch, $is_closed: ToggleSwitch, $result: MarketResult, $search: String, $sort: MarketSortInput) { markets(pager: $pager, date_range: $date_range, opened_at_range: $opened_at_range, expires_at_range: $expires_at_range, market_id: $market_id, event_id: $event_id, market_venue_id: $market_venue_id, external_id: $external_id, is_active: $is_active, is_closed: $is_closed, result: $result, search: $search, sort: $sort) { market_id event_id market_venue_id external_id is_active is_closed result opened_at expires_at closed_at resolved_at created_at updated_at title question volume image } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query markets($pager: PagerInput, $date_range: DateRangeInput, $opened_at_range: DateRangeInput, $expires_at_range: DateRangeInput, $market_id: String, $event_id: String, $market_venue_id: String, $external_id: String, $is_active: ToggleSwitch, $is_closed: ToggleSwitch, $result: MarketResult, $search: String, $sort: MarketSortInput) { markets(pager: $pager, date_range: $date_range, opened_at_range: $opened_at_range, expires_at_range: $expires_at_range, market_id: $market_id, event_id: $event_id, market_venue_id: $market_venue_id, external_id: $external_id, is_active: $is_active, is_closed: $is_closed, result: $result, search: $search, sort: $sort) { market_id event_id market_venue_id external_id is_active is_closed result opened_at expires_at closed_at resolved_at created_at updated_at title question volume image } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query market($market_id: String!) { market(market_id: $market_id) { market_id event_id market_venue_id external_id is_active is_closed result opened_at expires_at closed_at resolved_at created_at updated_at title question volume image } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query market($market_id: String!) { market(market_id: $market_id) { market_id event_id market_venue_id external_id is_active is_closed result opened_at expires_at closed_at resolved_at created_at updated_at title question volume image } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query market($market_id: String!) { market(market_id: $market_id) { market_id event_id market_venue_id external_id is_active is_closed result opened_at expires_at closed_at resolved_at created_at updated_at title question volume image } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query events($pager: PagerInput, $date_range: DateRangeInput, $opened_at_range: DateRangeInput, $expires_at_range: DateRangeInput, $event_id: String, $market_venue_id: String, $external_id: String, $primary_category: PrimaryCategory, $sub_category: SubCategory, $tags: [String!], $tag_match: TagMatch, $is_active: ToggleSwitch, $is_closed: ToggleSwitch, $is_favourite: ToggleSwitch, $sort: EventSortInput) { events(pager: $pager, date_range: $date_range, opened_at_range: $opened_at_range, expires_at_range: $expires_at_range, event_id: $event_id, market_venue_id: $market_venue_id, external_id: $external_id, primary_category: $primary_category, sub_category: $sub_category, tags: $tags, tag_match: $tag_match, is_active: $is_active, is_closed: $is_closed, is_favourite: $is_favourite, sort: $sort) { event_id market_venue_id external_id title primary_category sub_category is_active is_closed opened_at expires_at created_at updated_at tags image description volume markets_count is_favourite price_source price_symbol top_markets { market_id title image probability multiplier_yes multiplier_no result } } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query events($pager: PagerInput, $date_range: DateRangeInput, $opened_at_range: DateRangeInput, $expires_at_range: DateRangeInput, $event_id: String, $market_venue_id: String, $external_id: String, $primary_category: PrimaryCategory, $sub_category: SubCategory, $tags: [String!], $tag_match: TagMatch, $is_active: ToggleSwitch, $is_closed: ToggleSwitch, $is_favourite: ToggleSwitch, $sort: EventSortInput) { events(pager: $pager, date_range: $date_range, opened_at_range: $opened_at_range, expires_at_range: $expires_at_range, event_id: $event_id, market_venue_id: $market_venue_id, external_id: $external_id, primary_category: $primary_category, sub_category: $sub_category, tags: $tags, tag_match: $tag_match, is_active: $is_active, is_closed: $is_closed, is_favourite: $is_favourite, sort: $sort) { event_id market_venue_id external_id title primary_category sub_category is_active is_closed opened_at expires_at created_at updated_at tags image description volume markets_count is_favourite price_source price_symbol top_markets { market_id title image probability multiplier_yes multiplier_no result } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query events($pager: PagerInput, $date_range: DateRangeInput, $opened_at_range: DateRangeInput, $expires_at_range: DateRangeInput, $event_id: String, $market_venue_id: String, $external_id: String, $primary_category: PrimaryCategory, $sub_category: SubCategory, $tags: [String!], $tag_match: TagMatch, $is_active: ToggleSwitch, $is_closed: ToggleSwitch, $is_favourite: ToggleSwitch, $sort: EventSortInput) { events(pager: $pager, date_range: $date_range, opened_at_range: $opened_at_range, expires_at_range: $expires_at_range, event_id: $event_id, market_venue_id: $market_venue_id, external_id: $external_id, primary_category: $primary_category, sub_category: $sub_category, tags: $tags, tag_match: $tag_match, is_active: $is_active, is_closed: $is_closed, is_favourite: $is_favourite, sort: $sort) { event_id market_venue_id external_id title primary_category sub_category is_active is_closed opened_at expires_at created_at updated_at tags image description volume markets_count is_favourite price_source price_symbol top_markets { market_id title image probability multiplier_yes multiplier_no result } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query event($event_id: String!) { event(event_id: $event_id) { event_id market_venue_id external_id title primary_category sub_category is_active is_closed opened_at expires_at created_at updated_at tags image description volume markets_count is_favourite price_source price_symbol top_markets { market_id title image probability multiplier_yes multiplier_no result } } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query event($event_id: String!) { event(event_id: $event_id) { event_id market_venue_id external_id title primary_category sub_category is_active is_closed opened_at expires_at created_at updated_at tags image description volume markets_count is_favourite price_source price_symbol top_markets { market_id title image probability multiplier_yes multiplier_no result } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query event($event_id: String!) { event(event_id: $event_id) { event_id market_venue_id external_id title primary_category sub_category is_active is_closed opened_at expires_at created_at updated_at tags image description volume markets_count is_favourite price_source price_symbol top_markets { market_id title image probability multiplier_yes multiplier_no result } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query category_facets($is_active: ToggleSwitch) { category_facets(is_active: $is_active) { primary_category active_count sub_categories { sub_category active_count } } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query category_facets($is_active: ToggleSwitch) { category_facets(is_active: $is_active) { primary_category active_count sub_categories { sub_category active_count } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query category_facets($is_active: ToggleSwitch) { category_facets(is_active: $is_active) { primary_category active_count sub_categories { sub_category active_count } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query category_volumes { category_volumes { primary_category volume sub_categories { sub_category volume } } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query category_volumes { category_volumes { primary_category volume sub_categories { sub_category volume } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query category_volumes { category_volumes { primary_category volume sub_categories { sub_category volume } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation set_event_favourite($event_id: String!, $is_favourite: ToggleSwitch!) { set_event_favourite(event_id: $event_id, is_favourite: $is_favourite) }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation set_event_favourite($event_id: String!, $is_favourite: ToggleSwitch!) { set_event_favourite(event_id: $event_id, is_favourite: $is_favourite) }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation set_event_favourite($event_id: String!, $is_favourite: ToggleSwitch!) { set_event_favourite(event_id: $event_id, is_favourite: $is_favourite) }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query markets_prices($market_ids: [String], $event_id: String) { markets_prices(market_ids: $market_ids, event_id: $event_id) { market_id yes { bid ask multiplier } no { bid ask multiplier } ts } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query markets_prices($market_ids: [String], $event_id: String) { markets_prices(market_ids: $market_ids, event_id: $event_id) { market_id yes { bid ask multiplier } no { bid ask multiplier } ts } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query markets_prices($market_ids: [String], $event_id: String) { markets_prices(market_ids: $market_ids, event_id: $event_id) { market_id yes { bid ask multiplier } no { bid ask multiplier } ts } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query orderbook($market_id: String!, $outcome_side: OutcomeSide!) { orderbook(market_id: $market_id, outcome_side: $outcome_side) { market_id outcome_side buy { price quantity } sell { price quantity } ts ts_iso best_bid best_ask total_volume } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query orderbook($market_id: String!, $outcome_side: OutcomeSide!) { orderbook(market_id: $market_id, outcome_side: $outcome_side) { market_id outcome_side buy { price quantity } sell { price quantity } ts ts_iso best_bid best_ask total_volume } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query orderbook($market_id: String!, $outcome_side: OutcomeSide!) { orderbook(market_id: $market_id, outcome_side: $outcome_side) { market_id outcome_side buy { price quantity } sell { price quantity } ts ts_iso best_bid best_ask total_volume } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query market_price_history($market_id: String!, $side: OutcomeSide, $range: PriceHistoryRange!) { market_price_history(market_id: $market_id, side: $side, range: $range) { market_id points { ts price multiplier } } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query market_price_history($market_id: String!, $side: OutcomeSide, $range: PriceHistoryRange!) { market_price_history(market_id: $market_id, side: $side, range: $range) { market_id points { ts price multiplier } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query market_price_history($market_id: String!, $side: OutcomeSide, $range: PriceHistoryRange!) { market_price_history(market_id: $market_id, side: $side, range: $range) { market_id points { ts price multiplier } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query event_price_history($event_id: String!, $side: OutcomeSide, $range: PriceHistoryRange!) { event_price_history(event_id: $event_id, side: $side, range: $range) { market_id points { ts price multiplier } } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query event_price_history($event_id: String!, $side: OutcomeSide, $range: PriceHistoryRange!) { event_price_history(event_id: $event_id, side: $side, range: $range) { market_id points { ts price multiplier } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query event_price_history($event_id: String!, $side: OutcomeSide, $range: PriceHistoryRange!) { event_price_history(event_id: $event_id, side: $side, range: $range) { market_id points { ts price multiplier } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query event_top_markets_price_history($event_id: String!, $side: OutcomeSide, $range: PriceHistoryRange!) { event_top_markets_price_history(event_id: $event_id, side: $side, range: $range) { market_id points { ts price multiplier } } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query event_top_markets_price_history($event_id: String!, $side: OutcomeSide, $range: PriceHistoryRange!) { event_top_markets_price_history(event_id: $event_id, side: $side, range: $range) { market_id points { ts price multiplier } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query event_top_markets_price_history($event_id: String!, $side: OutcomeSide, $range: PriceHistoryRange!) { event_top_markets_price_history(event_id: $event_id, side: $side, range: $range) { market_id points { ts price multiplier } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query crypto_price_history($event_id: String!, $range: PriceHistoryRange!) { crypto_price_history(event_id: $event_id, range: $range) { ts open high low close volume closed } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query crypto_price_history($event_id: String!, $range: PriceHistoryRange!) { crypto_price_history(event_id: $event_id, range: $range) { ts open high low close volume closed } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query crypto_price_history($event_id: String!, $range: PriceHistoryRange!) { crypto_price_history(event_id: $event_id, range: $range) { ts open high low close volume closed } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query order_limitations($market_id: String!) { order_limitations(market_id: $market_id) { market_id tradeable min_size } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query order_limitations($market_id: String!) { order_limitations(market_id: $market_id) { market_id tradeable min_size } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query order_limitations($market_id: String!) { order_limitations(market_id: $market_id) { market_id tradeable min_size } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query estimate_order($market_id: String!, $outcome_side: OutcomeSide!, $side: Side!, $shares: Float, $amount: Float) { estimate_order(market_id: $market_id, outcome_side: $outcome_side, side: $side, shares: $shares, amount: $amount) { market_id outcome_side side shares price notional fee fee_currency_id total } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query estimate_order($market_id: String!, $outcome_side: OutcomeSide!, $side: Side!, $shares: Float, $amount: Float) { estimate_order(market_id: $market_id, outcome_side: $outcome_side, side: $side, shares: $shares, amount: $amount) { market_id outcome_side side shares price notional fee fee_currency_id total } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query estimate_order($market_id: String!, $outcome_side: OutcomeSide!, $side: Side!, $shares: Float, $amount: Float) { estimate_order(market_id: $market_id, outcome_side: $outcome_side, side: $side, shares: $shares, amount: $amount) { market_id outcome_side side shares price notional fee fee_currency_id total } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation create_order($market_id: String!, $outcome_side: OutcomeSide!, $side: Side!, $shares: Float, $amount: Float, $wallet_id: String) { create_order(market_id: $market_id, outcome_side: $outcome_side, side: $side, shares: $shares, amount: $amount, wallet_id: $wallet_id) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation create_order($market_id: String!, $outcome_side: OutcomeSide!, $side: Side!, $shares: Float, $amount: Float, $wallet_id: String) { create_order(market_id: $market_id, outcome_side: $outcome_side, side: $side, shares: $shares, amount: $amount, wallet_id: $wallet_id) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation create_order($market_id: String!, $outcome_side: OutcomeSide!, $side: Side!, $shares: Float, $amount: Float, $wallet_id: String) { create_order(market_id: $market_id, outcome_side: $outcome_side, side: $side, shares: $shares, amount: $amount, wallet_id: $wallet_id) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query open_orders($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $side: Side, $status: OrderStatus) { open_orders(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, side: $side, status: $status) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query open_orders($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $side: Side, $status: OrderStatus) { open_orders(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, side: $side, status: $status) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query open_orders($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $side: Side, $status: OrderStatus) { open_orders(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, side: $side, status: $status) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query closed_orders($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $side: Side, $status: OrderStatus) { closed_orders(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, side: $side, status: $status) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query closed_orders($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $side: Side, $status: OrderStatus) { closed_orders(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, side: $side, status: $status) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query closed_orders($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $side: Side, $status: OrderStatus) { closed_orders(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, side: $side, status: $status) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query order($order_id: String!) { order(order_id: $order_id) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query order($order_id: String!) { order(order_id: $order_id) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query order($order_id: String!) { order(order_id: $order_id) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query trades($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $order_id: String) { trades(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, order_id: $order_id) { trade_id user_id currency_id shares price order_id market_id event_id side outcome_side created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query trades($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $order_id: String) { trades(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, order_id: $order_id) { trade_id user_id currency_id shares price order_id market_id event_id side outcome_side created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query trades($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $order_id: String) { trades(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, order_id: $order_id) { trade_id user_id currency_id shares price order_id market_id event_id side outcome_side created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query trade($trade_id: String!) { trade(trade_id: $trade_id) { trade_id user_id currency_id shares price order_id market_id event_id side outcome_side created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query trade($trade_id: String!) { trade(trade_id: $trade_id) { trade_id user_id currency_id shares price order_id market_id event_id side outcome_side created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query trade($trade_id: String!) { trade(trade_id: $trade_id) { trade_id user_id currency_id shares price order_id market_id event_id side outcome_side created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query user_positions($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $event_id: String, $currency_id: String, $outcome_side: OutcomeSide, $wallet_id: String, $search: String, $status: PositionStatus, $sort: UserPositionSortInput) { user_positions(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, event_id: $event_id, currency_id: $currency_id, outcome_side: $outcome_side, wallet_id: $wallet_id, search: $search, status: $status, sort: $sort) { position_id user_id currency_id shares avg_price invested realized_pnl status market_id event_id outcome_side wallet_id created_at updated_at market_title event_title } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query user_positions($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $event_id: String, $currency_id: String, $outcome_side: OutcomeSide, $wallet_id: String, $search: String, $status: PositionStatus, $sort: UserPositionSortInput) { user_positions(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, event_id: $event_id, currency_id: $currency_id, outcome_side: $outcome_side, wallet_id: $wallet_id, search: $search, status: $status, sort: $sort) { position_id user_id currency_id shares avg_price invested realized_pnl status market_id event_id outcome_side wallet_id created_at updated_at market_title event_title } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query user_positions($pager: PagerInput, $date_range: DateRangeInput, $user_id: String, $market_id: String, $event_id: String, $currency_id: String, $outcome_side: OutcomeSide, $wallet_id: String, $search: String, $status: PositionStatus, $sort: UserPositionSortInput) { user_positions(pager: $pager, date_range: $date_range, user_id: $user_id, market_id: $market_id, event_id: $event_id, currency_id: $currency_id, outcome_side: $outcome_side, wallet_id: $wallet_id, search: $search, status: $status, sort: $sort) { position_id user_id currency_id shares avg_price invested realized_pnl status market_id event_id outcome_side wallet_id created_at updated_at market_title event_title } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query user_position($position_id: String, $market_id: String, $outcome_side: OutcomeSide, $wallet_id: String) { user_position(position_id: $position_id, market_id: $market_id, outcome_side: $outcome_side, wallet_id: $wallet_id) { position_id user_id currency_id shares avg_price invested realized_pnl status market_id event_id outcome_side wallet_id created_at updated_at market_title event_title } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query user_position($position_id: String, $market_id: String, $outcome_side: OutcomeSide, $wallet_id: String) { user_position(position_id: $position_id, market_id: $market_id, outcome_side: $outcome_side, wallet_id: $wallet_id) { position_id user_id currency_id shares avg_price invested realized_pnl status market_id event_id outcome_side wallet_id created_at updated_at market_title event_title } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query user_position($position_id: String, $market_id: String, $outcome_side: OutcomeSide, $wallet_id: String) { user_position(position_id: $position_id, market_id: $market_id, outcome_side: $outcome_side, wallet_id: $wallet_id) { position_id user_id currency_id shares avg_price invested realized_pnl status market_id event_id outcome_side wallet_id created_at updated_at market_title event_title } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query user_positions_stats($user_id: String, $market_id: String, $event_id: String, $currency_id: String, $outcome_side: OutcomeSide, $wallet_id: String, $status: PositionStatus) { user_positions_stats(user_id: $user_id, market_id: $market_id, event_id: $event_id, currency_id: $currency_id, outcome_side: $outcome_side, wallet_id: $wallet_id, status: $status) { total_positions total_shares total_invested total_realized_pnl } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query user_positions_stats($user_id: String, $market_id: String, $event_id: String, $currency_id: String, $outcome_side: OutcomeSide, $wallet_id: String, $status: PositionStatus) { user_positions_stats(user_id: $user_id, market_id: $market_id, event_id: $event_id, currency_id: $currency_id, outcome_side: $outcome_side, wallet_id: $wallet_id, status: $status) { total_positions total_shares total_invested total_realized_pnl } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query user_positions_stats($user_id: String, $market_id: String, $event_id: String, $currency_id: String, $outcome_side: OutcomeSide, $wallet_id: String, $status: PositionStatus) { user_positions_stats(user_id: $user_id, market_id: $market_id, event_id: $event_id, currency_id: $currency_id, outcome_side: $outcome_side, wallet_id: $wallet_id, status: $status) { total_positions total_shares total_invested total_realized_pnl } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query vako_transactions($transaction_id: String, $user_id: String, $currency_id: String, $wallet_id: String, $type: AccountTransactionType, $order_id: String, $position_id: String, $transaction_class: AccountTransactionClass, $status: VakoTransactionStatus, $approval_status: ApprovalStatus, $approved_by: String, $version: Int, $pager: PagerInput, $date_range: DateRangeInput, $sort: SortInput) { vako_transactions(transaction_id: $transaction_id, user_id: $user_id, currency_id: $currency_id, wallet_id: $wallet_id, type: $type, order_id: $order_id, position_id: $position_id, transaction_class: $transaction_class, status: $status, approval_status: $approval_status, approved_by: $approved_by, version: $version, pager: $pager, date_range: $date_range, sort: $sort) { transaction_id user_id currency_id wallet_id type order_id position_id transaction_class amount status approval_status approved_by error_message version created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query vako_transactions($transaction_id: String, $user_id: String, $currency_id: String, $wallet_id: String, $type: AccountTransactionType, $order_id: String, $position_id: String, $transaction_class: AccountTransactionClass, $status: VakoTransactionStatus, $approval_status: ApprovalStatus, $approved_by: String, $version: Int, $pager: PagerInput, $date_range: DateRangeInput, $sort: SortInput) { vako_transactions(transaction_id: $transaction_id, user_id: $user_id, currency_id: $currency_id, wallet_id: $wallet_id, type: $type, order_id: $order_id, position_id: $position_id, transaction_class: $transaction_class, status: $status, approval_status: $approval_status, approved_by: $approved_by, version: $version, pager: $pager, date_range: $date_range, sort: $sort) { transaction_id user_id currency_id wallet_id type order_id position_id transaction_class amount status approval_status approved_by error_message version created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query vako_transactions($transaction_id: String, $user_id: String, $currency_id: String, $wallet_id: String, $type: AccountTransactionType, $order_id: String, $position_id: String, $transaction_class: AccountTransactionClass, $status: VakoTransactionStatus, $approval_status: ApprovalStatus, $approved_by: String, $version: Int, $pager: PagerInput, $date_range: DateRangeInput, $sort: SortInput) { vako_transactions(transaction_id: $transaction_id, user_id: $user_id, currency_id: $currency_id, wallet_id: $wallet_id, type: $type, order_id: $order_id, position_id: $position_id, transaction_class: $transaction_class, status: $status, approval_status: $approval_status, approved_by: $approved_by, version: $version, pager: $pager, date_range: $date_range, sort: $sort) { transaction_id user_id currency_id wallet_id type order_id position_id transaction_class amount status approval_status approved_by error_message version created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation recompute_categories { recompute_categories { total updated uncategorized_active } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation recompute_categories { recompute_categories { total updated uncategorized_active } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation recompute_categories { recompute_categories { total updated uncategorized_active } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation update_order($order_id: String!, $price: Float, $shares: Float, $executed_quantity: Float, $remaining_quantity: Float, $status: OrderStatus) { update_order(order_id: $order_id, price: $price, shares: $shares, executed_quantity: $executed_quantity, remaining_quantity: $remaining_quantity, status: $status) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation update_order($order_id: String!, $price: Float, $shares: Float, $executed_quantity: Float, $remaining_quantity: Float, $status: OrderStatus) { update_order(order_id: $order_id, price: $price, shares: $shares, executed_quantity: $executed_quantity, remaining_quantity: $remaining_quantity, status: $status) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation update_order($order_id: String!, $price: Float, $shares: Float, $executed_quantity: Float, $remaining_quantity: Float, $status: OrderStatus) { update_order(order_id: $order_id, price: $price, shares: $shares, executed_quantity: $executed_quantity, remaining_quantity: $remaining_quantity, status: $status) { order_id user_id side market_id event_id outcome_side status executed_quantity remaining_quantity price shares version wallet_id created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation cancel_order($order_id: String!, $reason: String!) { cancel_order(order_id: $order_id, reason: $reason) }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation cancel_order($order_id: String!, $reason: String!) { cancel_order(order_id: $order_id, reason: $reason) }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation cancel_order($order_id: String!, $reason: String!) { cancel_order(order_id: $order_id, reason: $reason) }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query market_venues($pager: PagerInput, $date_range: DateRangeInput, $market_venue_id: String, $search: String, $venue_kind: VenueKind, $mode: MarketVenueMode, $is_active: ToggleSwitch, $hedging_enabled: ToggleSwitch) { market_venues(pager: $pager, date_range: $date_range, market_venue_id: $market_venue_id, search: $search, venue_kind: $venue_kind, mode: $mode, is_active: $is_active, hedging_enabled: $hedging_enabled) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query market_venues($pager: PagerInput, $date_range: DateRangeInput, $market_venue_id: String, $search: String, $venue_kind: VenueKind, $mode: MarketVenueMode, $is_active: ToggleSwitch, $hedging_enabled: ToggleSwitch) { market_venues(pager: $pager, date_range: $date_range, market_venue_id: $market_venue_id, search: $search, venue_kind: $venue_kind, mode: $mode, is_active: $is_active, hedging_enabled: $hedging_enabled) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query market_venues($pager: PagerInput, $date_range: DateRangeInput, $market_venue_id: String, $search: String, $venue_kind: VenueKind, $mode: MarketVenueMode, $is_active: ToggleSwitch, $hedging_enabled: ToggleSwitch) { market_venues(pager: $pager, date_range: $date_range, market_venue_id: $market_venue_id, search: $search, venue_kind: $venue_kind, mode: $mode, is_active: $is_active, hedging_enabled: $hedging_enabled) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query market_venue($market_venue_id: String!) { market_venue(market_venue_id: $market_venue_id) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query market_venue($market_venue_id: String!) { market_venue(market_venue_id: $market_venue_id) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query market_venue($market_venue_id: String!) { market_venue(market_venue_id: $market_venue_id) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation create_market_venue($venue_name: String!, $venue_kind: VenueKind!, $service_url: String, $service_api_key: String, $broker_user_id: String, $mode: MarketVenueMode, $is_active: ToggleSwitch, $hedging_enabled: ToggleSwitch, $meta: String) { create_market_venue(venue_name: $venue_name, venue_kind: $venue_kind, service_url: $service_url, service_api_key: $service_api_key, broker_user_id: $broker_user_id, mode: $mode, is_active: $is_active, hedging_enabled: $hedging_enabled, meta: $meta) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation create_market_venue($venue_name: String!, $venue_kind: VenueKind!, $service_url: String, $service_api_key: String, $broker_user_id: String, $mode: MarketVenueMode, $is_active: ToggleSwitch, $hedging_enabled: ToggleSwitch, $meta: String) { create_market_venue(venue_name: $venue_name, venue_kind: $venue_kind, service_url: $service_url, service_api_key: $service_api_key, broker_user_id: $broker_user_id, mode: $mode, is_active: $is_active, hedging_enabled: $hedging_enabled, meta: $meta) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation create_market_venue($venue_name: String!, $venue_kind: VenueKind!, $service_url: String, $service_api_key: String, $broker_user_id: String, $mode: MarketVenueMode, $is_active: ToggleSwitch, $hedging_enabled: ToggleSwitch, $meta: String) { create_market_venue(venue_name: $venue_name, venue_kind: $venue_kind, service_url: $service_url, service_api_key: $service_api_key, broker_user_id: $broker_user_id, mode: $mode, is_active: $is_active, hedging_enabled: $hedging_enabled, meta: $meta) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation update_market_venue($market_venue_id: String!, $venue_name: String, $service_url: String, $service_api_key: String, $broker_user_id: String, $mode: MarketVenueMode, $is_active: ToggleSwitch, $hedging_enabled: ToggleSwitch, $meta: String) { update_market_venue(market_venue_id: $market_venue_id, venue_name: $venue_name, service_url: $service_url, service_api_key: $service_api_key, broker_user_id: $broker_user_id, mode: $mode, is_active: $is_active, hedging_enabled: $hedging_enabled, meta: $meta) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation update_market_venue($market_venue_id: String!, $venue_name: String, $service_url: String, $service_api_key: String, $broker_user_id: String, $mode: MarketVenueMode, $is_active: ToggleSwitch, $hedging_enabled: ToggleSwitch, $meta: String) { update_market_venue(market_venue_id: $market_venue_id, venue_name: $venue_name, service_url: $service_url, service_api_key: $service_api_key, broker_user_id: $broker_user_id, mode: $mode, is_active: $is_active, hedging_enabled: $hedging_enabled, meta: $meta) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation update_market_venue($market_venue_id: String!, $venue_name: String, $service_url: String, $service_api_key: String, $broker_user_id: String, $mode: MarketVenueMode, $is_active: ToggleSwitch, $hedging_enabled: ToggleSwitch, $meta: String) { update_market_venue(market_venue_id: $market_venue_id, venue_name: $venue_name, service_url: $service_url, service_api_key: $service_api_key, broker_user_id: $broker_user_id, mode: $mode, is_active: $is_active, hedging_enabled: $hedging_enabled, meta: $meta) { market_venue_id venue_name venue_kind service_url broker_user_id mode is_active hedging_enabled meta created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation delete_market_venue($market_venue_id: String!) { delete_market_venue(market_venue_id: $market_venue_id) }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation delete_market_venue($market_venue_id: String!) { delete_market_venue(market_venue_id: $market_venue_id) }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation delete_market_venue($market_venue_id: String!) { delete_market_venue(market_venue_id: $market_venue_id) }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query prediction_limit_groups($pager: PagerInput, $prediction_limit_group_id: String, $search: String, $kyc_status: KycStatus, $trading_enabled: ToggleSwitch) { prediction_limit_groups(pager: $pager, prediction_limit_group_id: $prediction_limit_group_id, search: $search, kyc_status: $kyc_status, trading_enabled: $trading_enabled) { rows { prediction_limit_group_id name description kyc_status trading_enabled meta created_at updated_at } total } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query prediction_limit_groups($pager: PagerInput, $prediction_limit_group_id: String, $search: String, $kyc_status: KycStatus, $trading_enabled: ToggleSwitch) { prediction_limit_groups(pager: $pager, prediction_limit_group_id: $prediction_limit_group_id, search: $search, kyc_status: $kyc_status, trading_enabled: $trading_enabled) { rows { prediction_limit_group_id name description kyc_status trading_enabled meta created_at updated_at } total } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query prediction_limit_groups($pager: PagerInput, $prediction_limit_group_id: String, $search: String, $kyc_status: KycStatus, $trading_enabled: ToggleSwitch) { prediction_limit_groups(pager: $pager, prediction_limit_group_id: $prediction_limit_group_id, search: $search, kyc_status: $kyc_status, trading_enabled: $trading_enabled) { rows { prediction_limit_group_id name description kyc_status trading_enabled meta created_at updated_at } total } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query prediction_limit_group($prediction_limit_group_id: String!) { prediction_limit_group(prediction_limit_group_id: $prediction_limit_group_id) { prediction_limit_group_id name description kyc_status trading_enabled meta created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query prediction_limit_group($prediction_limit_group_id: String!) { prediction_limit_group(prediction_limit_group_id: $prediction_limit_group_id) { prediction_limit_group_id name description kyc_status trading_enabled meta created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query prediction_limit_group($prediction_limit_group_id: String!) { prediction_limit_group(prediction_limit_group_id: $prediction_limit_group_id) { prediction_limit_group_id name description kyc_status trading_enabled meta created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'http://localhost:3000/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation create_prediction_limit_group($name: String!, $description: String, $kyc_status: KycStatus, $trading_enabled: ToggleSwitch, $meta: String) { create_prediction_limit_group(name: $name, description: $description, kyc_status: $kyc_status, trading_enabled: $trading_enabled, meta: $meta) { prediction_limit_group_id name description kyc_status trading_enabled meta created_at updated_at } }","variables":{}}'

import requests

url = "http://localhost:3000/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation create_prediction_limit_group($name: String!, $description: String, $kyc_status: KycStatus, $trading_enabled: ToggleSwitch, $meta: String) { create_prediction_limit_group(name: $name, description: $description, kyc_status: $kyc_status, trading_enabled: $trading_enabled, meta: $meta) { prediction_limit_group_id name description kyc_status trading_enabled meta created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("http://localhost:3000/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation create_prediction_limit_group($name: String!, $description: String, $kyc_status: KycStatus, $trading_enabled: ToggleSwitch, $meta: String) { create_prediction_limit_group(name: $name, description: $description, kyc_status: $kyc_status, trading_enabled: $trading_enabled, meta: $meta) { prediction_limit_group_id name description kyc_status trading_enabled meta created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);