API Documentation

Atlas

Protein Intelligence Platform

DSM

Diffusion Sequence Model

Protify

Chemical Language Model Training

API Reference

Synthyra API

Build with protein AI. Annotate protein function, generate sequences, and train chemical language models through a unified REST API.

54 endpointsREST + Python SDKGPU-accelerated

Quick Start

Generate an API key at synthyra.com/settings?section=api-keys after signing in. Treat it like a password, do not commit it to git or share it publicly.

Paste the key directly into your script (assign it to a variable) or export it as an environment variable, both patterns are shown below.

Pass the key in the Authorization header (Bearer token) on every request:

import requests

api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post(
    "https://api.synthyra.com/v1/translator/run",
    headers={"Authorization": f"Bearer {api_key}"},
    json={"sequences": ["MEEPQSDPSV..."], "ids": ["TP53"]},
)
print(response.json())

Authentication

Every authenticated endpoint expects an Authorization: Bearer <your-key> header. Requests without a valid key return 401 Unauthorized. Generate a key at synthyra.com/settings?section=api-keys. Discovery endpoints (/v1/model, /v1/capabilities, /v1/proteome/organisms, the Protify metadata GETs, and /health) are public and accept unauthenticated reads. The Python SDK authenticates via Modal credentials, not the API key.

# Python: paste your key into the api_key variable, send as a header
import requests

api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post(
    "https://api.synthyra.com/v1/translator/run",
    headers={"Authorization": f"Bearer {api_key}"},
    json={"sequences": ["MEEPQSDP..."], "ids": ["TP53"]},
)

# curl: same Bearer header, key passed inline or as $SYNTHYRA_API_KEY env var
curl -H "Authorization: Bearer sk-..." \
  https://api.synthyra.com/v1/jobs

# Python SDK (Atlas only): uses Modal credentials, no API key needed
from atlas.serving.client import AtlasModalClient
client = AtlasModalClient("synth-atlas-dev")

Python SDK

The Atlas Python SDK provides typed methods for all Atlas endpoints via Modal RPC. DSM and Protify clients are coming soon; use their HTTP endpoints directly for now.

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")

# Score interaction pairs
result = client.score_pairs(
    inputs_a=["MKTLLILAVL..."],
    inputs_b=["MGSSHHHHH..."],
)
print(result["scores"])  # [85]

# Generate interaction network
network = client.generate_network(
    organism="human",
    query_sequences=[{"id": "P04637", "sequence": "MEEPQSDP..."}],
    confidence_threshold=0.7,
    run_enrichment=True,
)
print(f"Found {len(network['network']['nodes'])} proteins")

Atlas

39 endpoints

Protein Intelligence Platform

Comprehensive protein functional annotation through the lens of molecular interactions. Score interaction pairs and matrices, generate interaction networks with enrichment analysis, run functional annotation with oracle probes and structure prediction, and produce AI-driven deep research reports.

Discovery

GET

/v1/model

Model metadata

Returns metadata about the currently deployed Atlas model including model name, backbone, and supported capabilities.

Response

{
  "model_name": "atlas-ppi",
  "backbone": "esm2_t33_650M_UR50D",
  "embedding_dim": 1280,
  "supports_pli": true
}

Examples

curl https://api.synthyra.com/v1/model

import requests

response = requests.get("https://api.synthyra.com/v1/model")
print(response.json())

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
metadata = client.model_metadata()

GET

/v1/capabilities

Machine-readable capability registry

Returns a list of all available API capabilities with their endpoints, methods, and whether they are async (job-based).

Response

{
  "capabilities": [
    {
      "name": "network_generation",
      "endpoint": "/v1/generate/network",
      "method": "POST",
      "description": "Generate PPI network...",
      "async_job": true
    }
  ]
}

Examples

curl https://api.synthyra.com/v1/capabilities

import requests

response = requests.get("https://api.synthyra.com/v1/capabilities")
for cap in response.json()["capabilities"]:
    print(f"{cap['method']} {cap['endpoint']} - {cap['name']}")

GET

/v1/proteome/organisms

List available reference organisms

Returns the list of reference organisms with pre-embedded proteomes available for network generation and proteome queries.

Response

{
  "organisms": [
    {
      "key": "human",
      "display_name": "Homo sapiens",
      "proteome_id": "UP000005640",
      "organism_id": "9606"
    }
  ]
}

Examples

curl https://api.synthyra.com/v1/proteome/organisms

import requests

response = requests.get("https://api.synthyra.com/v1/proteome/organisms")
for org in response.json()["organisms"]:
    print(f"{org['key']}: {org['display_name']}")

Scoring

POST

/v1/score/pairs

Score interaction pairs

Score pairwise interactions between matched A-side and B-side inputs. Each A[i] is scored against B[i]. Returns quantized confidence scores (0-100). Optionally cross-reference pairs against STRING/BioGRID databases.

Parameters

Name	Type	Default	Description
inputs_a required	string[]	-	A-side protein sequences
inputs_b required	string[]	-	B-side protein sequences (or SELFIES for PLI)
ids_a optional	string[]	-	UniProt accessions for A-side (required if cross_reference=true)
ids_b optional	string[]	-	UniProt accessions for B-side (required if cross_reference=true)
both_directions optional	boolean	-	Score AB^T and BA^T, average the results
cross_reference optional	boolean	false	Cross-reference pairs against STRING/BioGRID in parallel

Response

{
  "scores": [85, 12, 97],
  "xref": {
    "pairs": [
      {"in_string": true, "in_biogrid": false, "in_biogrid_mv": false}
    ]
  }
}

Examples

curl -X POST https://api.synthyra.com/v1/score/pairs \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs_a": ["MKTLLILAVL..."],
    "inputs_b": ["MGSSHHHHH..."],
    "both_directions": true
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/score/pairs",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "inputs_a": ["MKTLLILAVL..."],
    "inputs_b": ["MGSSHHHHH..."],
    "both_directions": True,
})
print(response.json()["scores"])

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
result = client.score_pairs(
    inputs_a=["MKTLLILAVL..."],
    inputs_b=["MGSSHHHHH..."],
)
print(result["scores"])

POST

/v1/score/matrix

Score interaction matrix

Score all-vs-all interactions between A-side and B-side input sets. Returns an NxM matrix of quantized confidence scores (0-100). A 20,000 x 20,000 matrix completes in under one second.

Parameters

Name	Type	Default	Description
inputs_a required	string[]	-	A-side protein sequences
inputs_b required	string[]	-	B-side protein sequences
ids_a optional	string[]	-	Optional IDs for A-side
ids_b optional	string[]	-	Optional IDs for B-side
both_directions optional	boolean	-	Score bidirectionally and average

Response

{
  "matrix": [[85, 12], [43, 97]],
  "ids_a": ["P04637", "P53_HUMAN"],
  "ids_b": ["Q9Y6K9", "O95817"]
}

Examples

curl -X POST https://api.synthyra.com/v1/score/matrix \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs_a": ["MKTL...", "MGSS..."],
    "inputs_b": ["MVSK...", "MDFF..."]
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/score/matrix",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "inputs_a": ["MKTL...", "MGSS..."],
    "inputs_b": ["MVSK...", "MDFF..."],
})
matrix = response.json()["matrix"]

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
result = client.score_matrix(
    inputs_a=["MKTL...", "MGSS..."],
    inputs_b=["MVSK...", "MDFF..."],
)

POST

/v1/proteome/query

Score queries against reference proteome

Score query protein sequences against an entire pre-embedded reference proteome. Returns the full score vector for each query against all proteome members.

Parameters

