# AlphaGenome API: calling a DNA regulatory model from Python

> A client library for Google DeepMind's AlphaGenome, which predicts gene expression, splicing, chromatin state and contact maps from DNA sequence, plus a precomputed Atlas of variant scores across the human genome.

**google-deepmind/alphagenome** — This API provides programmatic access to the AlphaGenome model developed by Google DeepMind.

- Repository: https://github.com/google-deepmind/alphagenome
- Website: https://www.alphagenomedocs.com
- Stars: 2,170 · Forks: 305
- Language: Python
- License: Apache-2.0
- Published: 2026-10-06 · Updated: 2026-10-06 · Language: en
- Canonical page: https://hysenlabs.com/projects/google-deepmind-alphagenome

## A client library, not the model itself

The single most important thing to understand about this repository is what it is not. The README states that it contains client-side code, examples and documentation, and the links at the top of the page split the concerns: this repository for the API, a separate model code repository for the research implementation, a hosted documentation site, and a community forum. The model weights themselves are reached through the service using an API key you request from the AlphaGenome site.

That split shapes what you can expect to find locally. There is no inference code to read, no model architecture to study and no way to run this offline. What there is, under src, is a Python package that constructs requests, plus a data module for describing genomic intervals and variants, a models module holding the client, and a visualization module for plotting the returned tracks. The colabs directory holds runnable notebooks, and docs holds the source for the documentation site, which is built with Sphinx and its extensions listed in the optional dependencies.

The practical consequence is that evaluating this project means evaluating an interface. Its correctness depends on a service you cannot inspect, so the release notes, the documentation and the terms are where the real information lives.

## Expression, splicing, chromatin and contacts from one sequence

AlphaGenome is described as a unifying model for deciphering the regulatory code within DNA sequences, and the API exposes its predictions across several functional output types. Those named in the README are gene expression, splicing patterns, chromatin features and contact maps. Rather than four separate models or four separate endpoints, one call returns a set of modalities over the region you asked about, and the requested_outputs argument selects which ones you actually want.

The scope limits are specific and worth planning around. The model analyzes sequences of up to one million base pairs, and predictions come at single base-pair resolution for most outputs. That resolution is what makes a variant query meaningful, since a single position in the input can be located precisely in the output tracks and compared between the reference and the alternate sequence.

On accuracy, the README points to the published paper by Avsec and colleagues in Nature for variant effect prediction benchmarks, and describes the model as achieving state-of-the-art performance across a range of genomic prediction tasks. Treat that as a claim from the associated paper rather than something the client library establishes, since nothing in a request builder can tell you how well the underlying model scores.

## Atlas scores versus on-demand prediction calls

There are two ways to get an answer from this API, and picking the wrong one is the most common way to waste a rate limit.

The first is the Atlas, a dataset of pre-computed predictions across the entire human genome. It contains variant effect score predictions, the AlphaGenome Variant Impact score known as AVI, and feature importances. Because those numbers already exist, the README says Atlas predictions typically come with a larger query rate, since the server is not running a model for you.

The second is calling the model directly on an interval and variant you specify. This is the path for a limited number of regions or variants, and the README describes it as suited to smaller to medium-scale analyses in the range of thousands of predictions. It explicitly says it is likely not suitable for large-scale analyses requiring more than one million predictions, and query rates for non-Atlas calls vary with demand.

The variant scoring strategies in the documentation exist because of that split. If you have thousands of candidate variants to rank, the Atlas path avoids the ceiling entirely, whereas a bespoke interval is the only option when your variants fall outside precomputed coordinates.

## Terms that rule out clinical work and model training

The terms section is short enough to read in full and it constrains more than most readers expect. Outputs generated by AlphaGenome, and other information provided in AlphaGenome Atlas, are for non-commercial use only, except where the terms provide otherwise through references to Permissive Use Downloadable Artifacts for commercial and non-commercial use. They must not be used for training other machine learning models. And predictions are stated to be for theoretical modelling and research purposes only, with an explicit prohibition on clinical decision-making and on reliance for medical or other professional advice.

The API itself is offered free of charge for non-commercial use, subject to those terms. For commercial use, the README points to availability through Google Cloud, which is a different route with different terms rather than a paid tier of the same endpoint.

There is also a note about client code licensing that is easy to miss. The repository code is under the Apache License 2.0, so the client is permissively licensed, while the predictions you retrieve from it are not. Keeping those two facts separate matters for anyone planning to redistribute results or build a product on top of them.

