Cancer.gov

NCI SEER API

RESTful API for the Surveillance, Epidemiology, and End Results (SEER) Program. Supports SEER datasets plus staging APIs for cancer staging (TNM and Collaborative Stage algorithms), enabling developers to embed authoritative incidence, survival, and staging logic into their own systems.

GitHub OpenAPI

Operations 106

GET /rest/staging/{algorithm}/{version} Return information about a specific algorithm version #
PUT /rest/staging/{algorithm}/{version} Update an algorithm version #
POST /rest/staging/{algorithm}/{version} Create a new version for an algorithm #
DELETE /rest/staging/{algorithm}/{version} Delete an algorithm version #
GET /rest/staging/{algorithm}/{version}/table/{id} Return a single table #
PUT /rest/staging/{algorithm}/{version}/table/{id} Update a table #
DELETE /rest/staging/{algorithm}/{version}/table/{id} Delete a table #
GET /rest/staging/{algorithm}/{version}/schema/{id} Return a single schema #
PUT /rest/staging/{algorithm}/{version}/schema/{id} Update a schema #
DELETE /rest/staging/{algorithm}/{version}/schema/{id} Delete a schema #
GET /rest/staging/{algorithm} Return information about a specific algorithm #
PUT /rest/staging/{algorithm} Update an algorithm #
POST /rest/staging/{algorithm} Create a new algorithm #
DELETE /rest/staging/{algorithm} Delete an algorithm #
PUT /rest/rx/{version}/update Update an Rx entry #
PUT /rest/rx/{version}/reset/{id} Reset an Rx entry #
GET /rest/ndc/code/{code} Return a single drug product #
PUT /rest/ndc/code/{code} Update a drug with SEER-specific information #
GET /rest/hcpcs/code/{code} Return a single procedure #
PUT /rest/hcpcs/code/{code} Update a procedure #
DELETE /rest/hcpcs/code/{code} Delete a procedure #
PUT /rest/glossary/{version}/update Update a glossary entry #
PUT /rest/glossary/{version}/reset/{id} Reset a glossary entry #
PUT /rest/disease/{version}/update Update a disease entry #
PUT /rest/disease/{version}/reset/{id} Reset a disease entry #
POST /rest/staging/{algorithm}/{version}/{id}/defaults Get all schema defaults #
POST /rest/staging/{algorithm}/{version}/table Create a new table #
POST /rest/staging/{algorithm}/{version}/table/{id}/match Checks whether a set of key/value pairs match any row in a table #
POST /rest/staging/{algorithm}/{version}/stage Stage a case #
POST /rest/staging/{algorithm}/{version}/schemas/lookup Perform a schema lookup #
POST /rest/staging/{algorithm}/{version}/schema Create a new schema #
POST /rest/staging/{algorithm}/{version}/invalidate_cache Invalidate algorithm version cache #
POST /rest/staging/{algorithm}/{version}/fill_cache Fill algorithm version cache #
POST /rest/staging/{algorithm}/{version}/copy Copies all schemas and tables to another algorithm/version #
POST /rest/rx/{version}/unhide/{id} Unhide an Rx item #
POST /rest/rx/{version}/publish Publish the specified Rx entities into the associated production database #
POST /rest/rx/{version}/hide/{id} Hide an Rx item #
POST /rest/rx/{version}/create Save a new Rx entry #
POST /rest/rx/versions/create Creates a new BETA version database #
POST /rest/mph Compares two tumors and determines if they are multiple primaries #
POST /rest/hcpcs/code Save a new procedure #
POST /rest/glossary/{version}/unhide/{id} Unhide a glossary item #
POST /rest/glossary/{version}/publish Publish the specified glossary items into the associated production database #
POST /rest/glossary/{version}/hide/{id} Hide a glossary item #
POST /rest/glossary/{version}/create Save a new glossary entry #
POST /rest/glossary/versions/create Creates a new BETA version database #
POST /rest/glossary/match Match supplied text against the glossary #
POST /rest/disease/{version}/unhide/{id} Unhide a disease item #
POST /rest/disease/{version}/publish Publish the specified disease entities into the associated production database #
POST /rest/disease/{version}/hide/{id} Hide a disease item #
POST /rest/disease/{version}/create Save a new disease entry #
POST /rest/disease/versions/create Creates a new BETA version database #
POST /rest/disease/reportability Returns the reportable year range of the supplied disease #
GET /rest/surgery/{year}/tables Return all the available table titles for the specified year #
GET /rest/surgery/{year}/table Return a single surgery table #
GET /rest/staging/{algorithm}/{version}/tables Return a list of matching tables #
GET /rest/staging/{algorithm}/{version}/tables/history Return a list of table history entries #
GET /rest/staging/{algorithm}/{version}/table/{id}/schemas Return a list of the schemas which use a specific table #
GET /rest/staging/{algorithm}/{version}/table/{id}/history Return the history of single schema #
GET /rest/staging/{algorithm}/{version}/table/{id}/glossary Return a matching glossary keywords from the table #
GET /rest/staging/{algorithm}/{version}/schemas Return a list of schemas #
GET /rest/staging/{algorithm}/{version}/schemas/history Return a list of schema history entries #
GET /rest/staging/{algorithm}/{version}/schema/{id}/tables Return a list of the tables involved in a specific schema #
GET /rest/staging/{algorithm}/{version}/schema/{id}/history Return the history of single schema #
GET /rest/staging/{algorithm}/{version}/schema/{id}/glossary Return a matching glossary keywords from the schema #
GET /rest/staging/{algorithm}/versions Return information about all the supported versions of an algorithm #
GET /rest/staging/algorithms Return a list of all staging algorithms #
GET /rest/rx/{version} Return a list of Rx entries #
GET /rest/rx/{version}/status_summary Return a list of Rx entries #
GET /rest/rx/{version}/keywords Return a list of keywords contained in the Rx entries #
GET /rest/rx/{version}/id/{id} Return an Rx entry #
GET /rest/rx/{version}/id/{id}/regimens Return a list of regimens containing the passed drug #
GET /rest/rx/{version}/changelog Return a list of Rx changelog entries #
GET /rest/rx/versions Return a list of all versions of the Rx database #
GET /rest/recode/sitegroup/{algorithm} Return the site group for the site/histology/behavior combination based on a specified algorithm #
GET /rest/recode/sitegroup/algorithms Return the supported site group algorithms and versions #
GET /rest/ndc Return matching drugs #
GET /rest/naaccr/{version} Return all NAACCR item identifiers and names #
GET /rest/naaccr/{version}/{id} Return a single NAACCR item by XML ID or item number #
GET /rest/naaccr/versions Return a list of information about all supported NAACCR versions #
GET /rest/mph/groups Returns a list of all MPH groups #
GET /rest/mph/group/{id} Returns the group information for a given group ID #
GET /rest/hcpcs Return matching procedures #
GET /rest/glossary/{version} Return a list of glossary entries #
GET /rest/glossary/{version}/status_summary Return a list of glossary entries #
GET /rest/glossary/{version}/keywords Return a list of keywords contained in the glossary entries #
GET /rest/glossary/{version}/id/{id} Return a glossary entry #
GET /rest/glossary/{version}/changelog Return a list of glossary changelog entries #
GET /rest/glossary/versions Return a list of all versions of the glossary database #
GET /rest/disease/{version} Return a list of Disease entries #
GET /rest/disease/{version}/status_summary Return a list of disease entries #
GET /rest/disease/{version}/same_primary Indicate whether 2 morphologies (and diagnosis years) represent the same primary #
GET /rest/disease/{version}/keywords Return a list of keywords contained in the disease entries #
GET /rest/disease/{version}/id/{id} Return a single disease #
GET /rest/disease/{version}/id/{id}/{year} Return a single disease with only year-based information for the passed year included #
GET /rest/disease/{version}/changelog Return a list of Disease changelog entries #
GET /rest/disease/versions Return a list of all versions of the disease database #
GET /rest/disease/site_categories Return the complete list of site categories for use in the search API #
GET /rest/disease/primary_site Return the list of ICDO2/ICDO3 primary site codes and labels #
GET /rest/disease/primary_site/{code} Return the list of ICDO2/ICDO3 primary sites matching a code #
DELETE /rest/rx/{version}/delete/{id} Delete an Rx entry #
DELETE /rest/rx/versions/delete Deletes an existing BETA version and all associated glossary entries #
DELETE /rest/glossary/{version}/delete/{id} Delete a glossary entry #
DELETE /rest/glossary/versions/delete Deletes an existing BETA version and all associated glossary entries #
DELETE /rest/disease/{version}/delete/{id} Delete a disease entry #
DELETE /rest/disease/versions/delete Deletes an existing BETA version and all associated glossary entries #