Name	Type	Default	Description
organism required	string	-	Organism key (e.g. "human", "mouse", "ecoli")
query_sequences required	object[]	-	Array of {id, sequence} objects
task_type optional	string	"ppi"	"ppi" or "pli"

Response

{
  "scores": [[85, 12, 43, ...]],
  "proteome_ids": ["P04637", "Q9Y6K9", ...],
  "query_ids": ["my_protein"]
}

Examples

curl -X POST https://api.synthyra.com/v1/proteome/query \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "organism": "human",
    "query_sequences": [
      {"id": "P04637", "sequence": "MEEPQSDP..."}
    ]
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/proteome/query",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "organism": "human",
    "query_sequences": [
        {"id": "P04637", "sequence": "MEEPQSDP..."}
    ],
})

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
result = client.query_reference_proteome(
    organism="human",
    query_sequences=[{"id": "P04637", "sequence": "MEEPQSDP..."}],
)

Embedding

POST

/v1/embed/a

Embed A-side inputs (proteins)

Generate embeddings for protein sequences using the A-side (protein) encoder. Returns dense vectors suitable for downstream scoring or analysis.

Parameters

Name	Type	Default	Description
inputs required	string[]	-	Protein sequences to embed
ids optional	string[]	-	Optional IDs for the inputs

Response

{
  "embeddings": [[0.12, -0.34, ...], ...],
  "ids": ["seq_0", "seq_1"],
  "dim": 256
}

Examples

curl -X POST https://api.synthyra.com/v1/embed/a \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"inputs": ["MKTLLILAVL..."], "ids": ["p53"]}'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/embed/a",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "inputs": ["MKTLLILAVL..."],
    "ids": ["p53"],
})
embeddings = response.json()["embeddings"]

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
result = client.embed("a", ["MKTLLILAVL..."], ids=["p53"])

POST

/v1/embed/b

Embed B-side inputs (proteins or ligands)

Generate embeddings for B-side inputs. For PPI models, these are protein sequences. For PLI models, these are SELFIES-encoded small molecules.

Parameters

Name	Type	Default	Description
inputs required	string[]	-	Protein sequences or SELFIES strings
ids optional	string[]	-	Optional IDs for the inputs

Response

{
  "embeddings": [[0.12, -0.34, ...], ...],
  "ids": ["lig_0"],
  "dim": 256
}

Examples

curl -X POST https://api.synthyra.com/v1/embed/b \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"inputs": ["MGSSHHHHH..."]}'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/embed/b",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "inputs": ["MGSSHHHHH..."],
})

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
result = client.embed("b", ["MGSSHHHHH..."])

Networks

POST

/v1/generate/network

ASYNC

Generate interaction network (async)

Generate a protein interaction network by scoring query sequences against a reference proteome with BFS neighbor expansion. Supports PPI, PLI, and drug screening task types. Returns a job ID to poll for results. Results include the network graph, an expansion envelope for client-side threshold adjustment, optional enrichment, and actome edges for visualization.

Parameters

Name	Type	Default	Description
organism required	string	-	Reference organism (e.g. "human", "mouse", "ecoli", "yeast", "rat")
query_sequences required	object[]	-	Array of {id, sequence} objects
confidence_threshold optional	number	0.7	Minimum confidence score (0.0-1.0) for including edges
neighbor_depth optional	number	1	BFS expansion depth for neighbor discovery
max_neighbors optional	number	1000	Maximum neighbors per query protein
task_type optional	string	"ppi"	"ppi", "pli", or "drug_screen"
cross_reference_string optional	boolean	true	Cross-reference edges against STRING/BioGRID
run_enrichment optional	boolean	false	Run GO/KEGG/Reactome enrichment on discovered proteins
enrichment_libraries optional	string[]	-	Enrichment libraries to use (default: all available)

Response

{
  "job_id": "abc123...",
  "status": "Waiting"
}

// Poll GET /v1/job?job_id=abc123 for result:
{
  "status": "Complete",
  "result": {
    "network": {
      "nodes": [{"id": "P04637", "name": "TP53", "organism": "human", ...}],
      "edges": [{"source": "P04637", "target": "Q9Y6K9", "confidence": 85, "is_novel": true, "in_string": false, ...}]
    },
    "envelope": {
      "proteome_scores": [85, 12, ...],
      "proteome_ids": ["P04637", ...],
      "candidate_ids": [...],
      "candidate_matrix": [[...]]
    },
    "enrichment": { "terms": [...] },
    "actome_edges": { "nodes": [...], "edges": [...] }
  }
}

Examples

curl -X POST https://api.synthyra.com/v1/generate/network \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "organism": "human",
    "query_sequences": [
      {"id": "P04637", "sequence": "MEEPQSDP..."}
    ],
    "confidence_threshold": 0.7,
    "task_type": "ppi",
    "run_enrichment": true
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

import time

# Submit job
response = requests.post("https://api.synthyra.com/v1/generate/network",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "organism": "human",
    "query_sequences": [{"id": "P04637", "sequence": "MEEPQSDP..."}],
    "confidence_threshold": 0.7,
})
job_id = response.json()["job_id"]

# Poll for result
while True:
    status = requests.get(f"https://api.synthyra.com/v1/job?job_id={job_id}").json()
    if status["status"] in ("Complete", "Failed"):
        break
    time.sleep(2)

network = status["result"]["network"]
print(f"Nodes: {len(network['nodes'])}, Edges: {len(network['edges'])}")

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
result = client.generate_network(
    organism="human",
    query_sequences=[{"id": "P04637", "sequence": "MEEPQSDP..."}],
    confidence_threshold=0.7,
    run_enrichment=True,
)
print(f"Nodes: {len(result['network']['nodes'])}")

Enrichment

POST

/v1/generate/enrichment

ASYNC

Run enrichment analysis (async)

Run GO (BP/MF/CC), KEGG, and Reactome functional enrichment analysis on a gene list. Returns significantly enriched terms with p-values and gene overlaps.

Parameters

Name	Type	Default	Description
gene_list required	string[]	-	List of gene symbols or UniProt accessions
organism required	string	-	Organism key (e.g. "human")
libraries required	string[]	-	Enrichment libraries (e.g. ["GO_BP", "GO_MF", "GO_CC", "KEGG", "Reactome"])
p_threshold optional	number	0.05	P-value threshold for significance

Response

{
  "job_id": "abc123...",
  "status": "Waiting"
}

// Result when complete:
{
  "terms": [
    {
      "term": "apoptotic process (GO:0006915)",
      "library": "GO_BP",
      "p_value": 1.2e-8,
      "adjusted_p_value": 3.4e-6,
      "genes": ["TP53", "BCL2", "BAX"],
      "gene_count": 3
    }
  ]
}

Examples

curl -X POST https://api.synthyra.com/v1/generate/enrichment \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "gene_list": ["TP53", "MDM2", "BCL2", "BAX"],
    "organism": "human",
    "libraries": ["GO_BP", "KEGG", "Reactome"]
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/generate/enrichment",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "gene_list": ["TP53", "MDM2", "BCL2", "BAX"],
    "organism": "human",
    "libraries": ["GO_BP", "KEGG", "Reactome"],
})
job_id = response.json()["job_id"]

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
result = client.run_enrichment(
    gene_list=["TP53", "MDM2", "BCL2", "BAX"],
    organism="human",
    libraries=["GO_BP", "KEGG", "Reactome"],
)

DFA / Oracles

POST

/v1/generate/dfa

ASYNC

Run Direct Functional Annotation (async)

