Bring genetic personalization to your app

Let users connect an existing .genome or get sequenced through the same hosted integration.

We handle kitting, fulfillment, sequencing, bioinformatics, and support, then deliver structured genetic insights directly to your product.

API and insight panel access are free for approved organizations.

Request access at api@genome.computer.

Get API access Quickstart

One integration. Two ways to connect.

Every user ends up with the same connection to your product, whether they already have a .genome or need to be sequenced.

Connect an existing .genome

Users who already have a .genome can connect it to your product without paying for or waiting on new sequencing.

They verify their account, choose the genome they want to use, and grant your product access. Their connection can be ready immediately.

Order whole-genome sequencing

If a user does not have a .genome yet, they can order sequencing through the same hosted flow.

Collection kit fulfillment
Shipping and sample return
Sequencing and bioinformatics
.genome creation
Insight generation

Both journeys resolve to the same API resources, so your team only builds the integration once.

Set up and test in Developer Console

Developer Console is the control center for your organization's API integration. Access is scoped separately to staging and production.

Manage API access

Create environment-specific API keys. Each key secret is shown only once.
Review credential activity and revoke keys that are no longer needed.
Add each HTTPS return origin as a scheme, host, and optional port. Paths and wildcard domains are not supported.
Manage staging and production return origins independently.

Simulate orders in staging

Create a reusable synthetic genome to test the existing-genome path.
Place a dummy customer order through the hosted flow.
Advance fulfillment and processing to test progress updates and the ready state.
The simulator uses only synthetic staging records and does not contact payment, delivery, or lab providers.

Staging tools are available only in the staging environment. Production access, keys, return origins, and data remain separate and require production approval.

What your product gets

Genome Computer turns each connected genome into structured genetic context your product can ingest.

Base insight panels

Start with configured insight panels designed to make genetic information usable inside your product.

Genetic findings
Plain-language interpretations
Evidence levels
Source citations
Limitations

Custom insights for your product

During onboarding, we work with you to create additional insight panels specific to your product, from nutrition and performance to longevity, medication response, or other areas relevant to your experience.

Product-ready output

Insight responses are structured for user profiles, personalized recommendations, AI context, reports, dashboards, agent workflows, notifications, and longitudinal experiences.

Genome Computer manages the underlying genetics, interpretation logic, and panel configuration. Your team integrates the resulting structured output.

A user-owned genome layer

The user's genome belongs to them, not to the product they connect it to.

Users stay in control

A .genome can exist independently of any individual integration and can be connected to other applications the user chooses.

Sequence once. Use anywhere.

Users who have already been sequenced do not need to sequence again every time they want to use genetics in another product.

Your organization receives access only through the user's Genome Computer connection.

The hosted connection flow

Your product creates a Genome Computer connection for a signed-in user. From there, Genome Computer handles the user-facing genome flow.

Client

Create a connection from your authenticated product

User

Verify by email and accept the connection terms

User

Connect what they have, or order when they have neither

Genome Computer

Bind access to that specific genome

Client

Receive normalized status without user identity

Client

Confirm the user is signed into your product.
Create a connection with an opaque user reference and allowlisted return URL.
Store the returned genome_connection_id against your user.
Send that same signed-in user to the short-lived customer_url.
Read the connection or consume signed webhooks after they return.

User

Enter the one-time passcode sent by email.
Accept the applicable terms and access grant.
Choose an existing genome or connect an eligible order already in progress. If neither exists, complete direct checkout.

Genome Computer

Create or recover the user's Genome Computer account.
Identify the referring client, present the applicable terms, and request the access grant.
Return them to the approved URL and publish connection progress.

Two ways to connect a user's .genome

Both journeys end in the same client resource. The difference is whether the specific genome already exists or is created by a new order.

Grant access to an existing .genome

Your user selects one eligible .genome and grants your organization access. Genome Computer creates the client-specific handle and activates the grant immediately. Progress moves directly toready.