Documentation

📖
Documentation
https://api.seer.cancer.gov/docs
📖
RateLimits
https://raw.githubusercontent.com/api-evangelist/cancer-gov/refs/heads/main/rate-limits/cancer-gov-rate-limits.yml
📖
APIReference
https://api.seer.cancer.gov/docs

Specifications

⚙
OpenAPI
https://raw.githubusercontent.com/api-evangelist/cancer-gov/refs/heads/main/openapi/cancer-gov-seer-openapi.yml

Other Resources

🔗
Portal
https://api.seer.cancer.gov/
🔗
Overlay
https://raw.githubusercontent.com/api-evangelist/cancer-gov/refs/heads/main/overlays/cancer-gov-seer-overlay.yaml
🔗
TermsOfService
https://api.seer.cancer.gov/terms

Work with this as data

Every API here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for apis

7 MCP tools reach this
  • find_apisBrowse and filter every API in the catalog.
  • get_api_artifactsOne API's artifacts, grouped by type.
  • get_openapiThe primary OpenAPI for this API.
  • find_similar_apisAPIs that look like this one.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This API 
curl "https://apis.io/api/v1/apis/seer-api"
All apis 
curl "https://apis.io/api/v1/apis?limit=25"

Discovery needs no key. Ratings and market analysis are Pro.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