Run all available oracle probes and ESMFold2 structure prediction on a protein sequence. Returns per-residue attributions, scalar/vector scores, predicted pLDDT, and structure coordinates.

Parameters

Name	Type	Default	Description
sequence required	string	-	Protein sequence (single-letter amino acid codes)
protein_id optional	string	""	Optional identifier for the protein
run_structure optional	boolean	true	Run ESMFold2 structure prediction
run_oracles optional	boolean	true	Run oracle probe predictions
run_camp optional	boolean	true	Run CAMP functional annotation retrieval
run_translator optional	boolean	true	Run Translator sequence-to-annotation prediction

Response

{
  "job_id": "abc123...",
  "status": "Waiting"
}

// Result when complete:
{
  "protein_id": "P04637",
  "sequence": "MEEPQSDP...",
  "plddt": 72.5,
  "cif_string": "data_complex\n#\n_atom_site...",
  "oracle_predictions": [
    {
      "oracle_name": "ecoli-expression",
      "score": 0.82,
      "score_mode": "regression",
      "attributions": [[0.1, -0.05, ...]]
    }
  ]
}

Examples

curl -X POST https://api.synthyra.com/v1/generate/dfa \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "sequence": "MEEPQSDPSVEPPLSQETFSDLWKLLPENN...",
    "protein_id": "P04637"
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/generate/dfa",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "sequence": "MEEPQSDPSVEPPLSQETFSDLWKLLPENN...",
    "protein_id": "P04637",
})
job_id = response.json()["job_id"]

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
result = client.run_dfa(
    sequence="MEEPQSDPSVEPPLSQETFSDLWKLLPENN...",
    protein_id="P04637",
)

POST

/v1/dfa/run

Run DFA synchronously

Same as /v1/generate/dfa but returns the result directly instead of creating an async job. Useful for programmatic access where you want to wait for the result inline.

Parameters

Name	Type	Default	Description
sequence required	string	-	Protein sequence
protein_id optional	string	""	Optional protein identifier
run_structure optional	boolean	true	Run ESMFold2 structure prediction
run_oracles optional	boolean	true	Run oracle probe predictions
run_camp optional	boolean	true	Run CAMP functional annotation retrieval
run_translator optional	boolean	true	Run Translator sequence-to-annotation prediction

Response

{
  "protein_id": "P04637",
  "sequence": "MEEPQSDP...",
  "plddt": 72.5,
  "cif_string": "data_complex\n#\n_atom_site...",
  "oracle_predictions": [...]
}

Examples

curl -X POST https://api.synthyra.com/v1/dfa/run \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sequence": "MEEPQSDP...", "protein_id": "P04637"}'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/dfa/run",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "sequence": "MEEPQSDP...",
    "protein_id": "P04637",
})
result = response.json()
print(f"pLDDT: {result['plddt']}")

Folding (ESMFold2)

POST

/v1/fold

Predict structure synchronously (ESMFold2)

Predict 3D structure for protein sequences using FastPLMs ESMFold2. Defaults to ESMFold2-Fast; set options.model to "full" for Synthyra/ESMFold2. Use /v1/fold/async for batches.

Parameters

Name	Type	Default	Description
complexes required	array	-	List of complexes. Each: {name?, chains: [{sequence, type: "protein"\|"dna"\|"rna", id?}], ligands?: [{smiles}\|{ccd}]}
options.model optional	"fast" \| "full"	"fast"	ESMFold2 model alias. "fast" = Synthyra/ESMFold2-Fast; "full" = Synthyra/ESMFold2.
options.sample optional	integer	1	Number of diffusion samples; highest-pLDDT sample is returned per seed
options.seeds optional	integer[]	[0]	Random seeds; multiple seeds return multiple rows per complex
options.return_pdb optional	boolean	true	Inline PDB string in each row
options.return_cifs optional	boolean	false	Inline mmCIF string and base64-encoded mmCIF in each row

Response

{
  "rows": [
    {
      "status": "ok",
      "row_index": 0,
      "name": "query",
      "model": "fast",
      "model_id": "Synthyra/ESMFold2-Fast",
      "sample_name": "query_seed0",
      "seed": 0,
      "sample_rank": 0,
      "plddt": 0.87,
      "ranking_score": 0.87,
      "ptm": 0.88,
      "iptm": 0.75,
      "pdb_string": "ATOM ..."
    }
  ],
  "elapsed_seconds": 42.1,
  "status_counts": { "ok": 1, "error": 0 },
  "request_summary": {
    "complex_count": 1,
    "use_msa": false,
    "model": "fast",
    "model_id": "Synthyra/ESMFold2-Fast",
    "seeds": [0],
    "sample": 1
  }
}

Examples

curl -X POST https://api.synthyra.com/v1/fold \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "complexes": [{"chains": [{"sequence": "MQIFVKTLTGKTITLEVEPSDTIENVKAKIQDKEGIPPDQQRLIFAGKQLEDGRTLSDYNIQKESTLHLVLRLRGG", "type": "protein"}]}],
    "options": {"model": "fast", "sample": 1}
  }'

import requests, os

response = requests.post("https://api.synthyra.com/v1/fold",
    headers={"Authorization": f"Bearer {os.environ['SYNTHYRA_API_KEY']}"},
    json={
        "complexes": [{"chains": [{"sequence": "MQIFVKT...", "type": "protein"}]}],
        "options": {"model": "fast", "sample": 1},
    },
    timeout=900,
)
rows = response.json()["rows"]
best = max((r for r in rows if r["status"] == "ok"), key=lambda r: r["plddt"])
print(best["pdb_string"][:80])
print(f"pLDDT: {best['plddt']:.3f}")

POST

/v1/fold/async

ASYNC

Predict structure (async job)

Same as /v1/fold but returns immediately with a job_id. Poll /v1/job?job_id={job_id} for status. Same pricing as /v1/fold.

Parameters

Name	Type	Default	Description
complexes required	array	-	List of complexes (same shape as /v1/fold)
options optional	object	-	Same options as /v1/fold (model, sample, seeds, return_pdb, return_cifs, etc.)
name optional	string	-	Optional display label for the job

Response

{
  "job_id": "abc123...",
  "status": "queued"
}

// Poll /v1/job/{job_id} until status == "complete" or "failed".
// On completion, the result field contains the same shape as /v1/fold's response.

Examples

curl -X POST https://api.synthyra.com/v1/fold/async \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "complexes": [
      {"name": "antibody-antigen", "chains": [
        {"sequence": "QVQLVQSGAEVKKPGAS...", "type": "protein", "id": "H"},
        {"sequence": "DIQMTQSPSSLSASV...", "type": "protein", "id": "L"},
        {"sequence": "MFVFLVLLPLVSSQCVN...", "type": "protein", "id": "A"}
      ]}
    ],
    "options": {"model": "full", "sample": 1}
  }'

import requests, os, time

api_key = os.environ['SYNTHYRA_API_KEY']
r = requests.post("https://api.synthyra.com/v1/fold/async",
    headers={"Authorization": f"Bearer {api_key}"},
    json={"complexes": [...], "options": {"model": "full", "sample": 1}},
)
job_id = r.json()["job_id"]

while True:
    status = requests.get("https://api.synthyra.com/v1/job",
        params={"job_id": job_id},
        headers={"Authorization": f"Bearer {api_key}"}).json()
    if status["status"] in ("complete", "failed"):
        break
    time.sleep(10)
print(status)

Coordinated Analysis

POST

/v1/generate/coordinated

ASYNC

Run full coordinated analysis (async)

Run DFA + network + enrichment in parallel for a single protein. Orchestrates all analysis types into a single async job, returning combined results when complete.

