API

A GraphQL based API (Application Programming Interface) can be used to query the HLA Serotype Database.

How GraphQL APIs Work

Your App

GraphQL Query

GraphQL API

JSON Response

Serotype Data

An API (Application Programming Interface) defines a set of rules and protocols that enable different software applications to interact with one another. GraphQL is a query language designed for APIs that not only lets you retrieve data but also lets you specify exactly which data fields should be returned. This targeted approach ensures you obtain precisely the information you need in an efficient manner.

API Endpoint

https://serotype.org/api/graphql

Header (key:value)

x-api-key:

YOUR_API_KEY

Response size cap

Fetching bulk data in R or curl

The getDownloads query returns a files array enumerating every pre-built file with its scope, locus, resolution, format, and a ready-to-use url. Export files are research use only: filenames carry a RESEARCH_USE_ONLY_ prefix and a random suffix and cannot be guessed — pick the row you want and fetch its url (don't build paths by hand). The same list is on the Downloads page.

# R — pull bulk full-field for the current version (research use only)
library(httr); library(jsonlite)
key <- Sys.getenv("SEROTYPE_API_KEY")
q <- 'query { getDownloads { version files { url scope resolution format } } }'
res <- POST("https://serotype.org/api/graphql",
            add_headers(.headers = c("x-api-key" = key)),
            body = list(query = q), encode = "json")
files <- fromJSON(content(res, "text", encoding = "UTF-8"))$data$getDownloads$files
row <- subset(files, scope == "bulk" & resolution == "full_field" & format == "json")
doc <- jsonlite::fromJSON(gzcon(url(row$url)))
df <- doc$data                     # rows; doc$metadata says which version and build
cat(doc$metadata$build_id, "rows:", nrow(df), "\n")
# curl — discover the file URL, then download it
URL=$(curl -s https://serotype.org/api/graphql \
  -H "x-api-key: $SEROTYPE_API_KEY" -H 'content-type: application/json' \
  -d '{"query":"{ getDownloads { files { url scope resolution format } } }"}' \
  | jq -r '.data.getDownloads.files[] | select(.scope=="bulk" and .resolution=="full_field" and .format=="json") | .url')
curl -sL "$URL" | gunzip -c | jq '.metadata.build_id, (.data | length)'

See lesson 3 for a walk-through of all three patterns for bulk data (query narrowing, cap-error handling, manifest-driven discovery).

Without limit and offset the whole result is returned, up to the 5000-row cap; above it a RESPONSE_TOO_LARGE error carries the matching download URL. With limit (1-5000) and/or offset you get exactly that page and never the error; alleleToSerotypeCount returns the total for the same filters.

Parameters

loci
[String!]
alleles
[String!]
allele_exact_match
Boolean
= true
serotypes
[String!]
qualifiers
[String!]
splits
[String!]
broads
[String!]
bw4_bw6
[String!]
c1_c2
[String!]
dr5x
[String!]
ciwd
[String!]
cwd
[String!]
eurcwd
[String!]
who_status
[String!] (assigned | assigned_split | assigned_broad | conflict | mixed | assumed | unknown | null_allele | none)
ipd_hats_differs
Boolean (only alleles whose HATS assignment as copied by IPD-IMGT/HLA differs from HATS's own output)
ipd_hats_listed
Boolean (true: only alleles for which IPD-IMGT/HLA lists a HATS assignment; false: only those without one)
search
String (substring of allele, serotype, split, broad, qualifier or Bw4/Bw6)
protein_filters
[AminoAcidFilter!] { position, residue, residues (any of), is_definition }
resolution
Resolution
= two_field
accepts values: two_field or full_field
sort
AlleleSort
= allele
accepts values: allele or serotype
limit
Int (1-5000)
offset
Int

Response

locus
String
allele
String
qualifier
String
qualifier_code
String
qualifier_description
String
serotype
String
split
String
broad
String
ciwd
String
cwd
String
eurcwd
String
bw4_bw6
String
c1_c2
String
dr5x
String
who_antigen
String (WHO unambiguous antigen from IPD-IMGT/HLA rel_dna_ser.txt, in serotype naming)
who_status
String (how the WHO antigen relates to the HATS serotype; see the Introduction page)
who_possible
String (WHO possible antigens, slash-separated)
ipd_hats_antigen
String (the HATS assignment as listed by IPD-IMGT/HLA)
ipd_accession
String (IPD-IMGT/HLA accession, e.g. HLA00001; for a two-field name that is not itself an IPD allele, that of its lowest-numbered full-field allele)
ipd_accession_allele
String (the allele the accession belongs to)
protein
Protein

Example Query

query {
  alleleToSerotype(
    alleles: ["A*02:01"]
    resolution: two_field
  ) {
    locus
    allele
    qualifier
    qualifier_code
    qualifier_description
    serotype
    split
    broad
    bw4_bw6
    c1_c2
    dr5x
    ciwd
    cwd
    eurcwd
    version
  }
}

Example Response

{
  "data": {
    "alleleToSerotype": [
      {
        "locus": "A",
        "allele": "A*02:01",
        "qualifier": "Full",
        "qualifier_code": "F",
        "qualifier_description": "Matches the serotype's reference pattern at every defining residue.",
        "serotype": "A0201",
        "split": "A2",
        "broad": "A2",
        "bw4_bw6": "",
        "c1_c2": "",
        "dr5x": "",
        "ciwd": "C",
        "cwd": "C",
        "eurcwd": "C",
        "version": "1.0"
      }
    ]
  }
}

See the API in action using interactive tools that can generate the GraphQL query and return the results. Try it now

Learn how to use the API with interactive R examples at our learning portal