{
  "genome_connection_id": "gconn_01K4J92BRY7M",
  "client_user_reference": "user_8f3c2a",
  "status": "connected",
  "access_status": "active",
  "journey": "existing_genome",
  "client_genome_id": "cgen_01K4J9PT1Q6S",
  "created_at": "2026-09-03T04:15:22.000Z",
  "connected_at": "2026-09-03T04:19:08.000Z",
  "permissions": [
    { "permission": "genome_connection", "status": "granted" },
    { "permission": "insight_panels", "status": "granted" }
  ]
}

Order a .genome through Genome Computer

Your user can connect one eligible order already in progress. If they have no eligible genome or order, they can order a .genome through our hosted connection flow. Once an order is connected, your app can track its progress through fulfillment and sequencing. Their genetic insights become available when processing is complete.

{
  "genome_connection_id": "gconn_01K4J92BRY7M",
  "client_user_reference": "user_8f3c2a",
  "status": "connected",
  "access_status": "pending_genome",
  "journey": "new_order",
  "client_genome_id": null,
  "created_at": "2026-09-03T04:15:22.000Z",
  "connected_at": "2026-09-03T04:24:51.000Z",
  "permissions": [
    { "permission": "genome_connection", "status": "granted" },
    { "permission": "insight_panels", "status": "granted" }
  ]
}

Create a .genome connection

Call this endpoint only from your backend. API keys and connection URLs must not be embedded in browser bundles, mobile apps, analytics, or email.

POST /v2/genome_connections

export GC_API_KEY="gc_test_xxx"

curl https://staging.api.genome.computer/v2/genome_connections \
  -X POST \
  -H "Authorization: Bearer $GC_API_KEY" \
  -H "Idempotency-Key: connect-user-8f3c2a-01" \
  -H "Content-Type: application/json" \
  -d '{
    "client_user_reference": "user_8f3c2a",
    "return_url": "https://app.acmehealth.example/settings/genome"
  }'