Parameters

Name	Type	Default	Description
sequence required	string	-	Protein sequence (single-letter amino acid codes)
protein_id required	string	-	Identifier for the protein
organism optional	string	"human"	Reference organism
run_structure optional	boolean	true	Run protein structure prediction
run_oracles optional	boolean	true	Run oracle probe predictions
run_camp optional	boolean	true	Run CAMP functional annotation retrieval
run_translator optional	boolean	true	Run Translator sequence-to-annotation prediction
run_network optional	boolean	true	Run interaction network generation
run_enrichment optional	boolean	true	Run functional enrichment analysis
confidence_threshold optional	number	0.7	Minimum confidence score for network edges

Response

{
  "job_id": "abc123...",
  "status": "Waiting"
}

Examples

curl -X POST https://api.synthyra.com/v1/generate/coordinated \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "sequence": "MEEPQSDPSVEPPLSQETFSDLWKLLPENN...",
    "protein_id": "P04637",
    "organism": "human",
    "confidence_threshold": 0.7
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

import time

response = requests.post("https://api.synthyra.com/v1/generate/coordinated",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "sequence": "MEEPQSDPSVEPPLSQETFSDLWKLLPENN...",
    "protein_id": "P04637",
    "organism": "human",
})
job_id = response.json()["job_id"]

# Poll for result
while True:
    status = requests.get(f"https://api.synthyra.com/v1/job?job_id={job_id}").json()
    if status["status"] in ("Complete", "Failed"):
        break
    time.sleep(2)

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
result = client.generate_coordinated(
    sequence="MEEPQSDPSVEPPLSQETFSDLWKLLPENN...",
    protein_id="P04637",
    organism="human",
)

Cross-Reference

POST

/v1/xref/pairs

Cross-reference pairs against databases

Look up protein pairs in STRING, BioGRID, and BioGRID-MV interaction databases. Returns boolean flags indicating whether each pair exists in each database.

Parameters

Name	Type	Default	Description
ids_a required	string[]	-	UniProt accessions for A-side proteins
ids_b required	string[]	-	UniProt accessions for B-side proteins

Response

{
  "xref": [
    {
      "id_a": "P04637",
      "id_b": "Q00987",
      "in_string": true,
      "in_biogrid": true,
      "in_biogrid_mv": false
    }
  ]
}

Examples

curl -X POST https://api.synthyra.com/v1/xref/pairs \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ids_a": ["P04637", "P38398"],
    "ids_b": ["Q00987", "P51587"]
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/xref/pairs",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "ids_a": ["P04637", "P38398"],
    "ids_b": ["Q00987", "P51587"],
})
for pair in response.json()["xref"]:
    print(f"{pair['id_a']}-{pair['id_b']}: STRING={pair['in_string']}")

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas-dev")
result = client.xref_pairs(
    ids_a=["P04637", "P38398"],
    ids_b=["Q00987", "P51587"],
)

Translator

POST

/v1/translator/run

Annotate sequences with functional terms

For each input sequence, returns top-K natural-language functional annotations (GO biological process, GO molecular function, GO cellular component, EC numbers, family memberships, etc.) with confidence scores 0-100. Powered by the Translator model trained on the Annotation Vocabulary. Billed per sequence (one token = one sequence annotated). Batched: pass up to 64 sequences per call.

Parameters

Name	Type	Default	Description
sequences required	string[]	-	Protein sequences in single-letter amino-acid codes (1-64 per call, max 2048 residues each)
ids required	string[]	-	Caller-supplied IDs, same length as sequences. Echoed back in each result row.
num_annotations optional	number	32	Number of annotation positions to decode per sequence (1-64).
top_k optional	number	3	Top-K annotation candidates per position; deduplicated across positions (1-10).

Response

{
  "job_id": "abcd1234...",
  "results": [
    {
      "protein_id": "TP53",
      "annotations": [
        { "annotation_id": "GO:0006915", "name": "apoptotic process", "aspect": "Biological Process", "confidence": 97 },
        { "annotation_id": "GO:0003700", "name": "DNA-binding transcription factor activity", "aspect": "Molecular Function", "confidence": 94 },
        { "annotation_id": "GO:0005634", "name": "nucleus", "aspect": "Cellular Component", "confidence": 91 }
      ]
    }
  ]
}

Examples

curl -X POST https://api.synthyra.com/v1/translator/run \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sequences": ["MEEPQSDPSV..."], "ids": ["TP53"], "top_k": 3}'

import requests

api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post(
    "https://api.synthyra.com/v1/translator/run",
    headers={"Authorization": f"Bearer {api_key}"},
    json={"sequences": ["MEEPQSDPSV..."], "ids": ["TP53"], "top_k": 3},
)
for row in response.json()["results"]:
    print(row["protein_id"], row["annotations"][:3])

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas")
results = client.run_translator(
    sequences=["MEEPQSDPSV..."],
    ids=["TP53"],
    top_k=3,
)

Oracles

POST

/v1/oracles/run

Run all 14 InterpNet probes on each sequence

For each input sequence, runs all 14 InterpNet oracle probes and returns a per-oracle prediction per sequence. Valid probe identifiers: realness, solubility, soluprot, temperature-stability, ecoli-expression, kcat, ph, Subcellular, taxon, homodimer, ec_rigor, ec_general, go_rigor, go_general. Billed per sequence (one token = one sequence x all 14 probes). Batched: pass up to 64 sequences per call.

Parameters

Name	Type	Default	Description
sequences required	string[]	-	Protein sequences (1-64 per call)
ids required	string[]	-	Caller-supplied IDs, same length as sequences. Echoed back in each result row.

Response

{
  "job_id": "abcd1234...",
  "results": [
    {
      "protein_id": "TP53",
      "predictions": [
        { "oracle_name": "realness", "score": 0.97, "score_mode": "binary_prob", "label_names": ["Synthetic", "Natural"] },
        { "oracle_name": "solubility", "score": 0.62, "score_mode": "binary_prob", "label_names": ["Insoluble", "Soluble"] },
        { "oracle_name": "Subcellular", "score": [0.05, 0.78, 0.02, ...], "score_mode": "multilabel_sigmoid", "label_names": ["Cytoplasm", "Nucleus", ...] },
        { "oracle_name": "ec_general", "score": [...], "score_mode": "multiclass_prob", "label_names": [...] }
      ]
    }
  ]
}

Examples

curl -X POST https://api.synthyra.com/v1/oracles/run \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sequences": ["MEEPQSDPSV..."], "ids": ["TP53"]}'

import requests

api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post(
    "https://api.synthyra.com/v1/oracles/run",
    headers={"Authorization": f"Bearer {api_key}"},
    json={"sequences": ["MEEPQSDPSV..."], "ids": ["TP53"]},
)
for row in response.json()["results"]:
    for pred in row["predictions"]:
        print(row["protein_id"], pred["oracle_name"], pred["score"])

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas")
results = client.run_oracles(
    sequences=["MEEPQSDPSV..."],
    ids=["TP53"],
)

CAMP

POST

/v1/camp/run

Score sequences against functional annotations

Run CAMP (Contextual Annotation via Molecular Profiling) to score protein sequences against pre-embedded SwissProt functional annotations via vector retrieval. Returns top-K annotation hits with similarity scores for each input sequence. Billed per sequence (one token = one sequence scored). Batched: pass up to 64 sequences per call.

Parameters

Name	Type	Default	Description
sequences required	string[]	-	Protein sequences to annotate (1-64 per call)
ids required	string[]	-	Identifiers for each sequence (same length as sequences)
top_k optional	number	10	Number of top annotation hits to return per sequence (1-50)

