How to Submit Data to NCBI: 16S, ITS, Genomes & Metagenomes

Almost every journal now asks for a data availability statement with accession numbers, and many reviewers check them. Yet the first NCBI submission confuses nearly everyone I supervise: BioProject or BioSample? SRA or GenBank? Which “package”? What is library_selection? Why did my genome bounce back with a contamination report?

This guide answers those questions for the six data types my students submit most: 16S rRNA, ITS, whole genome sequencing, transcriptomics, metagenomics and metatranscriptomics, both as raw reads and as assemblies. I checked every rule against NCBI’s own documentation (linked throughout), wrote two small Python scripts to prepare metadata and pre-check assemblies, and listed the errors that block most first submissions.

New to sequencing data? Read my metabolomics complete guide for how an omics study is designed, and why learning bioinformatics is essential. Already sure what you have? Jump to the routing table.

Picture it as a tree. Your BioProject is the trunk; each BioSample is a branch; and every dataset from that sample (16S reads, shotgun reads, a MAG) hangs from the same branch. This is why NCBI keeps repeating one rule: register each sample once and reuse its SAMN accession everywhere.

Accession numbers you will receive

↑ Back to topNext: Where each data type goes →

Sources: NCBI SRA Quick Start, Metagenome Submission Guide, WGS and TSA pages. Strategy, source and selection values are SRA controlled vocabulary; pick the one that matches your protocol.

↑ Back to topNext: Before you start →

1. Create an NCBI account at submit.ncbi.nlm.nih.gov (you can log in with ORCID, Google or an institutional account). If co-workers should see the submission, create a group under your profile.
2. Collect raw reads as they came off the sequencer: FASTQ (gzip-compressed is fine) or BAM, demultiplexed so each sample has its own R1 and R2 files.
3. Check file names: unique, no spaces or special characters, and matching the names you will type in the metadata sheet exactly, including .fastq.gz.
4. Make checksums (md5sum) so you can prove the files arrived intact.
5. Fill a sample sheet: sample name, organism, collection date (YYYY-MM-DD), geographic location (“Pakistan: Faisalabad”), latitude and longitude, isolation source or host, and treatment.
6. Record the library details: primers and region (e.g. 515F/806R, V4), kit, platform and instrument model, read length, layout (single or paired).
7. Decide the release date: immediately, or a future date in line with your planned publication.

# make checksums for every read file (Linux; on macOS use: md5 -r *.fastq.gz > md5.txt)
md5sum *.fastq.gz > md5.txt

# quick check that R1 and R2 of a sample have the same number of reads
echo $(( $(zcat Soil01_R1.fastq.gz | wc -l) / 4 )) $(( $(zcat Soil01_R2.fastq.gz | wc -l) / 4 ))

↑ Back to topNext: Register a BioProject →

1. Tab 1Submitteryour name, institute and email
2. Tab 2Project typedata type and sample scope
3. Tab 3Targetorganism, strain or metagenome name
4. Tab 4General inforelease date, title, public description
5. Tab 5Grantsfunding agency and grant number (optional)
6. Tab 6BioSampleadd existing SAMN accessions or skip
7. Tab 7PublicationsDOI or PubMed ID if published
8. Tab 8Overviewcheck everything, then Submit

↑ Back to topNext: Register BioSamples →

Package names from the BioSample packages list; metagenome naming from the Metagenome Submission Guide.

The fields that cause most errors

• sample_name: unique within your whole NCBI account, and the same name you will use in the SRA sheet.
• organism: must exist in NCBI Taxonomy. For environmental DNA use a metagenome name such as “soil metagenome”, never “uncultured bacterium” or a list of taxa.
• collection_date: ISO format such as 2025-03-14, 2025-03 or 2025. If truly unknown use “missing”, “not collected” or “not applicable”.
• geo_loc_name: “Country: region, place”, e.g. “Pakistan: Punjab, Faisalabad”.
• lat_lon: decimal degrees with hemisphere letters: “31.42 N 73.08 E”.
• Duplicate rows: two samples with identical attributes are rejected. Add a distinguishing attribute such as replicate, plot or time point.

Need a reminder of ISO dates and tidy spreadsheets? My pandas mastery guide shows how to clean a sample sheet in Python.

↑ Back to topNext: Submit raw reads to SRA →