const response = await fetch(
  "https://staging.api.genome.computer/v2/genome_connections",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.GC_API_KEY}`,
      "Idempotency-Key": "connect-user-8f3c2a-01",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      client_user_reference: "user_8f3c2a",
      return_url: "https://app.acmehealth.example/settings/genome"
    })
  }
);

if (!response.ok) throw new Error("Connection creation failed");

const { genome_connection, customer_url } = await response.json();
// Redirect the intended signed-in user to customer_url.
console.log(genome_connection.genome_connection_id);

{
  "genome_connection": {
    "genome_connection_id": "gconn_01K4J92BRY7M",
    "client_user_reference": "user_8f3c2a",
    "status": "awaiting_customer",
    "access_status": null,
    "journey": null,
    "client_genome_id": null,
    "created_at": "2026-09-03T04:15:22.000Z",
    "connected_at": null,
    "permissions": [
      { "permission": "genome_connection", "status": "pending" },
      { "permission": "insight_panels", "status": "pending" }
    ]
  },
  "customer_url": "https://connect.genome.computer/c/gc_link_xxx",
  "customer_url_expires_at": "2026-09-03T04:30:22.000Z"
}

Idempotency

Every create requires an Idempotency-Key. Reuse the same key only to retry the same body after a timeout or 5xx. A successful retry returns the original connection and URL state.

One active connection initially

The API supports one active genome connection for eachclient_user_reference in an organization and environment. A second active attempt is rejected withactive_connection_exists. After the user revokes access, create a fresh connection with a new idempotency key.

Customer permission decisions

The hosted flow stores a separate decision for each permission shown to the customer. Every request includes permission to connect the selected genome and report its progress. It may also request insight-panel access, processed .genome bundle access, or both, according to the capabilities enabled for your organization and environment. Data endpoints require both an active organization capability and the matching customer permission.

If the customer selects Cancel, the connection remains available with its original genome_connection_id, but no genome access is granted. The latest values appear in permissions asdeclined. Your product can offer the choice again by creating a new short-lived permission request for that same connection. Do not automatically redirect or repeatedly prompt the customer.

curl https://staging.api.genome.computer/v2/genome_connections/gconn_01K4J92BRY7M/permission_requests   -X POST   -H "Authorization: Bearer $GC_API_KEY"   -H "Idempotency-Key: reconnect-user-8f3c2a-01"

List and recover connections

Use GET /v2/genome_connections to rebuild your local connection records or find the connection for an exactclient_user_reference. Results are scoped to the API key's organization and environment, ordered newest first, and use an opaque cursor for pagination. Expired and revoked historical connections remain in the list so a lost local record can still be recovered. Customer identity is never returned.

curl "https://staging.api.genome.computer/v2/genome_connections?limit=25&client_user_reference=user_8f3c2a" \
  -H "Authorization: Bearer $GC_API_KEY"

{
  "data": [
    {
      "genome_connection_id": "gconn_01K4J92BRY7M",
      "client_user_reference": "user_8f3c2a",
      "status": "connected",
      "access_status": "active",
      "journey": "existing_genome",
      "client_genome_id": "cgen_01K4J9PT1Q6S",
      "created_at": "2026-09-03T04:15:22.000Z",
      "connected_at": "2026-09-03T04:19:08.000Z",
      "permissions": [
        { "permission": "genome_connection", "status": "granted" },
        { "permission": "insight_panels", "status": "granted" }
      ]
    }
  ],
  "next_cursor": null
}

Identifiers

Field	Authority	Purpose
client_user_reference	Chosen by you	Your opaque reference for the signed-in user. Do not put direct identity in it.
genome_connection_id	Chosen by Genome Computer	The durable API resource for this client-to-genome connection.
client_genome_id	Chosen by Genome Computer	A stable genome handle scoped to your organization. It continues to identify the same genome after access is revoked.
customer_url	Chosen by Genome Computer	A short-lived hosted-flow URL returned only when the connection is created. It is a secret handoff, not a durable identifier.

Keep genome_connection_id as the resource identifier andclient_genome_id as the genome identifier. Do not parse either value. After revocation, the connection record, access state, and any previously issued client_genome_id remain queryable, while genome data endpoints no longer authorize access.

Connection state

status	Meaning
awaiting_customer	The URL has been created, but the user has not completed the hosted flow.
connected	The user completed the required terms and selected an existing genome or completed checkout for a new one.
expired	The hosted flow was not started before its URL expired. Create a new connection attempt.

access_status	Meaning
null	The user has not completed the hosted genome choice, so no access grant exists yet.
pending_genome	A new order is connected, but its specific canonical genome has not been registered yet.
active	The referring organization has an active grant to the selected genome.
revoked	The user has revoked access. The connection record and any previously issued client_genome_id remain queryable, but genome data endpoints deny access.

Read normalized progress

Poll the progress endpoint after a browser return, use webhooks for ongoing changes, and show users only the coarse stage. Internal carrier, lab, and processing statuses may change without changing API behavior.

1Order confirmed

2Outbound to user

3With user

4Inbound to lab

5At lab

6Processing

7Ready

stage	Meaning
awaiting_customer	Waiting for email verification, terms, and the user's genome choice.
order_confirmed	The user completed Genome Computer checkout for one new genome.
outbound_to_customer	The collection kit is on its way to the user.
with_customer	The kit has reached the user and is awaiting its return journey.
inbound_to_lab	The returned kit is on its way to the lab.
at_lab	The lab has received the sample.
processing	Sequencing and genome processing are underway.
ready	The specific genome is registered. Read access_status on the connection for the client's current access.

{
  "genome_connection_id": "gconn_01K4J92BRY7M",
  "client_genome_id": null,
  "stage": "inbound_to_lab",
  "updated_at": "2026-09-14T01:42:17.000Z"
}

Existing-genome connections usually move fromawaiting_customer directly to ready. New orders move through the full sequence. Stages are monotonic in the ordinary path, but clients should render the latest value rather than infer unreported timestamps.

Download a .genome bundle

Bundle downloads are available only when Genome Computer enables the capability for your organization and environment. The user's active grant still controls every request.

Explicitly enabled

Bundle access is separate from ordinary connection and insight-panel access. It is disabled by default and can be approved independently in Staging and Production.

Short-lived delivery

The endpoint returns a signed URL that expires after 15 minutes. Request it from your backend, do not log it, and deliver it only to the intended authorized user or system.

curl https://staging.api.genome.computer/v2/genome_connections/gconn_01K4J92BRY7M/bundle \
  -H "Authorization: Bearer $GC_API_KEY"

{
  "genome_connection_id": "gconn_01K4J92BRY7M",
  "client_genome_id": "cgen_01K4J9PT1Q6S",
  "bundle_version": "2026.09.1",
  "download_url": "https://storage.example/signed-bundle",
  "expires_in_seconds": 900
}

When this capability is enabled, the hosted connection flow tells the user that your organization can request a downloadable .genome bundle. Revoking the connection prevents new links from being created, but it cannot retract a file your organization already downloaded. Completed synthetic staging orders return a shared sample bundle for integration testing, not a representation of the customer's DNA.

Insight panels

Insight panels turn a user's genome into structured genetic context your product can use. Each panel has a stable insight_panel_id and can contain findings, evidence, citations, limitations, and other structured interpretation.

Built for products, not reports

Genome Computer does not require your product to parse a static genetic report. Panels expose structured outputs that can be incorporated directly into your product experience.

Generated automatically

Processing starts when the genome is ready, the connection grant is active, and Genome Computer has enabled the insight-panel capability for your environment. Reading results also requires the customer's insight-panel permission. A consumer subscription is not required.

Add more over time

Additional panels can be configured under new stable IDs and introduced without changing the underlying genome connection.

status	Meaning
waiting_for_genome	The connection is complete, but the specific genome is not ready.
subscription_required	Legacy status from older V2 deployments. Current V2 does not require a consumer subscription for panel access.
processing	The genome is ready, the grant is active, and the panel is being generated.
ready	The panel result is available to read.

{
  "genome_connection_id": "gconn_01K4J92BRY7M",
  "client_genome_id": "cgen_01K4J9PT1Q6S",
  "data": [
    {
      "insight_panel_id": "nutrition_diet_response",
      "title": "Nutrition & Diet Response",
      "status": "ready",
      "interpretation_version": "2026.09.1",
      "generated_at": "2026-09-16T08:24:13.000Z"
    },
    {
      "insight_panel_id": "pharmacogenomics_safety",
      "title": "Pharmacogenomics Safety",
      "status": "processing",
      "interpretation_version": null,
      "generated_at": null
    }
  ]
}

{
  "genome_connection_id": "gconn_01K4J92BRY7M",
  "client_genome_id": "cgen_01K4J9PT1Q6S",
  "insight_panel_id": "nutrition_diet_response",
  "title": "Nutrition & Diet Response",
  "status": "ready",
  "interpretation_version": "2026.09.1",
  "generated_at": "2026-09-16T08:24:13.000Z",
  "summary": "Inherited tendencies in how this user processes foods and drinks.",
  "sections": [
    {
      "section_id": "food_drink_metabolism",
      "title": "Food & Drink Metabolism",
      "evidence_level": "high",
      "findings": [
        {
          "finding_id": "rs4988235",
          "title": "MCM6 rs4988235",
          "gene": "MCM6",
          "result_label": "One copy of G and one copy of A",
          "meaning": "Associated with digesting dairy into adulthood in studied populations.",
          "evidence_level": "high",
          "evidence": {
            "basis": "GWAS Catalog",
            "clinical_review": "Review alongside current diet, symptoms, labs, and clinical context."
          }
        }
      ]
    }
  ],
  "citations": [
    {
      "source": "GWAS Catalog",
      "url": "https://www.ebi.ac.uk/gwas/"
    }
  ],
  "limitations": [
    "Genetic tendencies do not measure current nutrition or symptoms."
  ],
  "clinical_boundary": "Use for education and clinician review, not diagnosis or treatment."
}

Panel responses contain derived findings, evidence, citations, limitations, and a clinical boundary. They do not contain user identity or raw genome files.

Pricing

API and insight panel access are free for approved organizations.

API

There are no API access or insight-panel access fees charged to your organization.

Existing .genome users

Users who already have an eligible .genome can connect it without ordering or paying for new sequencing. Panel data remains available while their Genome Computer subscription is current.

New sequencing

Users who need a genome can order sequencing from Genome Computer through the hosted connection flow.

Thin, signed webhooks

Webhook events signal that connection or progress state changed. They contain only client-scoped identifiers and the new coarse state, so your backend can retrieve the current resource when needed.

Register an endpoint

Call POST /v2/webhooks from your backend with a key that has webhooks:write. Store the returned signing secret when the endpoint is created because it is shown only once.

curl https://staging.api.genome.computer/v2/webhooks \
  -X POST \
  -H "Authorization: Bearer $GENOME_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://api.your-company.com/webhooks/genome-computer",
    "event_types": [
      "genome_connection.connected",
      "genome_connection.progress.updated",
      "genome_connection.ready",
      "genome_connection.access.revoked",
      "insight_panel.status.updated"
    ]
  }'

Use GET /v2/webhooks to list endpoints andDELETE /v2/webhooks/{webhookId} to disable one.

Progress event

{
  "id": "evt_4a86cb99ccef40f09646093335fcffb4",
  "type": "genome_connection.progress.updated",
  "created_at": "2026-09-14T01:42:18.000Z",
  "data": {
    "genome_connection_id": "gconn_01K4J92BRY7M",
    "client_user_reference": "user_8f3c2a",
    "client_genome_id": null,
    "stage": "inbound_to_lab"
  }
}

Verify before processing

Verify the raw request body with the organization's signing secret, reject stale timestamps, and deduplicate by event ID.

import crypto from "node:crypto";

export function verifyWebhook(rawBody, headers, secret) {
  const timestamp = headers.get("gc-webhook-timestamp");
  const signature = headers.get("gc-webhook-signature")?.replace("v1=", "");
  if (!timestamp || !signature) return false;

  const ageSeconds = Math.abs(Date.now() / 1000 - Number(timestamp));
  if (!Number.isFinite(ageSeconds) || ageSeconds > 300) return false;

  const expected = crypto
    .createHmac("sha256", secret)
    .update(`${timestamp}.${rawBody}`)
    .digest("hex");

  return signature.length === expected.length && crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

Event	When	Data
genome_connection.connected	The hosted flow completes.	Connection ID, client reference, journey, access state
genome_connection.progress.updated	The normalized progress stage changes.	Connection ID, client genome ID when available, stage
genome_connection.ready	The genome becomes ready. The event includes the current access state.	Connection ID, client genome ID, stage, access state
genome_connection.access.revoked	A user revokes this client's access in Genome Computer account settings.	Connection ID, client genome ID when available, access state
insight_panel.status.updated	An enabled insight panel changes status.	Connection ID, client genome ID, insight panel ID, status

Return any 2xx response after durable receipt. Deliveries use at-least-once semantics, may arrive out of order, and are retried after a non-2xx response, a timeout, or a DNS or TLS failure. Unknown event types must be safely ignored and acknowledged.

Identity stays on each side of the handoff

The client proves which of its signed-in users began the journey. Genome Computer separately verifies the user's email and controls its own account, terms, checkout, and genome permissions.

Client responsibilities

Create connections from a trusted backend only.
Start every flow inside an authenticated product session.
Use an opaque reference without names, emails, or phone numbers.
Send the URL only to the intended signed-in user.
Add each exact HTTPS return origin in Developer Console before creating a connection. Staging and production have separate lists.

Genome Computer responsibilities

Verify the user by email OTP.
Require terms and the referring client's genome grant.
Keep the canonical user and genome identifiers private.
Scope every API read to organization and environment.
Retain grant and revocation history against the specific genome.

A hosted-flow link is a temporary bearer secret. Do not log it, send it through analytics, place it in support tickets, or let a different signed-in user use it. Create a fresh connection attempt if the URL expires before it is opened.

Errors and retries

Errors use a stable machine-readable code, a safe message, and a request ID for support. Do not branch on message text.

HTTP	Example code	Handling
400	invalid_request	The body, idempotency key, or return URL is invalid.
401	unauthorized	The API key is missing, invalid, or scoped to a different environment.
403	organization_blocked	The organization or requested environment is not currently enabled.
403	api_capability_disabled	Genome Computer has not enabled the requested sensitive capability for this organization and environment.
403	genome_access_forbidden	The user's grant for this organization and specific genome is no longer active.
404	not_found	The connection does not exist in this organization and environment.
409	active_connection_exists	This client user reference already has an active connection. Only one active connection is supported per client user reference.
429	rate_limited	Wait for Retry-After, then retry with backoff and jitter.
5xx	server_error	Retry reads. Retry create requests with the same idempotency key.

{
  "error": {
    "code": "active_connection_exists",
    "message": "An active genome connection already exists for this client user reference.",
    "request_id": "req_01K4J9YDB2N5"
  }
}

Build for additive change

The API evolves through additive response fields, webhook event types, and enum values. Breaking changes require a new major API version.

Change	Treatment	Client behavior
New response fields	Additive	Ignore fields your integration does not understand.
New webhook event types	Additive	Ignore unknown event types and acknowledge them with 2xx.
New enum values	Potentially additive	Use an unknown fallback instead of exhaustive failure.
Existing documented behavior	Stable	A breaking change requires a new major API version.

Current scope

The API establishes the user-owned connection, records access to the specific genome, reports progress, and returns configured insight panels.

Included

Capability	Available
Hosted flow	Co-branded Genome Computer flow, email OTP, required terms, return to an allowlisted client URL
Existing genome	User selects one genome already present in their Genome Computer account
New order	User orders a .genome through the hosted connection flow
Connection	Durable client-scoped identifiers and one active genome connection per client user reference
Progress	Read endpoint and thin signed webhook events through the ready stage
Insight panels	Read organization-configured panel statuses and results
Genome bundle downloads	Optional organization capability for short-lived signed .genome bundle links

Deferred

Capability	Later
Selective sharing	Users grant each supported API data capability shown in the hosted flow. Choosing genome regions or finer data categories comes later.
Multiple genomes per client user	A second active connection for the same client user reference is rejected. After the user revokes access, the client may create a fresh connection with a new idempotency key. The model may expand later.
Raw sequencing files	FASTQ and gVCF downloads are not included. Approved organizations may instead receive the processed .genome bundle capability.

Genome Computer designs and configures custom insight panels for each organization during onboarding. Additional panels can be introduced under new stable IDs without changing existing panel responses.

Provisioned access by environment

Being added as an API organization does not automatically create credentials. Staging and production are explicit control-plane entitlements with isolated keys and data.

Environment	Base URL	Access
Staging	https://staging.api.genome.computer	Your organization must be added and explicitly granted staging access. Hosted OTP emails are delivered, while checkout creates a dummy order without payment or fulfillment.
Production	https://api.genome.computer	Requires separate approval and setup. Production credentials and data are isolated from staging.

The examples use https://staging.api.genome.computer to show the complete integration flow. Replace it with the production base URL only after your organization receives production access.

Genome Computer can place a reversible global block on an API organization. A block suspends its API access without deleting user grants, connection history, or stable genome bindings.

Endpoint reference

The API keeps the surface intentionally small. Review each field while building your integration.

Genome connections

GET/v2/genome_connections

List genome connections

Scope: genome_connections:read

POST/v2/genome_connections

Create a hosted genome connection

Scope: genome_connections:write

GET/v2/genome_connections/{genome_connection_id}

Get a genome connection

Scope: genome_connections:read

GET/v2/genome_connections/{genome_connection_id}/bundle

Create a signed .genome bundle download link

Scope: genome_connections:read

POST/v2/genome_connections/{genome_connection_id}/permission_requests

Request customer permission again

Scope: genome_connections:write

Progress

GET/v2/genome_connections/{genome_connection_id}/progress

Get normalized genome progress

Scope: genome_connections:read

Insight panels

GET/v2/genome_connections/{genome_connection_id}/insight_panels

List insight panels for a connection

Scope: insight_panels:read

GET/v2/genome_connections/{genome_connection_id}/insight_panels/{insight_panel_id}

Get an insight panel

Scope: insight_panels:read

Webhooks

GET/v2/webhooks

List webhook endpoints

Scope: webhooks:read

POST/v2/webhooks

Scope: webhooks:write

DELETE/v2/webhooks/{webhookId}

Disable a webhook endpoint

Scope: webhooks:write

Open full reference Download OpenAPI