Response

{
  "job_id": "abcd1234...",
  "results": [
    {
      "protein_id": "P04637",
      "annotations": [
        {"annotation_id": "GO:0006915", "name": "apoptotic process", "aspect": "Biological Process", "score": 0.94},
        {"annotation_id": "GO:0005634", "name": "nucleus", "aspect": "Cellular Component", "score": 0.89}
      ]
    }
  ]
}

Examples

curl -X POST https://api.synthyra.com/v1/camp/run \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "sequences": ["MEEPQSDPSVEPPLSQETFSDLWKLLPENN..."],
    "ids": ["P04637"],
    "top_k": 10
  }'

import requests

api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post(
    "https://api.synthyra.com/v1/camp/run",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
        "sequences": ["MEEPQSDPSVEPPLSQETFSDLWKLLPENN..."],
        "ids": ["P04637"],
        "top_k": 10,
    },
)
for result in response.json()["results"]:
    print(f"{result['protein_id']}: {result['annotations'][0]['name']}")

from atlas.serving.client import AtlasModalClient

client = AtlasModalClient("synth-atlas")
results = client.run_camp(
    sequences=["MEEPQSDPSV..."],
    ids=["P04637"],
    top_k=10,
)

POST

/v1/camp/msa

Run MSA on query + CAMP hit sequences

Perform multiple sequence alignment between a query protein and sequences retrieved from CAMP hits. Useful for validating functional similarity through sequence conservation.

Parameters

Name	Type	Default	Description
query_name required	string	-	Identifier for the query sequence
query_sequence required	string	-	Query protein sequence
hit_names required	string[]	-	Identifiers for the CAMP hit sequences
hit_sequences required	string[]	-	Protein sequences from CAMP hits

Response

{
  "alignment": {
    "sequences": [
      {"name": "P04637", "aligned": "MEEPQSDP--SVEPPL..."},
      {"name": "Q9Y6K9", "aligned": "M--PQSDPAVSVEPPL..."}
    ],
    "conservation": [1.0, 0.8, 0.6, ...]
  }
}

Examples

curl -X POST https://api.synthyra.com/v1/camp/msa \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query_name": "P04637",
    "query_sequence": "MEEPQSDP...",
    "hit_names": ["Q9Y6K9", "P10415"],
    "hit_sequences": ["MPQSDPAV...", "MSQSNREL..."]
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/camp/msa",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "query_name": "P04637",
    "query_sequence": "MEEPQSDP...",
    "hit_names": ["Q9Y6K9", "P10415"],
    "hit_sequences": ["MPQSDPAV...", "MSQSNREL..."],
})
alignment = response.json()["alignment"]

Foldseek

POST

/v1/foldseek/3di

Convert structure to Foldseek 3Di tokens

Convert an mmCIF or PDB structure string into Foldseek 3Di structural alphabet tokens. Used for structure-based similarity searches and structural annotation.

Parameters

Name	Type	Default	Description
structure_string required	string	-	mmCIF or PDB structure text. The legacy "pdb_string" key is also accepted.

Response

{
  "tokens_3di": "DVVLSQQSV..."
}

Examples

curl -X POST https://api.synthyra.com/v1/foldseek/3di \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"structure_string": "data_complex\n#\n_atom_site..."}'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/foldseek/3di",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
        "structure_string": open("structure.cif").read(),
    })
tokens = response.json()["tokens_3di"]
print(f"3Di tokens: {tokens[:50]}...")

Actomes

POST

/v1/actome/create

ASYNC

Create a new actome (async)

Create a new actome by embedding query proteins and computing their all-vs-all interaction matrix against a reference proteome. Supports intra (1 set), inter (2 sets), and multi (3+ sets) modes.

Parameters

Name	Type	Default	Description
organism required	string	-	Reference organism key
query_sets required	object[]	-	Array of {label, sequences: [{id, sequence}]} objects
custom_proteome_id optional	string	-	Use a custom uploaded proteome instead of reference

Response

{"job_id": "abc123...", "status": "Waiting"}

Examples

curl -X POST https://api.synthyra.com/v1/actome/create \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "organism": "human",
    "query_sets": [{
      "label": "kinases",
      "sequences": [{"id": "P04637", "sequence": "MEEPQ..."}]
    }]
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/actome/create",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "organism": "human",
    "query_sets": [{
        "label": "kinases",
        "sequences": [{"id": "P04637", "sequence": "MEEPQ..."}],
    }],
})

GET

/v1/actome/{actome_id}

Get actome metadata

Returns metadata about an actome including protein count, organism, and creation time.

Response

{
  "actome_id": "abc123",
  "organism": "human",
  "protein_count": 150,
  "created_at": "2025-01-15T12:00:00Z"
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" https://api.synthyra.com/v1/actome/abc123

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/actome/abc123",
    headers={"Authorization": f"Bearer {api_key}"})

GET

/v1/actome/{actome_id}/row

Pull a row by protein ID

Retrieve the interaction score vector for a single protein against all other proteins in the actome.

Parameters

Name	Type	Default	Description
protein_id required	string	-	Protein ID to look up
top_k optional	number	100	Return only top-K highest scores

Response

{
  "protein_id": "P04637",
  "scores": [{"id": "Q00987", "score": 85}, ...],
  "total_proteins": 20000
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" "https://api.synthyra.com/v1/actome/abc123/row?protein_id=P04637&top_k=50"

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/actome/abc123/row",
    headers={"Authorization": f"Bearer {api_key}"}, params={
    "protein_id": "P04637", "top_k": 50,
})

GET

/v1/actome/{actome_id}/edges

Get sparse edges via graduated BFS

Returns edges from an actome using tier-based BFS expansion with graduated confidence thresholds. Includes database-only edges from STRING/BioGRID.

Parameters

Name	Type	Default	Description
query_ids optional	string	-	Comma-separated query protein IDs for BFS seed
tier_thresholds optional	string	-	Comma-separated confidence thresholds per tier
xref_databases optional	string	"string,biogrid,biogrid_mv"	Comma-separated xref databases for db-only edges
max_edges optional	number	500000	Maximum number of edges to return

Response

{
  "edges": [{"s": "P04637", "t": "Q00987", "c": 85, "st": true, "bg": false}],
  "node_tiers": {"P04637": 0, "Q00987": 1},
  "metadata": {"total_edges": 1234}
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" "https://api.synthyra.com/v1/actome/abc123/edges?query_ids=P04637&tier_thresholds=70,50,30"

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/actome/abc123/edges",
    headers={"Authorization": f"Bearer {api_key}"}, params={
    "query_ids": "P04637",
    "tier_thresholds": "70,50,30",
})

POST

/v1/actome/cluster

Cluster an actome matrix

Apply hierarchical clustering to an actome interaction matrix. Returns reordered indices and cluster labels for heatmap visualization.

Parameters

Name	Type	Default	Description
actome_id required	string	-	Actome to cluster
method optional	string	"hierarchical"	Clustering method
n_clusters optional	number	8	Number of clusters
linkage_method optional	string	"ward"	Linkage method for hierarchical clustering

Response

{
  "row_order": [3, 1, 0, 2, ...],
  "cluster_labels": [0, 0, 1, 1, ...],
  "col_order": [3, 1, 0, 2, ...],
  "linkage_matrix": [...]
}

Examples

curl -X POST https://api.synthyra.com/v1/actome/cluster \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"actome_id": "abc123", "n_clusters": 5}'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/actome/cluster",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "actome_id": "abc123",
    "n_clusters": 5,
})