1. Tab 1Submittercontact details; optionally a group
2. Tab 2General info“Yes” if BioProject and BioSamples already exist; release date
3. Tab 3–5Project and samplesonly if you did not register them first
4. Tab 6SRA metadataone row per experiment; online editor or Excel template
5. Tab 7Files“I have all files preloaded”, then select your folder
6. Tab 8Overviewcheck, click Submit, confirm the status changed

Wizard tabs from NCBI’s SRA Submission Portal guide.

The SRA metadata values for each data type

Typing 96 rows by hand is how mistakes happen. This script reads a folder of paired FASTQ files, recognises common Illumina names (Sample_S1_L001_R1_001.fastq.gz, Sample_R1.fastq.gz, Sample_1.fastq.gz), flags samples with a missing mate, and writes a draft sheet you can paste into the SRA template:

# make_sra_metadata.py: build the SRA metadata sheet from a folder of paired FASTQ files
# pip install pandas openpyxl
# Usage: python make_sra_metadata.py reads/ --strategy AMPLICON --source METAGENOMIC --selection PCR
import argparse
import hashlib
import re
from pathlib import Path

import pandas as pd

p = argparse.ArgumentParser()
p.add_argument("folder")
p.add_argument("--strategy", default="AMPLICON")      # AMPLICON, WGS, RNA-Seq, ...
p.add_argument("--source", default="METAGENOMIC")     # GENOMIC, TRANSCRIPTOMIC, METAGENOMIC, METATRANSCRIPTOMIC
p.add_argument("--selection", default="PCR")          # PCR, RANDOM, cDNA, PolyA, ...
p.add_argument("--platform", default="ILLUMINA")
p.add_argument("--model", default="Illumina MiSeq")
p.add_argument("--title", default="16S rRNA V3-V4 amplicon sequencing")
args = p.parse_args()

# match sample_R1.fastq.gz / sample_R2.fastq.gz (also _1/_2 and Illumina _S1_L001_R1_001)
pat = re.compile(r"^(?P<sample>.+?)(?:_S\d+)?(?:_L\d{3})?_R?(?P<read>[12])(?:_001)?\.f(?:ast)?q\.gz$")
pairs = {}
for f in sorted(Path(args.folder).iterdir()):
    m = pat.match(f.name)
    if m:
        pairs.setdefault(m["sample"], {})[m["read"]] = f

def md5(path):
    h = hashlib.md5()
    with open(path, "rb") as fh:
        for chunk in iter(lambda: fh.read(1 << 20), b""):
            h.update(chunk)
    return h.hexdigest()

rows, problems = [], []
for sample, reads in pairs.items():
    if set(reads) != {"1", "2"}:
        problems.append(f"{sample}: missing R1 or R2")
        continue
    rows.append({
        "sample_name": sample,                 # must match the sample_name in your BioSample sheet
        "library_ID": f"{sample}_lib",
        "title": f"{args.title}: {sample}",
        "library_strategy": args.strategy,
        "library_source": args.source,
        "library_selection": args.selection,
        "library_layout": "paired",
        "platform": args.platform,
        "instrument_model": args.model,
        "design_description": "Describe primers, kit and protocol here",
        "filetype": "fastq",
        "filename": reads["1"].name,
        "filename2": reads["2"].name,
        "md5_R1": md5(reads["1"]),             # keep for your records; not part of the template
        "md5_R2": md5(reads["2"]),
    })

df = pd.DataFrame(rows)
df.to_excel("sra_metadata_draft.xlsx", index=False)
print(f"{len(df)} paired samples written to sra_metadata_draft.xlsx")
for msg in problems:
    print("CHECK:", msg)

pip install pandas openpyxl
python make_sra_metadata.py reads/ --strategy AMPLICON --source METAGENOMIC --selection PCR \
    --model "Illumina MiSeq" --title "16S rRNA V3-V4 amplicon sequencing"

Upload the files: FTP or Aspera

For more than a few small files, pre-load them before you reach the Files tab. In the wizard (or the portal’s “My submissions → FTP/Aspera upload” page) NCBI shows your personal account folder and credentials. Create a new sub-folder for each submission inside it; files left directly in the account folder, or in nested folders, will not show up. Wait 10–15 minutes after the upload finishes, then click Select preload folder.

# host and password are shown in the Submission Portal; the folder name is personal to you
lftp -u subftp,YOUR_PASSWORD ftp-private.ncbi.nlm.nih.gov
cd uploads/your.email_AbCd1234
mkdir soil16S_2026
cd soil16S_2026
mput *.fastq.gz
bye

