Partake API Documentation

Introduction

Partake exposes a GraphQL schema over HTTP. You choose the fields and relationships your integration needs, and the server returns a JSON response with data, errors, or both.

Protocol

GraphQL over HTTPS

Public access

Read queries

Response format

JSON

The schema is evolving. Ask only for fields you use, treat nullable fields as genuinely nullable, and tolerate additive fields or enum values.

Making requests

Send an HTTP POST with a JSON body. The body may contain a query string, a variables object, and an optional operationName.

Request contract

Part	Value	Required
Method	`POST`	Yes
Header	`Content-Type: application/json`	Yes
Body	`{ query, variables?, operationName? }`	Yes

Minimal request

cURL

curl https://api.partake.gg/ \
  -H "Content-Type: application/json" \
  --data '{
    "query": "query { games(limit: 10) { id name } }"
  }'

Request with variables

JavaScript

const query = `
  query Team($id: Int!) {
    team(id: $id) {
      id
      name
      handle
      description
      followerCount
    }
  }
`;

const response = await fetch("https://api.partake.gg/", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ query, variables: { id: 1 } })
});

const result = await response.json();

if (result.errors) {
  console.error(result.errors);
}

console.log(result.data?.team);

Core queries

These examples use fields and arguments from Partake's current production schema. Copy the smallest useful query, then adapt its selection set to your product.

Upcoming events

Filter by date, game, location, team, tags, or age rating. Use STARTS_AT_ASC for a chronological discovery feed.

Upcoming events

GraphQL

query UpcomingEvents(
  $startsAfter: DateTime!
  $game: String
  $limit: Int = 20
  $offset: Int = 0
) {
  events(
    startsBetween: { start: $startsAfter }
    game: $game
    sortBy: STARTS_AT_ASC
    limit: $limit
    offset: $offset
  ) {
    id
    title
    startsAt
    endsAt
    location
    tags
    game { id name }
    team { id name handle iconUrl }
  }
}

One event

Event IDs are integers. Related game and team fields can be selected in the same request.

Event details

GraphQL

query EventDetails($id: Int!) {
  event(id: $id) {
    id
    title
    description
    startsAt
    endsAt
    ageRating
    location
    tags
    attendeeCount
    game { id name }
    team { id name handle }
  }
}

Teams and profiles

Fetch a team by integer ID and a public member profile by its handle. Public profile fields may be absent.

Community profiles

GraphQL

query CommunityProfiles($teamId: Int!, $handle: String!) {
  team(id: $teamId) {
    id
    name
    handle
    description
    followerCount
    websiteUrl
    discordUrl
  }

  userByHandle(handle: $handle) {
    id
    slug
    displayName
    description
    avatar
  }
}

Authentication

Public read queries do not require an Authorization header.

Partake does not currently offer a supported public flow for third-party user authorisation or write access. Mutations used by the Partake web application are not a public integration contract.

Do not ask users for browser cookies, access tokens, or other Partake credentials. Do not embed private credentials in client code. If your integration genuinely needs authenticated access, discuss the use case with the Partake team before building it.

Discuss an integration on Discord ↗

Pagination & limits

Collection queries generally accept limit and offset arguments, but defaults vary by resource. Set both explicitly so your integration behaves predictably.

Start with offset: 0 and a modest limit.
Request the next page by increasing offset by the number of items received.
Stop when a response contains fewer items than the requested limit.

No guaranteed quota or SLA

Partake does not publish a fixed global request quota. Cache suitable data, avoid rapid polling, coalesce duplicate requests, and request only the fields you display. Traffic that degrades the service may be throttled or blocked.

Errors

GraphQL can return HTTP 200 while reporting operation-level errors. Always inspect the errors array as well as data.

GraphQL error shape

JSON

{
  "data": { "event": null },
  "errors": [
    {
      "message": "The requested operation could not be completed.",
      "path": ["event"],
      "extensions": { "code": "..." }
    }
  ]
}

Condition	How to respond
Network or non-2xx response	Retry later with bounded backoff.
Validation error	Correct the query or variables; do not retry unchanged.
Partial data with errors	Use safe fields and surface or log the failed path.

Acceptable use

The API exists to help people find and participate in community activity. Use it in ways that preserve that purpose.

Use public data to add clear value for Partake communities and members.
Respect user intent, attribution, and any content that is removed or made unavailable.
Do not attempt to access private data, bypass safeguards, or reverse-engineer private credentials.
Do not spam, harass, profile, or discriminate against people using Partake data.
Do not present your product as official or endorsed by Partake without written permission.
Do not resell raw Partake data or operate a substitute bulk dataset.
Do not disrupt the API, evade restrictions, or send traffic that threatens service reliability.

Partake may restrict access that violates these rules or harms the service or community. These API rules sit alongside the Partake Guidelines and Privacy Policy.