DELETE

/v1/actome/{actome_id}

Delete an actome

Permanently delete an actome and all its stored data.

Response

{"message": "Actome deleted"}

Examples

curl -X DELETE https://api.synthyra.com/v1/actome/abc123   -H "Authorization: Bearer $SYNTHYRA_API_KEY"

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.delete("https://api.synthyra.com/v1/actome/abc123",
    headers={"Authorization": f"Bearer {api_key}"})

POST

/v1/actome/add

ASYNC

Add proteins to existing actome (async)

Embed additional proteins and add them to an existing actome, expanding the interaction matrix. Returns a job ID to poll for completion.

Parameters

Name	Type	Default	Description
actome_id required	string	-	ID of the existing actome to expand
sequences required	object[]	-	Array of {id, sequence} objects to add

Response

{"job_id": "abc123...", "status": "Waiting"}

Examples

curl -X POST https://api.synthyra.com/v1/actome/add \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "actome_id": "abc123",
    "sequences": [{"id": "P38398", "sequence": "MDLSA..."}]
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/actome/add",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "actome_id": "abc123",
    "sequences": [{"id": "P38398", "sequence": "MDLSA..."}],
})
job_id = response.json()["job_id"]

POST

/v1/actome/{actome_id}/rows

Batch fetch multiple protein rows

Retrieve interaction score vectors for multiple proteins in a single request. Returns top-K scores for each requested protein.

Parameters

Name	Type	Default	Description
protein_ids required	string[]	-	Protein IDs to look up
top_k optional	number	100	Return only top-K highest scores per protein

Response

{
  "rows": [
    {
      "protein_id": "P04637",
      "scores": [{"id": "Q00987", "score": 85}, ...]
    },
    {
      "protein_id": "P38398",
      "scores": [{"id": "P51587", "score": 91}, ...]
    }
  ]
}

Examples

curl -X POST https://api.synthyra.com/v1/actome/abc123/rows \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"protein_ids": ["P04637", "P38398"], "top_k": 50}'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/actome/abc123/rows",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "protein_ids": ["P04637", "P38398"],
    "top_k": 50,
})
for row in response.json()["rows"]:
    print(f"{row['protein_id']}: {len(row['scores'])} interactions")

GET

/v1/actome/{actome_id}/matrix

Get actome submatrix

Retrieve a submatrix of interaction scores for a subset of proteins in the actome. If no protein IDs are specified, returns the full matrix.

Parameters

Name	Type	Default	Description
protein_ids optional	string	-	Comma-separated protein IDs for submatrix extraction

Response

{
  "matrix": [[100, 85, 43], [85, 100, 67], [43, 67, 100]],
  "protein_ids": ["P04637", "Q00987", "P38398"]
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" "https://api.synthyra.com/v1/actome/abc123/matrix?protein_ids=P04637,Q00987,P38398"

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/actome/abc123/matrix",
    headers={"Authorization": f"Bearer {api_key}"}, params={
    "protein_ids": "P04637,Q00987,P38398",
})
matrix = response.json()["matrix"]

POST

/v1/actome/full

ASYNC

Compute full (Q+P) x (Q+P) actome

Compute the full all-vs-all interaction matrix for query proteins concatenated with a reference proteome. Produces a square uint8 matrix where both query-vs-query and query-vs-proteome interactions are scored.

Parameters

Name	Type	Default	Description
organism required	string	-	Reference organism key
query_sequences required	object[]	-	Array of {id, sequence} objects
threshold optional	number	50	Minimum score threshold for stored edges

Response

{
  "actome_id": "abc123",
  "organism": "human",
  "protein_count": 20150,
  "query_count": 150,
  "proteome_count": 20000
}

Examples

curl -X POST https://api.synthyra.com/v1/actome/full \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "organism": "human",
    "query_sequences": [{"id": "P04637", "sequence": "MEEPQ..."}],
    "threshold": 50
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/actome/full",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "organism": "human",
    "query_sequences": [{"id": "P04637", "sequence": "MEEPQ..."}],
    "threshold": 50,
})
print(response.json()["actome_id"])

GET

/v1/actome/{actome_id}/heatmap

Clustered heatmap for subnetwork

Generate a clustered heatmap visualization for a subset of proteins in the actome. Returns a base64-encoded PNG image.

Parameters

Name	Type	Default	Description
node_indices optional	string	-	Comma-separated integer indices for subnetwork selection

Response

{
  "image": "data:image/png;base64,iVBORw0KGgo...",
  "protein_ids": ["P04637", "Q00987", ...],
  "cluster_labels": [0, 0, 1, 1, ...]
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" "https://api.synthyra.com/v1/actome/abc123/heatmap?node_indices=0,1,2,5,8"

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

import base64

response = requests.get("https://api.synthyra.com/v1/actome/abc123/heatmap",
    headers={"Authorization": f"Bearer {api_key}"}, params={
    "node_indices": "0,1,2,5,8",
})
image_data = response.json()["image"]

GET

/v1/actome/{actome_id}/overview_png

Full actome heatmap PNG

Generate a full clustered heatmap and score distribution overview for the entire actome. Returns a base64-encoded PNG image with the same plots used in evaluation.

Response

{
  "image": "data:image/png;base64,iVBORw0KGgo..."
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" https://api.synthyra.com/v1/actome/abc123/overview_png

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/actome/abc123/overview_png",
    headers={"Authorization": f"Bearer {api_key}"})
image_data = response.json()["image"]

POST

/v1/actome/upload-proteome

ASYNC

Upload custom proteome (async)

Upload a custom proteome from FASTA text. The proteome is embedded and stored for use in actome creation. Returns a job ID to poll for completion.

Parameters

Name	Type	Default	Description
fasta_text required	string	-	FASTA-format proteome text
title optional	string	-	Optional display name for the proteome

Response

{"job_id": "abc123...", "status": "Waiting"}

Examples

curl -X POST https://api.synthyra.com/v1/actome/upload-proteome \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "fasta_text": ">sp|P04637|P53_HUMAN\nMEEPQSDP...",
    "title": "Custom kinase panel"
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

fasta = open("my_proteome.fasta").read()
response = requests.post("https://api.synthyra.com/v1/actome/upload-proteome",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "fasta_text": fasta,
    "title": "Custom kinase panel",
})
job_id = response.json()["job_id"]

POST

/v1/actome/screen-proteome

ASYNC

Run intra-actome proteome screen (async)

Upload a FASTA proteome and compute its full intra-actome (all-vs-all interaction matrix). Returns a job ID to poll for completion.

Parameters

Name	Type	Default	Description
fasta_text required	string	-	FASTA-format proteome text
title optional	string	-	Optional display name for the screen

Response

{"job_id": "abc123...", "status": "Waiting"}

Examples

curl -X POST https://api.synthyra.com/v1/actome/screen-proteome \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "fasta_text": ">sp|P04637|P53_HUMAN\nMEEPQSDP...",
    "title": "Viral proteome screen"
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

fasta = open("viral_proteome.fasta").read()
response = requests.post("https://api.synthyra.com/v1/actome/screen-proteome",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "fasta_text": fasta,
    "title": "Viral proteome screen",
})
job_id = response.json()["job_id"]

Deep Research

POST

/v1/deep-research/generate

ASYNC

Generate Atlas Deep Research report (async)

Launch an AI agent that orchestrates all Atlas APIs (network analysis, enrichment, DFA, CAMP, structure prediction) for comprehensive protein analysis and produces a detailed PDF report.

Parameters