# download the key file from the portal first; -d creates the destination folder
ascp -i aspera.openssh -QT -l100m -k1 -d reads/ \
  subasp@upload.ncbi.nlm.nih.gov:uploads/your.email_AbCd1234/soil16S_2026

Aspera options from NCBI’s file upload guide: -Q adaptive speed, -T no encryption, -k1 resume an interrupted transfer, -l100m maximum 100 Mbps. Aspera needs TCP port 22 and UDP port 33001 open; if your university firewall blocks them, use FTP. FileZilla also works for FTP: type your account folder into the “Remote site” box, or you will see “550 Permission denied”.

Never used a terminal before? lftp, ascp, md5sum and zcat are everyday Linux commands. My free Linux series takes you from your first command to running bioinformatics tools on a server:

↑ Back to topNext: 16S rRNA and ITS data →

A. Amplicon sequencing (MiSeq and similar) → SRA

1. BioProject: data type Raw sequence reads, scope Environment.
2. BioSamples: MIMARKS survey package for your environment (soil, water, plant-associated, human-gut…), organism such as “soil metagenome” or “rhizosphere metagenome”, one row per sample.
3. SRA metadata: AMPLICON / METAGENOMIC / PCR, paired layout, and in design_description the target region and primers (for example “16S V3–V4, 341F/805R” or “ITS2, ITS3/ITS4”), PCR conditions and kit.
4. Upload the demultiplexed raw FASTQ files (before primer removal, quality filtering or merging) and submit.

What about ASVs and OTUs? GenBank does not accept consensus sequences, and ASV or OTU representatives are computed from many reads rather than sequenced as single molecules, so they do not belong in GenBank. Deposit the reads in SRA and share the ASV table, representative sequences and taxonomy as supplementary files or in a repository such as Zenodo or Figshare, citing the PRJNA.

B. Sanger 16S, 18S, 28S or ITS sequences → GenBank

1. In the portal choose New submission → GenBank and the sequence type Ribosomal RNA (rRNA), rRNA-ITS or ITS.
2. Say whether the sequences come from cultured isolates or from uncultured organisms (clones from environmental DNA, named “uncultured bacterium”, “uncultured fungus” and so on).
3. Upload a FASTA file. Trim primers and low-quality ends; each sequence must be at least 200 bp, without leading or trailing Ns.
4. Give source information for each sequence, either in the FASTA definition line or as a table: organism, strain or isolate, isolation source, host, location and collection date.
5. Choose the gene or region (for example 16S ribosomal RNA, or ITS1, 5.8S rRNA and ITS2 complete), the sequencing technology and the release date, then submit.

>TH07 [organism=Trichoderma harzianum] [strain=TH-07] [isolation_source=wheat rhizosphere soil] [geo_loc_name=Pakistan: Faisalabad] [collection_date=2025-03-14]
TCCGTAGGTGAACCTGCGGAGGGATCATTACCGAGTTTACAACTCCCAAACCCAATGTGAACGTTACCAAACTGTTGCCTCGGCGGG...
>BS12 [organism=Bacillus subtilis] [strain=BS-12] [isolation_source=maize root] [geo_loc_name=Pakistan: Lahore] [collection_date=2025-04-02]
AGAGTTTGATCCTGGCTCAGGACGAACGCTGGCGGCGTGCCTAATACATGCAAGTCGAGCGGACAGATGGGAGCTTGCTCCC...

GenBank does not accept sequences shorter than 200 bp for these submissions, and the portal checks that each sequence really is the rRNA or ITS region you declared, so a mislabelled 18S in a 16S batch stops the submission. Older GenBank pages call the location field country; newer records use geo_loc_name. Accessions usually arrive within a few working days.

↑ Back to topNext: Whole genome sequencing →

Prepare the assembly

1. Remove contigs shorter than 200 bp (unless they are part of a scaffold) and trim Ns from the ends.
2. Screen for contamination: NCBI runs its Foreign Contamination Screen (FCS-GX) on new genome submissions. Run FCS-adaptor and FCS-GX yourself first and remove what they flag; it saves weeks of back-and-forth.
3. Check quality: completeness and contamination with CheckM2 or BUSCO, and assembly statistics (N50, number of contigs).
4. Write one FASTA file per genome with simple, unique contig IDs such as contig_1.
5. Know your assembly details: assembler and version, coverage and sequencing technologies. They go into the required Genome-Assembly-Data structured comment.

