> ## Documentation Index
> Fetch the complete documentation index at: https://docs.trdrs.co/llms.txt
> Use this file to discover all available pages before exploring further.

# List evaluation programs

> Returns the published evaluation programs open for enrollment.

**Preview: outside the additive-only guarantee.** These shapes will change when challenges are rebuilt, so read them but don't build on them.

**Served only where the engine runs with `CHALLENGES_ENABLED`.** Without it, these routes don't exist, and every path here answers `404`.

Requires a signed-in session.



## OpenAPI

````yaml /api/openapi.json get /api/challenges
openapi: 3.1.0
info:
  title: trdrs Engine API
  version: 1.1.0
  description: >-
    ## API Reference


    Every route the trdrs engine serves, with what to send and what comes back.
    It covers market

    data and news, trading and account state for a trader's own software, the
    Connect API a Connect

    app's backend calls and the Connect dashboard's routes, Connect
    pre-registration, the statements

    that carry a Connect account between environments, the venue routes a prop
    firm or brokerage runs its

    accounts through, and a trader's own challenges.


    Start with the Quickstart for your first call. The API standards hold the
    rules every route

    shares: keys, errors, rate limits, idempotency, paging and streaming.
servers:
  - url: https://app.trdrs.co
    description: Production
  - url: /
    description: This engine
security: []
tags:
  - name: Venue platform preview
    description: >-
      Run your venue: its providers, instruments, conditions, groups, routes,
      stages, venue rules, keys, accounts, usage, balance receipts and webhooks.
      These routes are in preview. They are served on the sandbox to every
      venue, and production access is arranged when a venue qualifies. Every
      route here under `/api/venues/` takes a Venue key. The back office reaches
      the same routes under `/api/back-office/` with a verified owner’s session,
      because the Venue key stays on your server, and both run the same checks.
      The team’s routes under `/api/organizations` serve the back office and the
      Connect dashboard alike, since one organization can run venues and Connect
      apps with one team. Changes to these routes are additive only from here
      on.
  - name: Market data
    description: >-
      Search and look up symbols, read price history and quotes, check the
      server clock, and stream live bars. Crypto prices come from each
      provider’s public feed. Futures prices are licensed to each user and
      stream only from that trader’s own futures source: a login on their
      venue’s production Rithmic system, under their own market data
      subscription. A Rithmic Test login carries no market data. Without a
      source, a futures request answers 503 `feed_requires_connection` and the
      symbol search lists no futures.
  - name: News
    description: >-
      Market news and the economic calendar, from licensed and open sources,
      tagged with futures roots as they arrive. The content is the same for
      everyone, and these routes admit the same callers as market data: a
      licensed origin, a session or a Trading API key. Page headlines by publish
      time, filter them by instrument root, and stream them live over
      server-sent events. Thumbnails come through the image route.
  - name: Trading
    description: >-
      Place, change and cancel orders, set a position’s exits, and close or
      flatten positions. Every call that places an order takes a `clientOrderId`
      as its idempotency key.
  - name: Account
    description: >-
      Read an account a trader can trade: its balance, positions, working
      orders, fills, profit and loss history, and the live account stream. You
      don’t create accounts here. A trader connects their own account at a
      provider, or opens their own Demo on the paper book, in the trdrs app. A
      venue issues accounts on the paper book with Issue an account into a
      group, and a venue pre-registers accounts at a provider through Connect
      with Pre-register a trader’s account.
  - name: Connect
    description: >-
      Connect is the account picker a trader opens: in the trdrs app, where it
      lists the built-in providers and every listed venue, and in hosted Connect
      on a Connect app’s website, where it lists the tiles the app chose. The
      pre-registration routes let a venue fill Connect in the trdrs app ahead of
      time, for a trader who signs in to trdrs. You tell trdrs that a trader has
      an account at a built-in provider: their sign-in email, and optionally the
      account number and login name. When that trader signs in, Connect shows
      the account ready to link, and they sign in to the provider themselves,
      once. The trader types their own password, and access starts when their
      own login succeeds. You can list who you pre-registered and who has
      linked, and cancel a pre-registration that hasn’t been used. A
      pre-registration expires after 30 days, and sending it again refreshes it.
      These routes take the pre-registration key. The whole flow is in the
      **[Quick Start](/docs/guides/quick-start)**.
  - name: Connect apps preview
    description: >-
      Run a Connect app: your own trading interface, whose traders connect their
      accounts in hosted Connect on your website and trade them on your screens.
      The Connect API is what your backend calls with your app’s API key: Create
      a Connect link, read and close it, and the account, market and trading
      routes with your trader named in `x-trdrs-trader`. Hosted Connect calls
      its own routes with the frame session a Connect link opens. The Connect
      dashboard calls the rest with your Connect sign-in session: your apps,
      each app’s name and logo, API keys, websites, tiles, white-label paper and
      Demos, traders and active traders, invoices, conformance runs and its
      Connect pass. These routes are in preview, served on the sandbox, where
      they are free. Once production opens to Connect apps, it serves the route
      that records an app’s Connect pass, which opens the app’s production.
  - name: Connect accounts
    description: >-
      A Connect client's team signs in to the Connect dashboard with a Connect
      account of its own, never a trader's, and one login reaches both
      environments. Production answers a short statement for the signed-in
      account, naming its verified email and the Connect apps it owns, and
      sandbox exchanges it for a sandbox session and the counterpart app of
      each: the sandbox app that stands for the production one. The environments
      share no credential: production signs the statement with its own key, and
      sandbox checks it with production's public key alone. These routes take
      the Connect dashboard's own session, from the dashboard's origin; a
      trader's session and every key are refused, and a Connect account's
      session reaches no trading, account, market or AI route.
  - name: Challenges
    description: >-
      These routes list evaluation programs and a trader’s own enrollments.
      **Preview: the one group in this reference outside the additive-only
      guarantee.** Their shapes will change when challenges are rebuilt; see
      Stability. **They take a signed-in session, not a key**, and are served
      only where the engine runs with `CHALLENGES_ENABLED`. Without it, the
      routes don’t exist and every one answers `404`. The administration half
      isn’t documented here, because it is trdrs’s own tooling, not part of the
      API.