GitHub Google LinkedIn

A second provider on the same verified email joins the account you already have.

OpenAPI Specification

cancer-gov-seer-openapi.yml Raw ↑ 
openapi: 3.1.0
info:
  title: SEER*API
  description: 'SEER API is a RESTful Web service that supports various [SEER Program](https://seer.cancer.gov)
    data sets and mapping.


    This service is available to developers who wish to incorporate SEER resources into their own systems. These
    resources

    include databases and tools developed to enhance registry operations and quality improvement. The SEER API is
    designed

    for integration into registry computer systems and is not designed to be accessed by end-users.

    '
  termsOfService: /terms
  version: '1.0'
  x-apis-io-source: https://api.seer.cancer.gov/v3/api-docs
  x-apis-io-harvested: '2026-09-05'
  x-apis-io-method: searched
servers:
- url: https://api.seer.cancer.gov
  description: Generated server url
security:
- apiKeyScheme: []
tags:
- name: rx
  description: Antineoplastic drugs database
- name: glossary
  description: A glossary of cancer-related terms
- name: ndc
  description: A searchable mirror of National Drug Codes (NDC)
- name: mph
  description: Multiple Primary and Histology Coding Rules
- name: recode
  description: Recode algorithms
- name: surgery
  description: SEER Site-Specific Surgery Codes
- name: disease
  description: Hematopoietic, lymphoid neoplasms and solid tumor diseases
- name: staging
  description: Staging Algorithms
- name: hcpcs
  description: Healthcare Common Procedure Coding Systems (HCPCS) nomenclatures
- name: naaccr
  description: NAACCR Documentation