Most submission errors are simple things a script can catch. This checker reports sequences shorter than 200 bp, Ns at the ends, long N runs, duplicate or overlong IDs and non-nucleotide characters, and prints the N50:

# check_assembly_fasta.py: catch the errors that stop WGS/TSA submissions before you upload
# No extra packages needed (standard Python 3). Works with .fasta, .fa, .fsa and .gz files.
# Usage: python check_assembly_fasta.py assembly.fasta
import gzip
import re
import sys

path = sys.argv[1]
opener = gzip.open if path.endswith(".gz") else open
records, name, chunks = [], None, []
with opener(path, "rt") as fh:
    for line in fh:
        line = line.strip()
        if line.startswith(">"):
            if name is not None:
                records.append((name, "".join(chunks).upper()))
            name, chunks = line[1:].split()[0], []
        elif line:
            chunks.append(line)
if name is not None:
    records.append((name, "".join(chunks).upper()))

errors, seen, total = [], set(), 0
for rid, seq in records:
    total += len(seq)
    if rid in seen:
        errors.append(f"{rid}: duplicate ID")
    seen.add(rid)
    if len(rid) > 50:
        errors.append(f"{rid}: ID longer than 50 characters")
    if len(seq) < 200:
        errors.append(f"{rid}: only {len(seq)} bp (minimum is 200 bp)")
    if seq.startswith("N") or seq.endswith("N"):
        errors.append(f"{rid}: starts or ends with N (trim them)")
    if re.search(r"[^ACGTNRYSWKMBDHV]", seq):
        errors.append(f"{rid}: contains characters that are not nucleotides")
    n_runs = [len(r) for r in re.findall(r"N+", seq)]
    if seq and seq.count("N") / len(seq) > 0.10:
        errors.append(f"{rid}: more than 10% N (TSA limit)")
    if n_runs and max(n_runs) > 14:
        errors.append(f"{rid}: run of {max(n_runs)} Ns (needs an assembly_gap; in TSA, split it)")

lengths = sorted((len(s) for _, s in records), reverse=True)
acc, n50 = 0, 0
for L in lengths:
    acc += L
    if acc >= total / 2:
        n50 = L
        break
print(f"{len(records)} sequences, {total:,} bp in total, N50 = {n50:,} bp")
print("\n".join(errors) if errors else "No blocking problems found. Still run FCS-GX before you submit.")

python check_assembly_fasta.py my_genome.fasta

# FCS-adaptor: adapters and vectors (Docker or Singularity image from github.com/ncbi/fcs)
./run_fcsadaptor.sh --fasta-input my_genome.fasta --output-dir ./adaptor_out --prok

# FCS-GX: sequences from other organisms; --tax-id is your organism's NCBI taxid
python3 fcs.py screen genome --fasta my_genome.fasta --out-dir ./gx_out \
    --gx-db "$GXDB_LOC/gxdb" --tax-id 1423

FCS-GX needs a large database and a lot of memory, so many labs run it on a server or skip it and let NCBI run it after submission. Commands from the FCS wiki; FCS-GX is described in Astashyn et al., Genome Biology 2024.

Submit the genome

• Choose New submission → Genome. Say whether the assembly is a draft (WGS) or complete, whether it is from one organism or a MAG, and whether you want PGAP annotation (bacteria and archaea only).
• Link the BioProject and BioSample, enter the assembly method, version, coverage and sequencing technology, and upload the FASTA.
• For a complete genome, assign each sequence: chromosome, plasmid (with its name) and whether it is circular, either in the portal table or in the FASTA definition line, e.g. >chr1 [location=chromosome] [topology=circular] [completeness=complete] and >p1 [plasmid-name=pBS12] [topology=circular] [completeness=complete].
• Many genomes at once: the batch option takes up to 400 assemblies, one row each.
• Annotation you made yourself (for example with Prokka or Bakta) goes in through table2asn; it needs a locus_tag prefix, which NCBI assigns when the BioSample is registered for an annotated genome.

From NCBI’s WGS page and genomes FAQ: sequences shorter than 200 bp are not accepted unless in scaffolds; sequences cannot begin or end with N; unannotated or PGAP-annotated genomes need at least two weeks to process and annotated genomes at least a month. Complete organelle and viral genomes are ordinary GenBank submissions, not WGS.

↑ Back to topNext: Transcriptomics →

Submitting a transcriptome assembly to TSA