## Installing from a clone and making one variant call

Installation is a clone and a local install, with the README recommending a Python virtual environment to avoid conflicting with the system Python:

```bash
$ git clone https://github.com/google-deepmind/alphagenome.git
$ pip install ./alphagenome
```

Package metadata puts the floor at Python 3.10, with classifiers for 3.11, 3.12 and 3.13, and describes the project as a Python SDK for interacting and visualizing genomic models, at Beta development status. The build backend is hatchling with a repository-local hatch_build.py, and the build requires grpcio-tools pinned to at most 1.67.1, which tells you the client speaks gRPC to the service rather than plain HTTP.

A prediction call is a client object, an interval, a variant and a set of requested outputs:

```python
from alphagenome.data import genome
from alphagenome.models import dna_client
from alphagenome.visualization import plot_components

API_KEY = 'MyAPIKey'
model = dna_client.create(API_KEY)

interval = genome.Interval(chromosome='chr22', start=35677410, end=36725986)
variant = genome.Variant(
    chromosome='chr22',
    position=36201698,
    reference_bases='A',
    alternate_bases='C',
)
```

and then predict_variant with the interval, the variant, ontology terms and requested output types. The example plots the reference and alternate tracks overlaid with the variant marked, using the visualization library's OverlaidTracks and VariantAnnotation components. Passing ontology terms alongside requested outputs is the detail to understand: the model can return tissue-specific predictions, so the terms you supply decide which biology you are asking about.

## What three client releases actually added

The release history shows an SDK being filled in around a fixed model, which is a useful pattern to recognise. Version 0.7.0 in June 2026 added a FASTA extractor for reading DNA sequences and a Colab demonstrating how to score splicing variants, and it changed gene-centric scoring to merge stranded tracks while improving transcript arrow plotting. Version 0.8.0 in August added a color argument to the sashimi plot component, tutorials on haplotype analysis and on deriving PSI values, and two helper methods for tracking data, then sped up plot_transcripts by removing redundant drawing passes and started generating .pyi files for protocol buffers so type hints work in an editor.

Version 0.9.0 in September 2026 is a single line: it added the AlphaGenome Atlas API for programmatic access to Atlas scores. That is the release that matters most for anyone doing variant ranking, because it moves the precomputed data from a website to something you can query in code.

The pacing is roughly monthly with feature-level releases rather than patch churn, and the repository's last push was on 2026-09-25. The practical implication is that the client will keep moving faster than the model, so pinning a version and reading the changelog before an upgrade is worth the habit here.

## Conclusion

AlphaGenome is built for a specific job: scoring how a DNA variant is likely to change gene regulation, either by calling the model on your own intervals or by reading precomputed scores from the Atlas. Its limits are stated rather than hidden, with a one million base pair sequence ceiling, a guidance that analyses needing more than a million predictions are not a good fit, and predictions explicitly barred from clinical decision-making. Two things to settle before writing analysis code against it: whether your use counts as commercial, since the free tier is non-commercial and a commercial path runs through Google Cloud, and whether the outputs may be used to train another model, which the terms prohibit. If both answers are clear, the Atlas is the cheaper starting point and the client install is two commands from a clone.

## FAQ

### What is an AlphaGenome?

AlphaGenome is Google DeepMind's model for deciphering the regulatory code within DNA sequences, and it makes multimodal predictions covering gene expression, splicing patterns, chromatin features and contact maps. It analyzes sequences of up to one million base pairs and returns predictions at single base-pair resolution for most outputs.

### Is AlphaGenome free?

The API is offered free of charge for non-commercial use, subject to the AlphaGenome terms of service. For commercial use it is available through Google Cloud, which comes with different terms rather than being a paid tier of the same endpoint.

### Can I use AlphaGenome predictions to train another machine learning model?

No. The terms state that outputs generated by AlphaGenome and information provided in AlphaGenome Atlas are for non-commercial use only and should not be used for training other machine learning models. Predictions are also stated to be for theoretical modelling and research purposes only, not for clinical decision-making.

## Sources

- [google-deepmind/alphagenome on GitHub](https://github.com/google-deepmind/alphagenome)
- [License: Apache-2.0](https://github.com/google-deepmind/alphagenome/blob/main/LICENSE)
- [Project website](https://www.alphagenomedocs.com)
- [README](https://github.com/google-deepmind/alphagenome/blob/main/README.md)
- [Releases](https://github.com/google-deepmind/alphagenome/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/google-deepmind-alphagenome