ena-database
ENA REST API for sequences, reads, assemblies, and annotations. Portal API search, Browser API retrieval (XML/FASTA/EMBL), file reports for FASTQ/BAM URLs, taxonomy, cross-refs. For multi-DB Python use bioservices; for NCBI-only use pubmed-database or Biopython Entrez.
Install / Use
npx skills add jaechang-hits/SciAgent-Skills --skill ena-databaseInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Data & AnalyticsSupported Platforms
Our assessment of ena-database
ena-database scores 91/100 on our quality scale, 246th of 599 Data & Analytics skills we index (top 42%).
Its SKILL.md is 21 KB long, well organised into 78 sections with 15 code examples: a thorough specification that gives an agent plenty to work with.
It has 367 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 3 months ago, so ena-database is actively maintained.
- Our last check on 2026-11-20 found the source still online.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-05. Automated pattern scan on 2026-10-05. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
ena-database compared with similar skills
All 4 of these similar skills score higher than ena-database; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| ena-database (this skill)by jaechang-hits | 91 | 367 | 3mo ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 113.3k | 12d ago | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 80.2k | today | CLAUDE.md |
| Scraplingby D4Vinci | 100 | 104.4k | 2d ago | MCP Server |
| crawl4aiby unclecode | 100 | 87.6k | today | MCP Server |
Frequently asked questions
- How do I install ena-database?
- Run
npx skills add jaechang-hits/SciAgent-Skills --skill ena-database. The install tabs above show the steps for each supported agent. - Which AI agents does ena-database work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is ena-database safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is ena-database still maintained?
- The repository was last updated about 3 months ago, so ena-database is actively maintained.
Skill content
View source on GitHubname: ena-database description: "ENA REST API for sequences, reads, assemblies, and annotations. Portal API search, Browser API retrieval (XML/FASTA/EMBL), file reports for FASTQ/BAM URLs, taxonomy, cross-refs. For multi-DB Python use bioservices; for NCBI-only use pubmed-database or Biopython Entrez." license: Unknown
ENA Database — European Nucleotide Archive Programmatic Access
Overview
The European Nucleotide Archive (ENA) is EMBL-EBI's comprehensive nucleotide sequence database, encompassing raw sequencing reads, genome assemblies, annotated sequences, and associated metadata. It mirrors and extends INSDC data (GenBank, DDBJ). All access is via REST APIs with no authentication required.
When to Use
- Searching for sequencing studies, samples, or experiments by organism, project, or keyword
- Downloading raw FASTQ/BAM files for reanalysis of public sequencing datasets
- Retrieving genome assemblies with quality statistics (N50, contig count, genome size)
- Fetching nucleotide sequences in FASTA or EMBL flat-file format by accession
- Exploring taxonomic lineage and finding organisms by partial name
- Cross-referencing ENA records with external databases (ArrayExpress, UniProt, PDB)
- Building bulk download lists for large-scale sequencing projects
- For multi-database Python queries (ENA + UniProt + KEGG), prefer
bioservicesinstead - For NCBI-specific queries (PubMed literature, GenBank records), use
pubmed-databaseor Biopython Entrez
Prerequisites
pip install requests
API constraints:
- Rate limit: 50 requests per second across all ENA APIs
- No authentication required
- Large result sets: use pagination (
limit+offset) or streaming (limit=0for TSV download) - Portal API base:
https://www.ebi.ac.uk/ena/portal/api - Browser API base:
https://www.ebi.ac.uk/ena/browser/api - Taxonomy API base:
https://www.ebi.ac.uk/ena/taxonomy/rest - Cross-ref API base:
https://www.ebi.ac.uk/ena/xref/rest
Quick Start
import requests
import time
BASE_PORTAL = "https://www.ebi.ac.uk/ena/portal/api"
BASE_BROWSER = "https://www.ebi.ac.uk/ena/browser/api"
BASE_TAXONOMY = "https://www.ebi.ac.uk/ena/taxonomy/rest"
BASE_XREF = "https://www.ebi.ac.uk/ena/xref/rest"
def ena_query(endpoint, params=None, base=BASE_PORTAL):
"""Reusable ENA API caller with rate-limit compliance."""
resp = requests.get(f"{base}/{endpoint}", params=params)
resp.raise_for_status()
time.sleep(0.02) # 50 req/sec limit
return resp
# Search for human RNA-seq studies
resp = ena_query("search", params={
"result": "study",
"query": 'tax_tree(9606)', # `library_strategy` is a `read_run`/`read_experiment` field, not a `study` field
"fields": "study_accession,study_title",
"format": "json",
"limit": 3,
})
studies = resp.json()
for s in studies:
print(f"{s['study_accession']}: {s['study_title'][:60]}")
# PRJEB12345: Transcriptome analysis of human liver tissue...
Core API
Module 1: Portal API Search
The Portal API provides advanced metadata search across all ENA data types with boolean query syntax, field selection, and pagination.
# Search read runs for a specific study
resp = ena_query("search", params={
"result": "read_run",
"query": 'study_accession="PRJEB1787"',
"fields": "run_accession,sample_accession,instrument_model,read_count,base_count",
"format": "json",
"limit": 5,
})
runs = resp.json()
for r in runs:
print(f"{r['run_accession']} — {r.get('instrument_model', 'N/A')}, "
f"{int(r.get('read_count', 0)):,} reads")
# ERR123456 — Illumina HiSeq 2000, 45,231,890 reads
# Count total results without fetching data
count_resp = ena_query("count", params={
"result": "read_run",
"query": 'study_accession="PRJEB1787"',
})
print(f"Total runs: {count_resp.text.strip()}")
# Total runs: 142
Module 2: Browser API Retrieval
Fetch individual records by accession in multiple formats: XML, FASTA, EMBL flat-file, or plain text.
# Retrieve XML metadata for a study
resp = ena_query("xml/PRJEB1787", base=BASE_BROWSER)
print(resp.text[:300])
# <?xml version="1.0" encoding="UTF-8"?><PROJECT_SET>...
# Retrieve FASTA sequence for a coding sequence
resp = ena_query("fasta/M10051.1", base=BASE_BROWSER)
print(resp.text[:200])
# >ENA|M10051|M10051.1 Human insulin mRNA, complete cds.
# AGCCCTCCAGGACAGGCTGCAT...
# Retrieve EMBL flat-file format
resp = ena_query("embl/M10051.1", base=BASE_BROWSER)
print(resp.text[:300])
# ID M10051; SV 1; linear; mRNA; STD; HUM; 786 BP.
# ...
Module 3: File Reports and Downloads
Get download URLs for FASTQ, submitted, and analysis files. File reports return FTP and Aspera paths.
# Get FASTQ file URLs for specific runs
resp = ena_query("filereport", params={
"accession": "ERR000589",
"result": "read_run",
"fields": "run_accession,fastq_ftp,fastq_bytes,fastq_md5",
"format": "json",
})
files = resp.json()
for f in files:
ftp_urls = f.get("fastq_ftp", "").split(";")
sizes = f.get("fastq_bytes", "").split(";")
for url, size in zip(ftp_urls, sizes):
if url:
print(f"ftp://{url} ({int(size)/1e6:.1f} MB)")
# ftp://ftp.sra.ebi.ac.uk/vol1/fastq/ERR000/ERR000589/ERR000589_1.fastq.gz (234.5 MB)
# ftp://ftp.sra.ebi.ac.uk/vol1/fastq/ERR000/ERR000589/ERR000589_2.fastq.gz (241.2 MB)
Module 4: Taxonomy Queries
Look up organisms by taxonomy ID, scientific name, or partial name match.
# Lookup by taxonomy ID
resp = ena_query("tax-id/9606", base=BASE_TAXONOMY)
tax = resp.json()
print(f"{tax['scientificName']} (taxId: {tax['taxId']}, rank: {tax['rank']})")
# Homo sapiens (taxId: 9606, rank: species)
print(f"Lineage: {tax['lineage'][:80]}...")
# Search by scientific name — endpoint returns a list (one entry per matching taxon)
resp = ena_query("scientific-name/Arabidopsis thaliana", base=BASE_TAXONOMY)
matches = resp.json()
result = matches[0] if isinstance(matches, list) else matches
print(f"Tax ID: {result['taxId']}, Common: {result.get('commonName', 'N/A')}")
# Tax ID: 3702, Common: thale cress
# Suggest organisms by partial name
resp = ena_query("suggest-for-search/salmo", base=BASE_TAXONOMY)
suggestions = resp.json()
for s in suggestions[:3]:
print(f" {s['scientificName']} (taxId: {s['taxId']})")
# Salmo salar (taxId: 8030)
# Salmo trutta (taxId: 8032)
# Salmonella enterica (taxId: 28901)
Module 5: Cross-Reference Service
Find links between ENA records and external databases (ArrayExpress, UniProt, PDB, etc.).
# Find cross-references for an ENA accession
resp = ena_query("json/search", base=BASE_XREF, params={
"accession": "M10051",
})
xrefs = resp.json()
for x in xrefs[:5]:
print(f" {x['Source']} → {x['Source Primary Accession']} "
f"({x.get('Source Description', '')[:50]})")
# UniProt → P01308 (Insulin precursor)
# PDB → 1A7F (Crystal structure of human insulin)
# Search cross-references by external database
resp = ena_query("json/search", base=BASE_XREF, params={
"source": "UniProt",
"accession": "P01308",
})
xrefs = resp.json()
for x in xrefs[:3]:
print(f" ENA: {x['Target Primary Accession']} — {x.get('Target Description', '')[:60]}")
Module 6: CRAM Reference Registry
Retrieve reference sequences used in CRAM files by MD5 or SHA1 checksum. Essential for CRAM decompression.
# Look up reference by MD5 checksum
md5 = "aef131c3b4b05d8e2b3f907faba5af9b" # example
try:
resp = ena_query(
f"cram/md5/{md5}",
base="https://www.ebi.ac.uk/ena/cram"
)
print(f"Reference found: {len(resp.content)} bytes")
except requests.HTTPError as e:
if e.response.status_code == 404:
print("Reference not found — check MD5 checksum")
else:
raise
Key Concepts
ENA Data Hierarchy
| Level | Accession Prefix | Description | Contains | |-------|-----------------|-------------|----------| | Study | PRJEB/ERP | Research project | Samples, Experiments | | Sample | ERS/SAMEA | Biological sample | Metadata, taxonomy | | Experiment | ERX | Library/sequencing setup | Runs | | Run | ERR | Sequencing run | Raw read files (FASTQ) | | Analysis | ERZ | Derived analysis | Assemblies, alignments | | Assembly | GCA | Genome assembly | Contigs, scaffolds | | Sequence | Accession.version | Annotated sequence | Features, coding seqs |
Query Syntax Operators
| Operator | Example | Description |
|----------|---------|-------------|
| Equality | instrument_model="Illumina NovaSeq 6000" | Exact match |
| Wildcard | study_title="*melanoma*" | Partial match |
| Range | base_count>=1000000 | Numeric comparison |
| Taxonomy tree | tax_tree(9606) | Taxon and all descendants |
| Exact taxon | tax_eq(9606) | Exact taxon only |
| Date range | first_public>=2023-01-01 | Date filtering |
| Boolean | AND, OR, NOT | Combine conditions |
| Grouping | (A OR B) AND C | Parenthetical grouping |
Result Types
| Result Type | Description | Key Fields |
|------------|-------------|------------|
| study | Research projects | study_accession, study_title, center_name |
| sample | Biological samples | sample_accession, tax_id, scientific_name |
| read_run | Sequencing runs | run_accession, read_count, base_count, fastq_ftp |
| read_experiment | Experiments | experiment_accession, library_strategy, instrument_model |
| analysis | Derived analyses | analysis_accession, analysis_type |
| assembly | Genome assemblies | assembly_accession, assembly_level, genome_representation |
| sequence | Annotated sequences | accession, sequence_length, mol_type |
| wgs_set | WGS scaffold sets | set_accession, set_size |
| tsa_set | Transcriptome assemblies | set_accession, set_size |
| coding | Coding sequences | accession, gene, product |
| noncoding | Non-coding features | accession, description |
| taxon | Taxonomy entries | tax_id, scientific_name, lineage |
Discoverable Fields
Use the returnFields endpoint to discover available fields for any result type:
resp = ena_query("returnFields", params={"result": "read_run"})
fields = resp.text.strip().split("\n")
print(f"Available fields for read_run: {len(fields)}")
print(fields[:10])
# ['accession', 'altitude', 'assembly_quality', 'assembly_software', ...]
Common Workflows
Workflow 1: Study Exploration Pipeline
Search for a study, list its samples, then retrieve run metadata.
import json
# Step 1: Find studies by organism — `study_title="*…*"` wildcards no longer match;
# use `tax_tree()` against the species tax ID (SARS-CoV-2 = 2697049).
resp = ena_query("search", params={
"result": "study",
"query": 'tax_tree(2697049) AND first_public>=2023-01-01',
"fields": "study_accession,study_title,center_name",
"format": "json",
"limit": 3,
})
studies = resp.json()
study_acc = studies[0]["study_accession"]
print(f"Selected: {study_acc} — {studies[0]['study_title'][:60]}")
# Step 2: List samples in the study
resp = ena_query("search", params={
"result": "sample",
"query": f'study_accession="{study_acc}"',
"fields": "sample_accession,scientific_name,collection_date",
"format": "json",
"limit": 5,
})
samples = resp.json()
print(f"Found {len(samples)} samples (showing first 5)")
for s in samples:
print(f" {s['sample_accession']} — {s.get('scientific_name', 'N/A')}")
# Step 3: Get run metadata for each sample
for s in samples[:2]:
resp = ena_query("search", params={
"result": "read_run",
"query": f'sample_accession="{s["sample_accession"]}"',
"fields": "run_accession,instrument_model,read_count,library_strategy",
"format": "json",
})
runs = resp.json()
for r in runs:
print(f" {r['run_accession']}: {r.get('library_strategy','N/A')}, "
f"{int(r.get('read_count',0)):,} reads")
time.sleep(0.02)
Truncated for display — read the full file on GitHub.
Related Skills
Agent-Reach
113.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
headroom
80.2kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Scrapling
104.4k🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev
crawl4ai
87.6kOfficial Crawl4AI Cloud: a hosted web scraping, extraction, and search API for AI agents. Free API key, 1,000 credits a month, no card. Fully open source: this repo is the Apache-2.0 crawler that powers it, and you can self-host it.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