1. Submit the raw reads to SRA first; TSA requires the SRR, BioProject and BioSample accessions.
2. Clean the assembly: remove sequences shorter than 200 nt, trim end Ns, split sequences at gaps of unknown length, and make sure no sequence has more than 10% Ns or more than 14 Ns in a row.
3. Remove contaminants and sequencing primers (FCS-GX and FCS-adaptor), because the portal stops submissions with hits to NGS primers.
4. Name the file with the .fsa suffix, give each transcript a short unique ID, and add [moltype=transcribed_RNA] to the definition lines; or build a .sqn file with table2asn.
5. Submit through the TSA option of the Submission Portal with the assembly method and version (for example “Trinity v2.15.1”).

# add moltype to every header and keep IDs short and unique
awk '/^>/{print ">contig" ++i " [moltype=transcribed_RNA]"; next}{print}' Trinity.fasta > transcripts.fsa

# optional: build and validate a .sqn file (template.sbt is made with NCBI's online template tool)
table2asn -t template.sbt -i transcripts.fsa -Y comment.txt -M t -V v

TSA rules from NCBI’s TSA page and TSA Submission Guide. Sequences under 200 nt stop the submission in the portal. Rename the awk output IDs back to your own if you need to trace contigs to your analysis.

↑ Back to topNext: Metagenomics →

1. Raw reads

BioProject type Metagenome, scope Environment; one MIMS BioSample per sample with a metagenome organism name from NCBI Taxonomy; SRA values WGS / METAGENOMIC / RANDOM. If the sample is human-associated, remove human reads first.

2. Primary metagenome assembly

The assembled contigs of the whole community (for example from MEGAHIT or metaSPAdes) can be submitted through the Genome submission as a WGS project with the metagenome name. Leave out contigs shorter than 200 bp, and join contigs with Ns only where there is linkage evidence; random concatenation is not allowed.

3. Metagenome-assembled genomes (MAGs)

1. Check the bins: each MAG must represent one organism, be at least 90% complete with CheckM or CheckM2, and total at least 100,000 bp. Use only sequences you generated, not public ones.
2. Ask for organism names first: email genomes@ncbi.nlm.nih.gov a table of your MAG isolate names and proposed names or unmodified GTDB lineages before you register BioSamples.
3. Register one BioSample per MAG with the MIMAG package: a stable isolate such as MAG001, sample_type = “metagenomic assembly”, the same location and date as the source sample, and derived_from listing the SRA runs used, separated by commas.
4. Add the reads to each FASTA header, e.g. >MAG001_c1 [SRA=SRR123,SRR124].
5. Submit through the Genome submission, one row per MAG in batch mode (up to 400 per batch). PGAP can annotate prokaryotic MAGs if you ask.

sample_name	organism	isolate	sample_type	derived_from	geo_loc_name	collection_date	env_broad_scale	completeness_score	contamination_score
MAG001	Bacillus sp.	MAG001	metagenomic assembly	SRR29000001,SRR29000002	Pakistan: Faisalabad	2025-03-14	terrestrial biome	96.4	1.2
MAG002	Streptomyces sp.	MAG002	metagenomic assembly	SRR29000001	Pakistan: Faisalabad	2025-03-14	terrestrial biome	91.8	2.7

MAG rules from NCBI’s genomes FAQ, which takes priority over older metagenome pages. Bins that are small, BLAST-only or without organism information can instead be submitted as one WGS project under the metagenome name, with bin details as notes. Contact NCBI before submitting 5,000 or more MAGs. The MIMAG standard: Bowers et al., Nat Biotechnol 2017.

↑ Back to topNext: Metatranscriptomics →

• Same sample, same BioSample: if you extracted DNA and RNA from the same soil core, the metagenome and metatranscriptome are two SRA experiments on one BioSample.
• Raw reads, not rRNA-depleted output: upload the reads as sequenced; describe rRNA depletion (wet lab or in silico) in design_description.
• Assemblies to TSA: use the metagenome name, remove contaminants with FCS-GX, split large assembly files, and follow the TSA rules in Section 9.
• Functional tables (KEGG or gene counts) are not accepted by SRA or TSA; share them in GEO, supplementary files or a repository.

From NCBI’s Metagenome Submission Guide (“metagenomic transcriptomes can be submitted to GenBank following the TSA guide”) and the TSA Submission Guide.

↑ Back to topNext: After you submit →

Write your data availability statement