paths:
  /rest/staging/{algorithm}/{version}:
    get:
      tags:
      - staging
      summary: Return information about a specific algorithm version
      operationId: getVersion
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingAlgorithmVersion'
        '404':
          description: Algorithm version does not exist
    put:
      tags:
      - staging
      summary: Update an algorithm version
      operationId: updateVersion
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StagingAlgorithmVersion'
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingAlgorithmVersion'
        '400':
          description: Invalid input
        '404':
          description: Algorithm/version does not exist
    post:
      tags:
      - staging
      summary: Create a new version for an algorithm
      operationId: createVersion
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StagingAlgorithmVersion'
        required: true
      responses:
        '201':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingAlgorithmVersion'
        '400':
          description: Algorithm version already exists
        '404':
          description: Algorithm does not exist
    delete:
      tags:
      - staging
      summary: Delete an algorithm version
      operationId: deleteVersion
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      responses:
        '204':
          description: Success
        '404':
          description: Algorithm/version does not exist
  /rest/staging/{algorithm}/{version}/table/{id}:
    get:
      tags:
      - staging
      summary: Return a single table
      operationId: getTable
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Table identifier
        required: true
        schema:
          type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingTable'
        '404':
          description: Table does not exist
    put:
      tags:
      - staging
      summary: Update a table
      operationId: updateTable
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Table identifier
        required: true
        schema:
          type: string
      - name: comment
        in: query
        description: A comment to be associated with the history
        required: false
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StagingTable'
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingTable'
        '400':
          description: Table not valid
        '404':
          description: Table does not exist
    delete:
      tags:
      - staging
      summary: Delete a table
      operationId: deleteTable
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Table identifier
        required: true
        schema:
          type: string
      - name: comment
        in: query
        description: A comment to be associated with the history
        required: false
        schema:
          type: string
      responses:
        '204':
          description: Success
        '400':
          description: Table not valid
        '404':
          description: Table does not exist
  /rest/staging/{algorithm}/{version}/schema/{id}:
    get:
      tags:
      - staging
      summary: Return a single schema
      operationId: getSchema
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Schema identifier
        required: true
        schema:
          type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingSchema'
        '404':
          description: Schema does not exist
    put:
      tags:
      - staging
      summary: Update a schema
      operationId: updateSchema
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Schema identifier
        required: true
        schema:
          type: string
      - name: comment
        in: query
        description: A comment to be associated with the history
        required: false
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StagingSchema'
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingSchema'
        '400':
          description: Schema not valid
        '404':
          description: Schema does not exist
    delete:
      tags:
      - staging
      summary: Delete a schema
      operationId: deleteSchema
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Schema identifier
        required: true
        schema:
          type: string
      - name: comment
        in: query
        description: A comment to be associated with the history
        required: false
        schema:
          type: string
      responses:
        '204':
          description: Success
        '400':
          description: Schema not valid
        '404':
          description: Schema does not exist
  /rest/staging/{algorithm}:
    get:
      tags:
      - staging
      summary: Return information about a specific algorithm
      operationId: getAlgorithm
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingAlgorithm'
        '404':
          description: Algorithm does not exist
    put:
      tags:
      - staging
      summary: Update an algorithm
      operationId: updateAlgorithm
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StagingAlgorithm'
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingAlgorithm'
        '400':
          description: Invalid input
        '404':
          description: Algorithm does not exist
    post:
      tags:
      - staging
      summary: Create a new algorithm
      operationId: createAlgorithm
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StagingAlgorithm'
        required: true
      responses:
        '201':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingAlgorithm'
        '400':
          description: Algorithm already exists
    delete:
      tags:
      - staging
      summary: Delete an algorithm
      operationId: deleteAlgorithm
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      responses:
        '204':
          description: Success
        '400':
          description: Only algorithms with no versions can be deleted
        '404':
          description: Algorithm does not exist
  /rest/rx/{version}/update:
    put:
      tags:
      - rx
      summary: Update an Rx entry
      operationId: updateRx
      parameters:
      - name: version
        in: path
        description: Rx version
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Rx'
        required: true
      responses:
        '201':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Rx'
        '400':
          description: Invalid input
        '404':
          description: Unknown version
  /rest/rx/{version}/reset/{id}:
    put:
      tags:
      - rx
      summary: Reset an Rx entry
      operationId: resetRx
      parameters:
      - name: version
        in: path
        description: Rx version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Rx identifier
        required: true
        schema:
          type: string
      responses:
        '201':
          description: Success
        '400':
          description: Invalid input
        '404':
          description: Unknown version
        '204':
          description: No Content
  /rest/ndc/code/{code}:
    get:
      tags:
      - ndc
      summary: Return a single drug product
      description: All possible packages are included in each product.
      operationId: getByNdcId
      parameters:
      - name: code
        in: path
        description: NDC code
        required: true
        schema:
          type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/NdcProduct'
        '400':
          description: NDC code is not a valid format
        '404':
          description: NDC code does not exist
    put:
      tags:
      - ndc
      summary: Update a drug with SEER-specific information
      operationId: updateNdc
      parameters:
      - name: code
        in: path
        description: NDC code
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/NdcProduct'
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/NdcProduct'
        '400':
          description: NDC code is not a valid format
        '404':
          description: NDC code does not exist
  /rest/hcpcs/code/{code}:
    get:
      tags:
      - hcpcs
      summary: Return a single procedure
      operationId: getById
      parameters:
      - name: code
        in: path
        description: HCPCS code
        required: true
        schema:
          type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HcpcsProcedure'
        '404':
          description: HCPCS procedure does not exist
    put:
      tags:
      - hcpcs
      summary: Update a procedure
      operationId: updateProcedure
      parameters:
      - name: code
        in: path
        description: HCPCS code
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/HcpcsProcedure'
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HcpcsProcedure'
        '404':
          description: HCPCS procedure does not exist
    delete:
      tags:
      - hcpcs
      summary: Delete a procedure
      operationId: deleteProcedure
      parameters:
      - name: code
        in: path
        description: HCPCS code
        required: true
        schema:
          type: string
      responses:
        '200':
          description: Success
        '409':
          description: Procedure does not exist
        '204':
          description: No Content
  /rest/glossary/{version}/update:
    put:
      tags:
      - glossary
      summary: Update a glossary entry
      operationId: updateGlossaryItem
      parameters:
      - name: version
        in: path
        description: Glossary version
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Glossary'
        required: true
      responses:
        '201':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Glossary'
        '400':
          description: Invalid input
        '404':
          description: Unknown version
  /rest/glossary/{version}/reset/{id}:
    put:
      tags:
      - glossary
      summary: Reset a glossary entry
      operationId: resetGlossaryItem
      parameters:
      - name: version
        in: path
        description: Glossary version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Glossary identifier
        required: true
        schema:
          type: string
      responses:
        '201':
          description: Success
        '400':
          description: Invalid input
        '404':
          description: Unknown version
        '204':
          description: No Content
  /rest/disease/{version}/update:
    put:
      tags:
      - disease
      summary: Update a disease entry
      operationId: updateDisease
      parameters:
      - name: version
        in: path
        description: Disease version
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Disease'
        required: true
      responses:
        '201':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Disease'
        '400':
          description: Invalid input
        '404':
          description: Unknown version
  /rest/disease/{version}/reset/{id}:
    put:
      tags:
      - disease
      summary: Reset a disease entry
      operationId: resetDisease
      parameters:
      - name: version
        in: path
        description: Disease version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Disease identifier
        required: true
        schema:
          type: string
      responses:
        '201':
          description: Success
        '400':
          description: Invalid input
        '404':
          description: Unknown version
        '204':
          description: No Content
  /rest/staging/{algorithm}/{version}/{id}/defaults:
    post:
      tags:
      - staging
      summary: Get all schema defaults
      description: For a specified schema, add defaults to the input map. This is based on input 'default' and 'default_table'
        values.
      operationId: getSchemaInputDefaults
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Schema identifier
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              type: object
              additionalProperties:
                type: string
              description: Input map
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                type: object
                additionalProperties:
                  type: string
        '400':
          description: Schema not found
        '404':
          description: Algorithm/version does not exist
  /rest/staging/{algorithm}/{version}/table:
    post:
      tags:
      - staging
      summary: Create a new table
      operationId: createTable
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      - name: comment
        in: query
        description: A comment to be associated with the history
        required: false
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StagingTable'
        required: true
      responses:
        '201':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingTable'
        '400':
          description: Schema valid
  /rest/staging/{algorithm}/{version}/table/{id}/match:
    post:
      tags:
      - staging
      summary: Checks whether a set of key/value pairs match any row in a table
      description: The API returns true or false indicating a match. If a match was found, the row number of the
        match is returned as well.
      operationId: matchTable
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Table identifier
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              type: object
              additionalProperties:
                type: string
              description: Input map
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TableMatch'
        '404':
          description: Table does not exist
  /rest/staging/{algorithm}/{version}/stage:
    post:
      tags:
      - staging
      summary: Stage a case
      description: The POST data consists of a set of input keys that are defined by the schema that is being staged.
      operationId: stageSchema
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              type: object
              additionalProperties:
                type: string
              description: Input map
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingData'
        '400':
          description: Invalid input
  /rest/staging/{algorithm}/{version}/schemas/lookup:
    post:
      tags:
      - staging
      summary: Perform a schema lookup
      description: Perform a schema lookup based on site, histology and an optional set of discriminators.
      operationId: listSchemas
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              type: object
              additionalProperties:
                type: string
              description: Input map
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/StagingSchemaInfo'
        '404':
          description: Algorithm/version does not exist
  /rest/staging/{algorithm}/{version}/schema:
    post:
      tags:
      - staging
      summary: Create a new schema
      operationId: createSchema
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      - name: comment
        in: query
        description: A comment to be associated with the history
        required: false
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StagingSchema'
        required: true
      responses:
        '201':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StagingSchema'
        '400':
          description: Schema valid
  /rest/staging/{algorithm}/{version}/invalidate_cache:
    post:
      tags:
      - staging
      summary: Invalidate algorithm version cache
      operationId: invalidateCache
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      responses:
        '204':
          description: Success
        '404':
          description: Algorithm/version does not exist
  /rest/staging/{algorithm}/{version}/fill_cache:
    post:
      tags:
      - staging
      summary: Fill algorithm version cache
      operationId: fillCache
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      responses:
        '204':
          description: Success
        '404':
          description: Algorithm/version does not exist
  /rest/staging/{algorithm}/{version}/copy:
    post:
      tags:
      - staging
      summary: Copies all schemas and tables to another algorithm/version
      description: 'Create a new version in the target algorithm which is a copy of all schemas and tables from
        this algorithm version.  The new version does

        not include any schema or table history.


        The target version must not already exist.

        '
      operationId: copyVersion
      parameters:
      - name: algorithm
        in: path
        description: Staging algorithm
        required: true
        schema:
          type: string
      - name: version
        in: path
        description: Algorithm version
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StagingAlgorithmVersion'
        required: true
      responses:
        '204':
          description: Success
        '400':
          description: Target algorithm does not exist or target version already exists
        '404':
          description: Algorithm or version does not exist
  /rest/rx/{version}/unhide/{id}:
    post:
      tags:
      - rx
      summary: Unhide an Rx item
      description: Given a DEVELOPMENT Rx item, unhide the associated production Rx item. If there are other unpublished
        changes in the DEVELOPMENT Rx item, they will not be published.
      operationId: unhideRx
      parameters:
      - name: version
        in: path
        description: Rx version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Rx identifier
        required: true
        schema:
          type: string
      - name: description
        in: query
        required: false
        schema:
          type: string
      responses:
        '201':
          description: Success
        '400':
          description: Invalid input
        '404':
          description: Unknown version
        '204':
          description: No Content
  /rest/rx/{version}/publish:
    post:
      tags:
      - rx
      summary: Publish the specified Rx entities into the associated production database
      description: Publish the specified Rx entities into the associated production database.
      operationId: publishRx
      parameters:
      - name: version
        in: path
        description: Rx version
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/PublishInfo'
        required: true
      responses:
        '201':
          description: Success
        '400':
          description: Invalid input
        '404':
          description: Unknown version
        '204':
          description: No Content
  /rest/rx/{version}/hide/{id}:
    post:
      tags:
      - rx
      summary: Hide an Rx item
      description: Given a DEVELOPMENT Rx item, hide the associated production Rx item. If there are other unpublished
        changes in the DEVELOPMENT Rx item, they will not be published.
      operationId: hideRx
      parameters:
      - name: version
        in: path
        description: Rx version
        required: true
        schema:
          type: string
      - name: id
        in: path
        description: Rx identifier
        required: true
        schema:
          type: string
      - name: description
        in: query
        required: false
        schema:
          type: string
      responses:
        '201':
          description: Success
        '400':
          description: Invalid input
        '404':
          description: Unknown version
        '204':
          description: No Content
  /rest/rx/{version}/create:
    post:
      tags:
      - rx
      summary: Save a new Rx entry
      operationId: createRx
      parameters:
      - name: version
        in: path
        description: Rx version
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Rx'
        required: true
      responses:
        '201':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Rx'
        '400':
          description: Invalid input
        '404':
          description: Unknown version
  /rest

# --- truncated at 32 KB (143 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/cancer-gov/refs/heads/main/openapi/cancer-gov-seer-openapi.yml