Name	Type	Default	Description
proteins required	string[]	-	List of UniProt accessions to analyze
input_type optional	string	"uniprot"	Input identifier type
organism optional	string	"human"	Reference organism
include_structure optional	boolean	true	Include ESMFold structure prediction
include_dfa optional	boolean	true	Include DFA oracle predictions

Response

{"job_id": "abc123...", "status": "Waiting"}

Examples

curl -X POST https://api.synthyra.com/v1/deep-research/generate \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"proteins": ["P04637"], "organism": "human"}'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/deep-research/generate",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "proteins": ["P04637"],
    "organism": "human",
})
job_id = response.json()["job_id"]

GET

/v1/deep-research/job/{job_id}

Poll deep research job status

Check the status of a deep research generation job. Returns progress information including current step and completion percentage.

Response

{
  "job_id": "abc123",
  "status": "Running",
  "summary_status": "executing",
  "current_step": "Running network analysis",
  "steps_completed": 3,
  "total_steps": 8
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" https://api.synthyra.com/v1/deep-research/job/abc123

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/deep-research/job/abc123",
    headers={"Authorization": f"Bearer {api_key}"})

GET

/v1/deep-research/download/{job_id}

Download deep research PDF

Download the completed deep research report as a PDF file.

Response

Binary PDF file (application/pdf)

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" -o report.pdf https://api.synthyra.com/v1/deep-research/download/abc123

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/deep-research/download/abc123",
    headers={"Authorization": f"Bearer {api_key}"})
with open("report.pdf", "wb") as f:
    f.write(response.content)

Jobs

GET

/v1/job

Poll job status

Check the status of any async job (network, enrichment, DFA, actome, deep research, coordinated). Returns the full job record including result when complete.

Parameters

Name	Type	Default	Description
job_id required	string	-	Job ID returned by the async endpoint

Response

{
  "job_id": "abc123",
  "status": "Complete",
  "job_type": "network",
  "created_at": "2025-01-15T12:00:00Z",
  "started_at": "2025-01-15T12:00:01Z",
  "completed_at": "2025-01-15T12:00:05Z",
  "result": { ... }
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" "https://api.synthyra.com/v1/job?job_id=abc123"

import requests
import time

job_id = "abc123"
while True:
    response = requests.get(f"https://api.synthyra.com/v1/job", params={"job_id": job_id})
    data = response.json()
    if data["status"] in ("Complete", "Failed"):
        break
    time.sleep(2)

if data["status"] == "Complete":
    result = data["result"]

DSM

4 endpoints

Diffusion Sequence Model

Generate, score, and embed protein sequences using masked diffusion. DSM iteratively denoises masked sequences through multiple remasking strategies to produce high-quality protein variants.

Inference

GET

/v1/dsm/model

DSM model metadata

Returns metadata about the currently deployed DSM model including backbone, checkpoint, and supported remasking strategies.

Response

{
  "model_name": "dsm-esm2-650m",
  "backbone": "esm2_t33_650M_UR50D",
  "remasking_strategies": ["random", "low_confidence", "low_logit", "dual"]
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" https://api.synthyra.com/v1/dsm/model

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/dsm/model",
    headers={"Authorization": f"Bearer {api_key}"})
print(response.json())

POST

/v1/dsm/generate

Generate protein sequences

Generate protein sequences via masked diffusion. Provide seed sequences that will be masked at the specified ratio, then iteratively denoised. With mask_ratio=1.0, generates fully de novo sequences.

Parameters

Name	Type	Default	Description
sequences required	string[]	-	Seed protein sequences (will be masked and regenerated)
mask_ratio optional	number	1.0	Fraction of positions to mask (0.0-1.0). 1.0 = fully de novo
step_divisor optional	number	5	Number of diffusion steps = sequence_length / step_divisor
temperature optional	number	1.0	Sampling temperature. Higher = more diverse
remasking optional	string	"random"	Remasking strategy: "random", "low_confidence", "low_logit", or "dual"
safe_mode optional	boolean	true	Restrict output to canonical amino acids only
max_length optional	number	2048	Maximum sequence length (truncates longer inputs)
return_trajectory optional	boolean	false	Return intermediate sequences at each diffusion step

Response

{
  "generated": [
    "MKTLLILAVLCLGFAQGKPVGKKQ..."
  ],
  "trajectory": [
    ["M<mask><mask>L...", "MK<mask>L...", "MKTL..."]
  ]
}

Examples

curl -X POST https://api.synthyra.com/v1/dsm/generate \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "sequences": ["MKTLLILAVLCLGFAQGKPVG"],
    "mask_ratio": 0.5,
    "temperature": 1.0,
    "remasking": "low_confidence"
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/dsm/generate",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "sequences": ["MKTLLILAVLCLGFAQGKPVG"],
    "mask_ratio": 0.5,
    "temperature": 1.0,
    "remasking": "low_confidence",
})
generated = response.json()["generated"]
print(generated[0])

POST

/v1/dsm/score

Score sequence quality

Compute pseudo-perplexity scores for protein sequences. Lower scores indicate sequences that are more consistent with the learned protein distribution. Useful for ranking generated variants.

Parameters

Name	Type	Default	Description
sequences required	string[]	-	Protein sequences to score
max_length optional	number	2048	Maximum sequence length

Response

{
  "pseudo_perplexities": [3.21, 5.67, 2.89]
}

Examples

curl -X POST https://api.synthyra.com/v1/dsm/score \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sequences": ["MKTLLILAVL...", "MGSSHHHHH..."]}'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/dsm/score",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "sequences": ["MKTLLILAVL...", "MGSSHHHHH..."],
})
scores = response.json()["pseudo_perplexities"]
print(f"Best sequence: index {scores.index(min(scores))}")

POST

/v1/dsm/embed

Generate DSM embeddings

Extract per-sequence embeddings from the DSM backbone. These capture the learned protein representation and can be used for downstream tasks like clustering or similarity search.

Parameters

Name	Type	Default	Description
sequences required	string[]	-	Protein sequences to embed
max_length optional	number	2048	Maximum sequence length
return_format optional	string	"list"	"list" for nested arrays or "base64" for compact binary

Response

{
  "embeddings": [[0.12, -0.34, ...], ...],
  "hidden_dim": 1280
}

Examples

curl -X POST https://api.synthyra.com/v1/dsm/embed \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sequences": ["MKTLLILAVL..."]}'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/dsm/embed",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "sequences": ["MKTLLILAVL..."],
})
embeddings = response.json()["embeddings"]
print(f"Embedding dim: {response.json()['hidden_dim']}")

Protify

11 endpoints

Chemical Language Model Training

Train and evaluate chemical language model probes on custom datasets. Choose from multiple backbones (ESM2, ProtTrans, Ankh, and more) and probe architectures (linear, transformer, Lyra). Jobs run on A100 GPUs with real-time log streaming.

Discovery

GET

/v1/protify/models

List available base models

Returns all available protein language model backbones with their HuggingFace paths and supported probe types.

Response

{
  "models": [
    {
      "family": "esm2",
      "name": "ESM2-650M",
      "hf_path": "facebook/esm2_t33_650M_UR50D",
      "parameters": "650M",
      "supported_probe_types": ["linear", "transformer", "lyra"]
    }
  ]
}

Examples

curl https://api.synthyra.com/v1/protify/models

import requests
response = requests.get("https://api.synthyra.com/v1/protify/models")
for model in response.json()["models"]:
    print(f"{model['name']}: {model['hf_path']}")

GET

/v1/protify/probes

List available probe types

Returns all available probe architectures that can be trained on top of PLM backbones.

Response