The raw sequencing reads generated in this study have been deposited in the NCBI Sequence Read Archive under BioProject accession PRJNA123456 (BioSamples SAMN38000001–SAMN38000024). The draft genome of Bacillus subtilis BS-12 is available in GenBank under accession JBXXXX000000000, and the metagenome-assembled genomes under BioSamples SAMN38000101–SAMN38000135.

• Change a release date: in the portal, open the BioProject in the SRA data interface and edit it, as long as it is not yet public.
• Add more data later: start a new submission and reuse the same BioProject and BioSamples.
• Correct a public record: email the database (sra@, gb-admin@ or genomes@ncbi.nlm.nih.gov) with the accession; a new genome assembly becomes version 2 and replaces version 1.

Writing up your study? My guides on AI tools for scientific writing and conference posters help you present the results behind these accessions.

↑ Back to topNext: Find a project on NCBI →

Four ways to search

• By accession: paste PRJNA…, SAMN…, SRR… or an assembly accession (GCA_…) into the NCBI search box with “All Databases” selected, or go straight to ncbi.nlm.nih.gov/bioproject/PRJNA….
• By topic: in the BioProject database, combine keywords and field tags, for example Bacteroides[Organism] AND hybrid assembly, then narrow the results with the filters on the left (project type, data type, organism).
• By runs: the SRA Run Selector lists every run of a project in one table with read counts, platforms and sample attributes, and exports the accession list for download tools.
• Your own submissions: unreleased records are not searchable. Find them under My submissions in the Submission Portal instead.

Real example: PRJNA1455430, 18 hybrid-assembled gut bacteria

Open PRJNA1455430. It is a public project from Christian-Albrechts-University of Kiel: “Hybrid genome assemblies of Bacteroidota isolates uncover mobile genetic elements, antimicrobial resistance genes, and novel antimicrobial peptides”. The researchers sequenced 18 Bacteroidales strains isolated from mouse caeca, human faeces and tortoise stool, each with Illumina short reads and Oxford Nanopore long reads, and combined them into highly contiguous hybrid assemblies. It is a textbook example of Sections 4 to 8 of this guide.

How the records connect: one strain, end to end

Six of the 18 strains; all values from the public NCBI records of PRJNA1455430, checked on 9 November 2026. Each strain has exactly one BioSample, two SRA experiments (one per platform) and one assembly: the same structure I recommend in Sections 5, 6 and 8.

Summarise any project with Python

Clicking through 18 samples is slow. This script uses NCBI’s free E-utilities to print the project details, the number of linked records in each database, the sequencing platforms and one line per BioSample:

# bioproject_summary.py: see what is inside any public NCBI BioProject
# No extra packages needed (standard Python 3). Uses NCBI's free E-utilities.
# Usage: python bioproject_summary.py PRJNA1455430
import csv
import io
import json
import sys
import time
import urllib.request
from collections import Counter, defaultdict

ACC = sys.argv[1] if len(sys.argv) > 1 else "PRJNA1455430"
EUTILS = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/"

def get(url):
    time.sleep(0.4)  # NCBI allows about 3 requests per second without an API key
    with urllib.request.urlopen(url) as r:
        return r.read().decode()

def eutil(tool, **params):
    query = "&".join(f"{k}={v}" for k, v in params.items())
    return json.loads(get(f"{EUTILS}{tool}.fcgi?retmode=json&{query}"))

# 1. The project record
uid = eutil("esearch", db="bioproject", term=ACC)["esearchresult"]["idlist"][0]
p = eutil("esummary", db="bioproject", id=uid)["result"][uid]
print(f"{p['project_acc']}: {p['project_title']}")
print(f"Data type: {p['project_data_type']} | scope: {p['project_target_scope']} | "
      f"submitter: {p['submitter_organization']} | registered: {p['registration_date'][:10]}")

# 2. How many linked records in each database
links = eutil("elink", dbfrom="bioproject", db="biosample,sra,assembly,nuccore", id=uid)
for ls in links["linksets"][0].get("linksetdbs", []):
    if ls["linkname"] in ("bioproject_biosample", "bioproject_sra", "bioproject_assembly", "bioproject_nuccore"):
        print(f"  {ls['linkname'].split('_')[1]:10s} {len(ls['links'])} records")

# 3. The SRA runs: one row per sequencing run
runs = list(csv.DictReader(io.StringIO(get(f"https://trace.ncbi.nlm.nih.gov/Traces/sra-db-be/runinfo?acc={ACC}"))))
print(f"\nSRA study {runs[0]['SRAStudy']}: {len(runs)} runs")
for (platform, model, layout), n in Counter((r["Platform"], r["Model"], r["LibraryLayout"]) for r in runs).items():
    print(f"  {n} x {platform} {model} ({layout.lower()})")