paths:
  /api/challenges:
    get:
      tags:
        - Challenges
      summary: List evaluation programs
      description: >-
        Returns the published evaluation programs open for enrollment.


        **Preview: outside the additive-only guarantee.** These shapes will
        change when challenges are rebuilt, so read them but don't build on
        them.


        **Served only where the engine runs with `CHALLENGES_ENABLED`.** Without
        it, these routes don't exist, and every path here answers `404`.


        Requires a signed-in session.
      responses:
        '200':
          description: The programs open for enrollment.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ChallengesResponse'
        '404':
          description: '`CHALLENGES_ENABLED` is off, so the route doesn’t exist.'
      security:
        - sessionCookie: []
      x-codeSamples:
        - lang: javascript
          label: TypeScript
          source: >-
            // Runs in a signed-in trdrs session, which sends its cookie. An API
            key cannot call this route.

            const res = await fetch('https://app.trdrs.co/api/challenges', {
              credentials: 'include',
            })

            const data = await res.json()
        - lang: shell
          label: cURL
          source: |-
            curl 'https://app.trdrs.co/api/challenges' \
              -b "session=$TRDRS_SESSION"
components:
  schemas:
    ChallengesResponse:
      type: object
      description: The programs open to you.
      properties:
        challenges:
          type: array
          items:
            $ref: '#/components/schemas/WireChallenge'
          description: The programs.
      required:
        - challenges
      example:
        challenges:
          - id: 3f8a1c2e-9b47-4d10-a3fe-2c61b7c90d84
            name: 50K Evaluation
            description: Two-stage evaluation on a 50K account.
            isActive: true
            stage: 1
            nextChallengeId: 8d2f5a90-1e4b-4c7a-9f3d-6b0a8c4e2f17
            allowedTypes:
              - standard
            accountSizes:
              - 50000
            currency: USD
            priceCents: 0
            sizes:
              - size: 50000
                venueId: 5b1d7e20-3c4a-4f8e-9d21-7a6c0b3e9f42
                groupId: evaluation-50k
                stage:
                  stageId: evaluation-1
                  profitTarget: '4000'
                  minimumTradingDays: 5
                  session:
                    timeZone: America/Chicago
                    rolloverHour: 17
                  drawdown:
                    maxLoss: '4000'
                    kind: trailing
                    measure: equity
                    highWater: endOfDay
                    dailyMaxLoss: '2000'
                  maximumReturn: null
                  maximumDays: null
            profitSharePct: null
    WireChallenge:
      type: object
      description: An evaluation program a trader can enroll in.
      properties:
        id:
          type: string
          format: uuid
          description: The program's id.
        name:
          type: string
          description: The program's name.
        description:
          type:
            - string
            - 'null'
          description: The program's description, or null.
        isActive:
          type: boolean
          description: True when the program is open for enrollment.
        stage:
          type: integer
          description: For a program with several stages, this program's stage number.
        nextChallengeId:
          type:
            - string
            - 'null'
          description: The program for the next stage, for a two-step evaluation, or null.
        allowedTypes:
          type: array
          items:
            type: string
            enum:
              - trial
              - standard
              - funded
          description: The kinds of enrollment the program allows.
        accountSizes:
          type: array
          items:
            type: integer
          description: The starting balances allowed, in whole dollars.
        currency:
          type: string
          description: The program's currency.
        priceCents:
          type: integer
          description: >-
            The entry price in cents. A trader can enroll on their own only in a
            program priced at 0; see `/api/challenges/enroll`.
        sizes:
          type: array
          description: >-
            The sizes an enrollment can be issued at, each with the venue group
            it is issued into and the rules it is judged by: the stage that
            group runs now, in money for that size. `stage` is null while no
            version of it is active. A program with sizes states its rules only
            here, and its percentage rules below are null.
          items:
            type: object
            properties:
              size:
                type: integer
                description: The starting balance, in whole units of the currency.
              venueId:
                type: string
                format: uuid
                description: The venue the account is issued at.
              groupId:
                type: string
                description: The group the account is issued into.
              stage:
                type:
                  - object
                  - 'null'
                description: >-
                  The stage rules the account is judged by, or null while none
                  is active.
                properties:
                  stageId:
                    type: string
                    description: The stage's id.
                  profitTarget:
                    type: string
                    description: >-
                      The net trading profit required, in the account's
                      currency.
                  minimumTradingDays:
                    type: integer
                    description: The fewest trading days required.
                  session:
                    type: object
                    description: The session the days are counted in.
                    properties:
                      timeZone:
                        type: string
                        description: The IANA time zone.
                      rolloverHour:
                        type: integer
                        description: The hour the trading day starts.
                    required:
                      - timeZone
                      - rolloverHour
                  drawdown:
                    type:
                      - object
                      - 'null'
                    description: The drawdown rule, or null for none.
                    properties:
                      maxLoss:
                        type: string
                        description: The largest loss allowed.
                      kind:
                        type: string
                        enum:
                          - static
                          - trailing
                        description: >-
                          Whether the loss limit stays put or trails the
                          high-water mark.
                      measure:
                        type: string
                        enum:
                          - balance
                          - equity
                        description: Whether the limit is measured on balance or equity.
                      highWater:
                        type:
                          - string
                          - 'null'
                        enum:
                          - intraday
                          - endOfDay
                          - null
                        description: >-
                          For a trailing limit, when the high-water mark is
                          taken, or null.
                      dailyMaxLoss:
                        type:
                          - string
                          - 'null'
                        description: The largest loss allowed in one day, or null.
                    required:
                      - maxLoss
                      - kind
                      - measure
                      - highWater
                      - dailyMaxLoss
                  maximumReturn:
                    type:
                      - string
                      - 'null'
                    description: The largest return allowed, or null.
                  maximumDays:
                    type:
                      - integer
                      - 'null'
                    description: The most days the stage may run, or null.
                required:
                  - stageId
                  - profitTarget
                  - minimumTradingDays
                  - session
                  - drawdown
                  - maximumReturn
                  - maximumDays
            required:
              - size
              - venueId
              - groupId
              - stage
        profitSharePct:
          type:
            - number
            - 'null'
          description: The trader's profit share, in percent, or null.
      required:
        - id
        - name
        - isActive
        - stage
        - allowedTypes
        - accountSizes
        - currency
        - priceCents
        - sizes
  securitySchemes:
    sessionCookie:
      type: apiKey
      in: cookie
      name: session
      description: >-
        The signed session cookie of a trdrs user who is signed in, used by
        trdrs's own apps in a browser. The trading app and the Connect dashboard
        each sign in on their own: the trading app with a trader's session and
        the Connect dashboard with a Connect account's session, and a route
        takes the session of the one that calls it. An API key cannot reach a
        route secured this way.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.