{
  "probes": [
    {"name": "linear", "description": "Linear probe on frozen embeddings", "supports_lora": false},
    {"name": "transformer", "description": "Transformer probe with attention layers", "supports_lora": true},
    {"name": "lyra", "description": "Lyra probe with lightweight attention", "supports_lora": true}
  ]
}

Examples

curl https://api.synthyra.com/v1/protify/probes

import requests
response = requests.get("https://api.synthyra.com/v1/protify/probes")

GET

/v1/protify/benchmarks

List available benchmark suites

Returns available benchmark suites for model evaluation including standard benchmarks, vector benchmarks, and ProteinGym.

Response

{
  "benchmarks": [
    {"name": "standard", "description": "Standard benchmark (12 tasks)", "task_type": "mixed", "num_sequences": 12},
    {"name": "vector", "description": "Vector representation benchmark (28 tasks)", "task_type": "mixed", "num_sequences": 28},
    {"name": "proteingym", "description": "ProteinGym DMS zero-shot scoring", "task_type": "regression", "num_sequences": 217}
  ]
}

Examples

curl https://api.synthyra.com/v1/protify/benchmarks

import requests
response = requests.get("https://api.synthyra.com/v1/protify/benchmarks")

GET

/v1/protify/datasets

List available datasets

Returns all supported training/evaluation datasets with their HuggingFace paths.

Response

{
  "datasets": [
    {"name": "thermostability", "hf_path": "Synthyra/thermostability"}
  ]
}

Examples

curl https://api.synthyra.com/v1/protify/datasets

import requests
response = requests.get("https://api.synthyra.com/v1/protify/datasets")

Jobs

POST

/v1/protify/train

ASYNC

Submit training job (async)

Submit a Protify training job. Configure the base model, probe type, dataset, and training hyperparameters. Jobs run on A100 GPUs with up to 24 hours of compute time. Optionally auto-push trained weights to HuggingFace Hub.

Parameters

Name	Type	Default	Description
config required	object	-	Serialized ProtifyJobConfig with model, probe, dataset, and training parameters

Response

{"job_id": "abc123...", "status": "Waiting"}

Examples

curl -X POST https://api.synthyra.com/v1/protify/train \
  -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "config": {
      "base_model": "ESM2-650M",
      "probe_type": "transformer",
      "dataset_name": "thermostability",
      "learning_rate": 1e-4,
      "epochs": 10,
      "batch_size": 32,
      "gpu": "A100"
    }
  }'

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/protify/train",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
    "config": {
        "base_model": "ESM2-650M",
        "probe_type": "transformer",
        "dataset_name": "thermostability",
        "learning_rate": 1e-4,
        "epochs": 10,
    },
})
job_id = response.json()["job_id"]

GET

/v1/protify/download/{job_id}

Download job artifacts (zip)

Download all artifacts for a completed Protify job (metrics, plots, and any trained weights) as a single zip archive. Only the job owner / org can download; the job must be complete.

Parameters

Name	Type	Default	Description
job_id required	string	-	Job ID (path parameter)

Response

<binary application/zip stream>

Examples

curl -L -H "Authorization: Bearer $SYNTHYRA_API_KEY" \
  "https://api.synthyra.com/v1/protify/download/abc123" -o protify_abc123.zip

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/protify/download/abc123",
    headers={"Authorization": f"Bearer {api_key}"})
with open("protify_abc123.zip", "wb") as f:
    f.write(response.content)

GET

/v1/protify/job

Poll job status

Check the status of a Protify training or evaluation job. Returns phase information (embedding, training, evaluating, pushing_to_hub).

Parameters

Name	Type	Default	Description
job_id required	string	-	Job ID to check

Response

{
  "job_id": "abc123",
  "status": "running",
  "phase": "training",
  "gpu_type": "A100",
  "has_checkpoint": true,
  "result": null,
  "error": null
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" "https://api.synthyra.com/v1/protify/job?job_id=abc123"

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/protify/job",
    headers={"Authorization": f"Bearer {api_key}"}, params={"job_id": "abc123"})

GET

/v1/protify/jobs

List all Protify jobs

Returns a list of all Protify jobs sorted by creation time (newest first).

Response

{
  "jobs": [
    {
      "job_id": "abc123",
      "job_type": "protify",
      "status": "Complete",
      "created_at": "2025-01-15T12:00:00Z",
      "phase": "complete",
      "gpu_type": "A100"
    }
  ]
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" https://api.synthyra.com/v1/protify/jobs

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/protify/jobs",
    headers={"Authorization": f"Bearer {api_key}"})
for job in response.json()["jobs"]:
    print(f"{job['job_id']}: {job['status']}")

GET

/v1/protify/logs

Read job log delta

Stream training logs from a running or completed Protify job. Supports chunked reading with offset for real-time log tailing.

Parameters

Name	Type	Default	Description
job_id required	string	-	Job ID
offset optional	number	0	Character offset to read from
max_chars optional	number	50000	Maximum characters to return

Response

{
  "job_id": "abc123",
  "content": "Epoch 1/10: loss=0.453 ...",
  "offset": 0,
  "next_offset": 1234,
  "total_size": 5678
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" "https://api.synthyra.com/v1/protify/logs?job_id=abc123&offset=0"

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/protify/logs",
    headers={"Authorization": f"Bearer {api_key}"}, params={
    "job_id": "abc123", "offset": 0,
})
print(response.json()["content"])

GET

/v1/protify/results

Fetch job results

Retrieve complete results for a finished Protify job including metrics TSV, plot images (base64-encoded), and HuggingFace Hub URL if weights were pushed.

Parameters

Name	Type	Default	Description
job_id required	string	-	Job ID

Response

{
  "job_id": "abc123",
  "status": "Complete",
  "results_tsv": "metric\tvalue\n...",
  "images": [
    {"filename": "loss_curve.png", "data": "base64..."}
  ],
  "hub_url": "https://huggingface.co/Synthyra/...",
  "weights_path": "/synth-protify/weights/abc123"
}

Examples

curl -H "Authorization: Bearer $SYNTHYRA_API_KEY" "https://api.synthyra.com/v1/protify/results?job_id=abc123"

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.get("https://api.synthyra.com/v1/protify/results",
    headers={"Authorization": f"Bearer {api_key}"}, params={"job_id": "abc123"})
result = response.json()
if result["hub_url"]:
    print(f"Model published at: {result['hub_url']}")

POST

/v1/protify/cancel

Cancel a running job

Cancel a running Protify job. Only jobs in Waiting or Running status can be cancelled.

Parameters

Name	Type	Default	Description
job_id required	string	-	Job ID to cancel

Response

{"job_id": "abc123", "status": "Cancelled"}

Examples

curl -X POST "https://api.synthyra.com/v1/protify/cancel?job_id=abc123"   -H "Authorization: Bearer $SYNTHYRA_API_KEY"

import requests
api_key = "sk-..."  # paste your key from synthyra.com/settings?section=api-keys

response = requests.post("https://api.synthyra.com/v1/protify/cancel",
    headers={"Authorization": f"Bearer {api_key}"},
    params={"job_id": "abc123"})

Base URL: https://api.synthyra.com

All endpoints accept and return JSON unless otherwise noted.

.css-1de82de{background-image:linear-gradient(to right, var(--chakra-colors-cyan-500), var(--chakra-colors-purple-500));color:transparent;-webkit-background-clip:text;background-clip:text;line-height:1.2;-webkit-background-clip:text;-webkit-text-fill-color:transparent;}Synthyra API

Protein Intelligence Platform

Diffusion Sequence Model

Chemical Language Model Training

Synthyra API