# 4. One line per BioSample: organism, runs and total gigabases
by_sample = defaultdict(list)
for r in runs:
    by_sample[(r["BioSample"], r["ScientificName"])].append(r)
print("\nBioSample      Organism                         Runs                       Gb")
for (sample, name), rs in sorted(by_sample.items())[:5]:
    gb = sum(int(r["bases"]) for r in rs) / 1e9
    print(f"{sample}  {name[:30]:30s}  {', '.join(r['Run'] for r in rs):25s}  {gb:.2f}")
if len(by_sample) > 5:
    print(f"... and {len(by_sample) - 5} more samples")

python bioproject_summary.py PRJNA1455430

PRJNA1455430: Hybrid genome assemblies of Bacteroidota isolates uncover mobile genetic elements, antimicrobial resistance genes, and novel antimicrobial peptides
Data type: Genome sequencing | scope: Multispecies | submitter: Christian-Albrechts-University of Kiel | registered: 2026/04/20
  biosample  18 records
  sra        36 records
  assembly   18 records
  nuccore    21 records

SRA study SRP693156: 36 runs
  18 x OXFORD_NANOPORE GridION (single)
  18 x ILLUMINA Illumina NovaSeq 6000 (paired)

BioSample      Organism                         Runs                       Gb
SAMN57365447  Bacteroides muris (ex Fokt et   SRR38187858, SRR38187868   0.97
SAMN57365448  Bacteroides caecimuris          SRR38187867, SRR38187857   1.75
SAMN57365449  Bacteroides ovatus              SRR38187855, SRR38187856   1.25
SAMN57365450  Bacteroides caecimuris          SRR38187854, SRR38187845   0.75
SAMN57365451  Bacteroides caecimuris          SRR38187838, SRR38187853   0.78
... and 13 more samples

Download the data

# genomes with NCBI Datasets (conda install -c conda-forge ncbi-datasets-cli)
datasets download genome accession GCA_062075006.1 --include genome,gff3 --filename caecimuris_241156E.zip

# raw reads with the SRA Toolkit (conda install -c bioconda sra-tools)
prefetch SRR38187867
fasterq-dump --split-files SRR38187867      # Illumina: _1.fastq and _2.fastq
prefetch SRR38187857 && fasterq-dump SRR38187857   # Nanopore: one file

Datasets and the SRA Toolkit are NCBI’s official download tools: NCBI Datasets documentation, SRA Toolkit wiki. The Run Selector can also export the full list of SRR accessions for a loop.

↑ Back to topNext: Common errors and fixes →

Free video courses to go with this guide (Urdu/Hindi)

Full playlists on the Codanics YouTube channel

Submitting data is the last step of a bioinformatics project. These free playlists cover the steps before it, and what you can do with the genomes once they are public.

Bioinformatics ka Chilla: 40 biological data science topics

AlphaFold and protein structure prediction

The Linux series is embedded in Section 6, next to the upload commands, and on YouTube: Linux for Data Science and Bioinformatics.

Final checklist before you click Submit

• NCBI account created; co-workers added to a group if needed
• One BioProject for the study, with a public-friendly title and description
• One BioSample per biological sample, correct package, unique sample names
• Organism names from NCBI Taxonomy (metagenome names for environmental DNA)
• Dates as YYYY-MM-DD and locations as “Country: region”
• Raw, demultiplexed reads; R1 and R2 for every paired sample; md5 checksums saved
• SRA sheet: strategy, source and selection match the protocol; file names match exactly
• Assemblies: ≥200 bp, no end Ns, adapters and contaminants removed, assembly method recorded
• MAGs: ≥90% complete, ≥100 kb, MIMAG BioSamples with derived_from, names agreed with NCBI
• Release date set to match your publication plan

Official NCBI guides used in this article

• 1
  NCBI Submission PortalStart every submission here
• 2
  SRA Quick StartOverview of SRA submissions
• 3
  SRA Submission Portal guideWizard tabs and metadata rules
• 4
  SRA file uploadFTP and Aspera instructions
• 5
  SRA file formatsFASTQ, BAM and paired reads
• 6
  BioSample packagesChoose the right metadata template
• 7
  WGS submissionsGenome assembly rules
• 8
  Genomes FAQIncluding the MAG requirements
• 9
  TSATranscriptome assembly rules
• 10
  TSA Submission GuideStep by step, incl. metatranscriptomes
• 11
  Metagenome Submission GuideWhere each metagenomic data type goes
• 12
  FCS (Foreign Contamination Screen)FCS-adaptor and FCS-GX

Standards papers

• 1
  Field et al. (2008) The minimum information about a genome sequence (MIGS) specificationNature Biotechnology 26:541–547
• 2
  Yilmaz et al. (2011) Minimum information about a marker gene sequence (MIMARKS) and MIxSNature Biotechnology 29:415–420
• 3
  Bowers et al. (2017) Minimum information about a single amplified genome (MISAG) and a metagenome-assembled genome (MIMAG)Nature Biotechnology 35:725–731
• 4
  Astashyn et al. (2024) Rapid and sensitive detection of genome contamination at scale with FCS-GXGenome Biology 25:60

Related guides and courses on Codanics

• 1
  Bioinformatics ka ChillaThe complete bioinformatics course
• 2
  Why learning bioinformatics is essentialStart here if you are new
• 3
  Metabolomics complete guideAnother omics, end to end
• 4
  AlphaFold tutorialProtein structure prediction
• 5
  Bioinformatics ka Chilla playlist40 free video lessons on YouTube
• 6
  Linux for bioinformatics playlistTerminal skills for uploads and servers
• 7
  AlphaFold course playlistProtein structure prediction videos
• 8
  Python ka Chilla for data sciencePython for biological data
• 9
  R with AammarR for statistics and figures
• 10
  Pandas mastery guideClean your sample sheets
• 11
  Using AI tools in scientific writingWrite up your study

More research, AI and bioinformatics guides on the Codanics blog.

NCBI submission glossary

22 key terms in plain English

Submission Portal

NCBI's single website (submit.ncbi.nlm.nih.gov) for registering projects and samples and submitting most sequence data.

SUB number

The temporary ID of a submission in the portal (SUB1234567). Quote it when you contact NCBI; never cite it in a paper.

BioProject

A record that describes your whole study and links all its data. Accession: PRJNA.

BioSample

A record that describes one biological sample, such as a soil core, an isolate or a patient's stool. Accession: SAMN.

BioSample package

The metadata template for a type of sample, such as MIMARKS survey, MIMS, MIGS or MIMAG, with its required fields.

MIxS

Minimum Information about any (x) Sequence: the Genomic Standards Consortium checklists behind the MIMARKS, MIMS, MIGS and MIMAG packages.

SRA

Sequence Read Archive: NCBI's archive of raw sequencing reads with quality scores.

Experiment (SRX)

In SRA, one library of one sample sequenced on one instrument model.

Run (SRR)

The actual data files of an experiment. Most analysis tools download data by SRR accession.

Library strategy

SRA field describing the sequencing approach, such as AMPLICON, WGS or RNA-Seq.

Library source

SRA field describing the type of material, such as GENOMIC, TRANSCRIPTOMIC, METAGENOMIC or METATRANSCRIPTOMIC.

Library selection

SRA field describing how the material was selected, such as PCR, RANDOM, cDNA or PolyA.

GenBank

NCBI's database of annotated nucleotide sequences, such as genes, 16S and ITS sequences and organelle genomes.

WGS

The GenBank division for whole-genome shotgun assemblies: draft genomes, metagenome assemblies and MAGs.

TSA

Transcriptome Shotgun Assembly: the GenBank division for assembled transcripts, including metatranscriptome assemblies.

GEO

Gene Expression Omnibus: NCBI's database for functional genomics such as RNA-seq expression data. Accession: GSE.

MAG

Metagenome-assembled genome: a genome of one organism reconstructed by binning contigs from a metagenome.

PGAP

NCBI's Prokaryotic Genome Annotation Pipeline, which can annotate bacterial and archaeal genomes during submission.

FCS-GX

NCBI's Foreign Contamination Screen, which finds sequences from the wrong organism in an assembly. NCBI runs it on new genome submissions.

table2asn

NCBI's command-line tool that combines FASTA, annotation and a template into a .sqn file for GenBank, WGS or TSA.

Release date

The date NCBI makes your data public. Data are released on that date or when the accessions are published, whichever comes first.

INSDC

The International Nucleotide Sequence Database Collaboration of NCBI, ENA and DDBJ, which share all sequence data.

Frequently asked questions