# How to Batch Download AlphaFold PDB Files By the end of this guide you will be able to download AlphaFold predicted structures in bulk, whether that means five structures for a paper figure, five thousand RefSeq accessions for a proteome screen, or every predicted structure for one organism in a single rsync command. You will also learn how to verify that the files you downloaded are intact, how to pick between PDB, mmCIF, binary mmCIF, and PAE JSON formats, and which downstream tools consume these files directly. Here is what you need on hand before you start: - A Unix-like shell (Linux, macOS Terminal, or WSL on Windows) with `curl` and `rsync` installed. Python 3 with Biopython is useful for validation but not required. - A plain text list of protein accessions, one per line. UniProt accessions work directly against the AlphaFold server. RefSeq accessions and locus tags need a mapping step, which I cover below. - Roughly 1 to 5 GB of free disk space for small batches. Whole-proteome downloads are much larger, so check the size published on the AlphaFold Database download page before you start one. ## AlphaFold DB in Brief: Formats, Confidence, and Naming The AlphaFold Database (AlphaFold DB) is a public collection of predicted protein structures, hosted by EMBL-EBI in partnership with Google DeepMind. It covers more than 200 million predicted structures, essentially every catalogued protein in the UniProt reference proteomes and beyond. Individual structures are identified by the UniProt accession of the protein, prefixed with `AF-` and suffixed with a fragment and version tag, for example `AF-P69905-F1-model_v4.pdb`. Every coordinate file from the database carries per-residue confidence as the predicted local distance difference test score (pLDDT), stored in the B-factor column of the PDB file and in the `B_iso_or_equiv` field of mmCIF. The pLDDT scale runs from 0 to 100. As documented in the AlphaFold method papers and on the AlphaFold DB help pages, the working interpretation is roughly this: scores above 90 indicate very high model confidence, scores from about 70 to 90 indicate a well-modeled backbone, scores from about 50 to 70 indicate low confidence where side chains are uncertain, and scores below about 50 usually mark intrinsically disordered regions rather than a failed prediction. Treat those bands as guidance, not gates. A second confidence measure, the predicted aligned error (PAE), describes the expected positional error between every pair of residues. PAE is distributed as a separate JSON file, not inside the coordinate file. PAE matters when you care about how domains or chains pack relative to each other, which is exactly the question that pLDDT cannot answer. One naming point causes more confusion than anything else in this workflow. The AlphaFold server keys structures by **UniProt accession**, a stable identifier like `P69905` (hemoglobin subunit alpha, human) or `P02768` (serum albumin). A UniProt **entry name** such as `HBA_HUMAN` is a different identifier and will fail. A **gene symbol** such as `HBA1` will also fail as a direct URL. If your list contains anything other than UniProt accessions, plan on a mapping step. ## How to Download AlphaFold PDB Files One at a Time Before scaling up, confirm you understand the URL pattern. The AlphaFold server serves each file at a predictable address built from four parts: the fixed prefix, the UniProt accession, the fragment and model tag, and the version. ```bash curl -fsS -o AF-P69905-F1-model_v4.pdb \ "https://alphafold.ebi.ac.uk/files/AF-P69905-F1-model_v4.pdb" ``` The `-f` flag makes curl fail with a non-zero exit code on HTTP errors instead of saving an error page as your structure file. That single flag prevents the most common silent failure in batch downloads, which is a directory full of zero-byte or HTML files that look fine until you try to parse them. The same accession has sibling files for the other formats: ```bash curl -fsS -o AF-P69905-F1-model_v4.cif \ "https://alphafold.ebi.ac.uk/files/AF-P69905-F1-model_v4.cif" curl -fsS -o AF-P69905-F1-predicted_aligned_error_v4.json \ "https://alphafold.ebi.ac.uk/files/AF-P69905-F1-predicted_aligned_error_v4.json" ``` If the URL pattern is unfamiliar, open any structure page on the AlphaFold DB website, click the download button, and read the filename it offers you. That filename is the template for every scripted download you will ever run against this resource. ## Batch Download AlphaFold PDB Files Step by Step ![Decision path that sends UniProt accessions to a curl loop, whole proteomes to rsync, and RefSeq or locus tags to the Structure Extractor.](/article-images/illustrations/batch-download-alphafold-pdb-files-identifier-triage.webp) There are three practical routes, and the right one depends on scale. The table below summarizes them, and each method gets a full walkthrough in the sections that follow. | Method | Practical scale | Input it accepts | Formats delivered | Use it when | |, - |, - |, - |, - |, - | | rsync mirror | Whole proteomes | Organism proteome identifier | PDB, mmCIF, PAE JSON | You want everything for one species | | Scripted HTTPS fetch | Tens to thousands | Your own accession list | Any single format per URL | You have a curated list of accessions | | AlphaFoldDB Structure Extractor | Up to about 5,000 accessions per run | Taxonomy IDs, RefSeq, locus tags, UniProt, AlphaFold accessions | PDB, mmCIF, bCIF, PAE JSON | Your identifiers are not UniProt accessions, or you want an API call inside a pipeline | ### Method 1: rsync for an Entire Proteome EMBL-EBI exposes the full database over rsync, which is the correct tool when your unit of work is an organism rather than a protein list. Each reference proteome sits under its own proteome identifier. Human, for example, is `UP000005640`. ```bash rsync -rpltvz rsync.ebi.ac.uk::ftp/databases/alphafold/UP000005640 . ``` Expected output looks like this: ``` receiving incremental file list ./ AF-P69905-F1-model_v4.cif AF-P69905-F1-model_v4.pdb AF-P02768-F1-model_v4.cif AF-P02768-F1-model_v4.pdb ... sent 1,234 bytes received 987,654,321 bytes 10,234,567.89 bytes/sec total size is 1,234,567,890 speedup is 1.25 ``` Run it again later and rsync transfers only what changed or what is missing, which makes it the best way to keep a local mirror current. Three cautions before you run this against a large proteome. First, whole-proteome downloads are measured in many gigabytes, so confirm the current size on the AlphaFold DB download page and check your quota. Second, rsync against this mirror can be slow on constrained connections, so start a test with a small proteome first. Third, if you only need the mmCIF or only the PDB files, you can narrow the transfer with rsync include and exclude filters rather than downloading everything and deleting what you do not want. ### Method 2: A Scripted HTTPS Download for Your Own Accession List When you have a specific list of proteins, a small loop over the official URL pattern is simpler than any mirroring strategy. Save your accessions to a file, one per line: ``` P69905 P02768 P00533 ``` Then run a serial loop that logs its own failures. This is the version I recommend as a default because it is easy to audit: ```bash mkdir -p alphafold_pdb while read -r acc do url="https://alphafold.ebi.ac.uk/files/AF-${acc}-F1-model_v4.pdb" out="alphafold_pdb/AF-${acc}-F1-model_v4.pdb" if curl -fsS -o "$out" "$url" then echo "OK $acc" else echo "FAIL $acc" >> failures.txt fi sleep 1 done < accessions.txt ``` Expected console output: ``` OK P69905 OK P02768 OK P00533 ``` The `sleep 1` between requests keeps you from hammering a shared public service. For a few hundred accessions the serial loop finishes in minutes. When you genuinely need speed for a few thousand, use controlled parallelism with `xargs`, keeping the concurrency modest: ```bash xargs -a accessions.txt -P 4 -I {} \ curl -fsS -o alphafold_pdb/AF-{}-F1-model_v4.pdb \ https://alphafold.ebi.ac.uk/files/AF-{}-F1-model_v4.pdb ``` `-P 4` means four downloads in flight at once. Four is a reasonable ceiling for a shared public endpoint. Do not set `-P 50`, because that gets you rate-limited and does not actually finish faster. After the run, check what you actually got: ``` $ ls alphafold_pdb | head AF-P00533-F1-model_v4.pdb AF-P02768-F1-model_v4.pdb AF-P69905-F1-model_v4.pdb $ grep -c "^ATOM" alphafold_pdb/AF-P69905-F1-model_v4.pdb 5705 $ grep -c "^MODEL" alphafold_pdb/AF-P69905-F1-model_v4.pdb 5 ``` Two things in that output are diagnostic. The ATOM count is nonzero, so the file has coordinates. The MODEL count is 5, because every AlphaFold DB PDB file contains five independently predicted structures per fragment, ranked so that model 1 is the best. Many downstream programs either read only model 1 or expect a single-model file, and this is the single most common reason an AlphaFold PDB file behaves oddly in software built for experimental structures. If you want a single-model file, split it with your parser of choice or keep only the first block. Also record what you downloaded and when, so results are reproducible: ```bash cd alphafold_pdb md5sum *.pdb > manifest.md5 date >> ../download_log.txt ``` ### Method 3: The AlphaFoldDB Structure Extractor Web Server and API Most real-world identifier lists are not tidy UniProt accessions. They are RefSeq accessions from an annotation table, locus tags from a genome assembly, or a whole taxon defined by an NCBI Taxonomy ID. Translating those to AlphaFold DB identifiers by hand does not scale. The AlphaFoldDB Structure Extractor was built for exactly this problem. It is an open-access web server and API that accepts NCBI Taxonomy IDs, RefSeq accessions, locus tags in both old and new formats, and UniProt or AlphaFold accessions, then delivers the corresponding structures in PDB, mmCIF, binary mmCIF (bCIF), or PAE JSON [1]. The workflow inside the tool is worth understanding even if you use only its output. It maps each input identifier to a standard accession, retrieves the structure, and returns an ID mapping file that ties every input identifier back to the accession actually used. Identifiers that could not be mapped are reported separately rather than silently dropped [1]. The authors tested the tool with randomly selected accessions of each input type, in individual form and in batches of up to 5,000 accessions, drawn from NCBI RefSeq and Taxonomy, UniProt, and the AlphaFold DB itself [1]. To use the web version, go to the tool at `https://project.iith.ac.in/sharmaglab/alphafoldextractor/`, paste or upload your identifiers, choose your output format or formats, and download the archive. Then do one thing that most users skip: open the mapping file and the unmapped report before you touch the structure files. The unmapped report tells you which of your inputs produced nothing, and the mapping file is your provenance record for every downstream figure and table. A mapping-only mode exists for cases where you want the crosswalk between your identifiers and standard accessions but will fetch coordinates yourself [1]. That is a clean design for pipelines where a separate step handles file transfer. For programmatic use, the tool exposes an API methodology intended for integration into bioinformatics pipelines [1]. The exact endpoint parameters are documented on the tool's own page, so consult that page rather than guessing. The integration pattern in Python looks like this once you have the endpoint details: ```python import requests # Read the tool's API documentation for the exact endpoint and parameters # on the Structure Extractor website before running this. accessions = [line.strip() for line in open("accessions.txt")] response = requests.post(API_ENDPOINT, json={"ids": accessions, "format": "pdb"}) response.raise_for_status() with open("batch_result.zip", "wb") as handle: handle.write(response.content) ``` The value of this route over a homegrown scraper is simple. Someone has already solved identifier resolution, one-to-many mappings, missing entries, and format conversion, and published the tests they ran to validate it [1]. ## Verifying That Your Downloads Are Correct ![Three-step verification flow: find zero-byte files, compute mean pLDDT with Biopython, then reconcile the file set against the input list.](/article-images/illustrations/batch-download-alphafold-pdb-files-verify-downloads.webp) A batch download is not done when the transfer finishes. It is done when you have checked three things: the files are nonempty and parseable, the confidence profile makes sense, and the set matches your input list. First, catch empty or HTML files. Any file pulled with `curl -f` should be fine, but audit anyway: ```bash find alphafold_pdb -name "*.pdb" -size 0 -print ``` An empty result means no zero-byte files. Also spot-check one file's header and residue count against UniProt. For human hemoglobin subunit alpha, a 141-residue protein, a coordinate file with a handful of ATOM records is wrong. Second, inspect the confidence profile of each structure. The mean pLDDT across model 1 is a one-line calculation with Biopython: ```python from Bio.PDB import PDBParser import numpy as np parser = PDBParser(QUIET=True) structure = parser.get_structure("af", "AF-P69905-F1-model_v4.pdb") model = next(structure.get_models()) bfactors = [atom.bfactor for atom in model.get_atoms()] print(len(bfactors), "atoms") print(f"mean pLDDT {np.mean(bfactors):.1f}") ``` Expected output: ``` 1141 atoms mean pLDDT 93.4 ``` (A well-folded globular protein typically sits high on the scale, while a protein with long disordered tails will pull the mean down substantially. The exact number depends on the protein, so treat the output above as an illustration of format, not a reference value.) Remember that pLDDT is defined per residue, so the per-atom mean weights larger residues slightly more heavily. For most screening purposes that bias is negligible, but if you need exact per-residue statistics, take one B-factor value per residue instead. Third, reconcile your file set against your input list: ```bash comm -23 <(sort accessions.txt) \ <(ls alphafold_pdb | sed 's/AF-\(.*\)-F1-model_v4.pdb/\1/' | sort) > missing.txt wc -l missing.txt ``` Everything in `missing.txt` either failed, was unmapped, or never had a prediction in the database. Each of those three causes calls for a different fix, and the AlphaFoldDB Structure Extractor's unmapped report distinguishes them for you [1]. ## Choosing the Right File Format for Your Workflow | Format | What it contains | Best suited to | Practical notes | |, - |, - |, - |, - | | PDB | Coordinates, pLDDT in the B-factor column | Quick visualization, legacy tools, molecular replacement packages | Column-based legacy format, five models per file, size limits on very large proteins | | mmCIF | Coordinates, pLDDT, full metadata | Archival storage, very large proteins and complexes | The recommended wwPDB format, no legacy column limits | | bCIF | Binary, compressed mmCIF | Large batches, web applications, notebooks | Much smaller than mmCIF and fast to parse with Mol* and similar tools | | PAE JSON | Predicted aligned error matrix | Domain packing, interface assessment, chain assembly decisions | A separate file with no coordinates, matched to one structure by accession and version | Two general rules follow from that table. If you are moving structures into software written before 2014, use PDB and be prepared to split the five models. If you are storing or transmitting thousands of files, use bCIF or mmCIF and keep disk usage and transfer times down. The AlphaFoldDB Structure Extractor can deliver any of the coordinate formats plus PAE JSON in a single request, which removes format juggling from the picture entirely [1]. ## Batch Download AlphaFold PDB Files Tips These are the habits that separate a clean reusable dataset from a folder of files you will quietly re-download next month. 1. **Pin the version and record it.** The version tag sits inside every filename, for example `_v4`. Structures change between database releases, so a mixed set of v3 and v4 files is a real analysis problem, not a cosmetic one. Record the version in your manifest and re-download the whole batch if you switch versions. 2. **Map identifiers before you download.** A mapping-only pass through the Structure Extractor costs almost nothing and surfaces every accession that will fail before you have written a single file to disk [1]. Mapping first also produces the tracing file that ties each downloaded structure back to the identifier your collaborators actually sent you [1]. 3. **Use structure-search servers to triage.** If the point of the batch is to find a few interesting structures among many, search before you download. AlphaFind indexes the entire AlphaFold DB on tertiary structure features and accepts a UniProt ID, a PDB ID, or a gene symbol as input, returning similar chains with similarity metrics and superposition visualizations [2]. 3D-AF-Surfer provides real-time structure-based search over AlphaFold models using 3D Zernike descriptors, a rotationally invariant shape representation, with a neural network that retrieves proteins of the same fold more accurately than direct descriptor comparison [3]. Both let you download the fifty structures you care about instead of the five thousand you do not. 4. **Keep retries and failures in the log, not in your head.** The `failures.txt` pattern from Method 2 costs one line of code and answers the question you will otherwise have at 6 p.m. before a deadline. 5. **Prefer bulk routes at scale.** For organism-wide sets, rsync. For cross-proteome batches with messy identifiers, the Structure Extractor, which was explicitly designed to remove the limits on extracting structures for restricted organism lists and capped batch sizes [1]. Reserve direct per-file HTTPS fetches for curated short lists. 6. **Keep checksums.** `md5sum` before you archive and after you restore from backup. Structural data files rarely corrupt in transit, but storage migrations and interrupted rsync runs do corrupt them. 7. **Decide your confidence policy before the download.** Whether you will analyze residues with pLDDT above 90 only, or everything, changes which files you need and how you validate them. Deciding after the download leads to inconsistent filtering across batches. ## Common Mistakes and Limitations **Using entry names or gene symbols where accessions are required.** `HBA_HUMAN` and `HBA1` are legitimate identifiers, and both fail as AlphaFold DB file keys. The failure mode is usually a 404 on every line of the list, which looks like a network problem and is actually an identifier problem. Fix it with a mapping step through UniProt or the Structure Extractor [1]. **Mixing database versions.** The version tag in the filename is not decoration. If half your dataset is v3 and half is v4, any comparison across that dataset carries an uncontrolled variable. The fix is boring and effective: one version per analysis, recorded in the manifest. **Treating every residue as equally trustworthy.** This is the mistake with the most scientific consequences. Regions with pLDDT below about 50 are frequently intrinsically disordered, and the model is a plausible-looking shape there, not a measurement. Work on AlphaFold model classification has explicitly examined the correlation between model confidence and intrinsic disorder for exactly this reason [3]. If your analysis depends on the exact position of a side chain or the packing of two domains, check pLDDT and PAE, and prefer experimental structures where they exist. **Expecting PAE inside the coordinate file.** The coordinate file carries pLDDT. The PAE matrix is a separate JSON file. People who need inter-domain error estimates discover this only after their analysis, and the fix is a second fetch keyed to the same accession and version. **Forgetting that AlphaFold PDB files contain five models.** A single AlphaFold DB PDB file holds five ranked predictions. Tools built for experimental crystal structures often assume one model. Depending on the software, it will either read model 1 only (usually what you want), average over models (usually not what you want), or fail. Split the file or extract model 1 explicitly when interfacing with such tools. **Hammering the public endpoint.** Looping over tens of thousands of HTTPS requests with no delay and high parallelism is a reliable way to get throttled and a discourteous way to treat shared infrastructure. The people who run the AlphaFold server provide rsync for bulk transfer for this reason. Use the bulk route when your batch outgrows the polite per-file route. **Overlooking one-to-many identifier mappings.** A locus tag or RefSeq accession does not always resolve to exactly one UniProt entry, and therefore not always to exactly one AlphaFold structure. This is precisely why the Structure Extractor returns a mapping file and a separate unmapped report instead of a bare pile of files [1]. If you skip the mapping file, you cannot later explain which transcript or gene a given structure came from. **Running out of disk space mid-download.** Whole-proteome rsync transfers are large, and an interrupted rsync is resumable but messy to audit. Check the published size, check `df -h`, and start with a single small proteome to measure throughput before committing to a multi-day transfer. **Confusing the AlphaFold server, AlphaFold DB, and the experimental PDB.** Three related things get conflated. The experimental [Protein Data Bank](/blog/guides/protein-data-bank) holds measured structures. AlphaFold DB, hosted at EMBL-EBI, holds predicted structures keyed by UniProt accession. The AlphaFold server, in the sense DeepMind uses the term, is the interactive service for running AlphaFold 3 predictions on your own input, which is a different product from the database of precomputed AlphaFold 2 models. Batch download workflows described here target the database. **Assuming every protein has a prediction.** Coverage is broad but not universal, and some accessions resolve to no structure at all. A batch that assumed full coverage will show gaps, and the gaps are informative rather than fatal as long as you detect them. The comm-based reconciliation above, or the extractor's unmapped report [1], does that detection for you. ## Where Downloaded Structures Plug Into Real Pipelines Bulk-downloaded AlphaFold structures are the raw material for a growing set of purpose-built tools, and knowing what consumes them helps you choose the right download format on day one. For crystallographers, MrParse consolidates search-model selection in one place. It searches for homologues in both the experimental PDB and the EBI AlphaFold database, ranks experimental homologues by eLLG, a likelihood measure of whether a given search model will solve the structure by molecular replacement, and displays predicted secondary structure, coiled-coil, and transmembrane regions to inform protocol choice [4]. MrParse is a good example of a tool that handles the AlphaFold retrieval step itself, which is worth knowing before you write your own fetch loop for crystallographic triage. For molecular dynamics and electrostatics, PypKa server computes pKa values, isoelectric points, titration curves, and pH-dependent protonation states compatible with the AMBER, CHARMM, and GROMOS force fields. Critically for the batch-download question, PypKa has precomputed results for over 200 thousand structures drawn from the Protein Data Bank and the AlphaFold DB, retrievable through its web interface or API without extra calculation [5]. If your protein is already covered, you can obtain protonation states without downloading and preparing a structure at all. For proteomics, AlphaCross-XL automates mapping of cross-linked peptides onto three-dimensional protein structures at proteome-wide scale, and its first step is retrieving protein structures from the AlphaFold [Protein Structure](/blog/guides/protein-structure) Database [6]. Tools like this demonstrate why programmatic retrieval, either through an API such as the Structure Extractor's [1] or a managed bulk mirror, beats manual per-protein fetching. Crosslinking datasets routinely span thousands of proteins, and the authors built the tool specifically because existing mapping software required manual, single-protein structure input [6]. For structure comparison at scale, AlphaFind performs structure-similarity search across the entire AlphaFold DB, extracting three-dimensional features of each protein chain and using a machine learning model to rank similar structures, with the indexing demonstrated to scale to large datasets and large proteins [2]. 3D-AF-Surfer offers complementary real-time search using 3D Zernike descriptors and has been used to produce structure classifications of AlphaFold 2 models [3]. AlphaFold predictions also appear as content inside curated databases, which can save you the download entirely for targeted questions. The DRAVP database of antiviral peptides and proteins used AlphaFold to predict structures for peptides lacking experimental structures and exposes them through its web interface [7]. BoMiProt 2.0 cross-references AlphaFold predicted models among its structural annotations for bovine milk proteins, retrievable by protein name, accession, or FASTA sequence [8]. RNAffinityDB anchors each curated RNA-protein binding measurement to a defined protein construct and provides interactive visualizations of AlphaFold 3-predicted complex structures alongside records linked to UniProt annotations [9]. In each case the database maintainers did the batch retrieval once, and you query their result rather than repeating it. The practical takeaway from this section is a decision sequence. First check whether an existing tool or database already answers your question. If it does not, decide your identifier type and scale, pick rsync, scripted HTTPS, or the Structure Extractor accordingly, download in a consistent version and format, validate, and then hand the clean set to whatever analysis comes next. ## Frequently Asked Questions ### What is the fastest way to batch download AlphaFold PDB files? For a list of up to a few thousand accessions, the fastest reliable route is the AlphaFoldDB Structure Extractor, which accepts many identifier types and returns PDB, mmCIF, bCIF, or PAE JSON in one pass [1]. For an entire organism, rsync against the AlphaFold server mirror is the standard route. For a short curated list of UniProt accessions, a simple curl loop is fast enough and easiest to audit. ### What is the difference between the AlphaFold server and the AlphaFold Database? The AlphaFold Database, hosted by EMBL-EBI, stores precomputed AlphaFold 2 structures for over 200 million proteins and is what you batch download from. The AlphaFold server, as Google DeepMind uses the term, is the interactive service for running new AlphaFold 3 predictions on user-supplied sequences and complexes. This article covers downloading from the database. ### Why does my download return a curl 404 error? The most common causes are using a UniProt entry name or gene symbol instead of a UniProt accession, requesting a version tag that does not exist for that entry, or fetching an accession that has no prediction in the database. Check the identifier on the UniProt website, confirm the version tag against the filename shown on the structure's AlphaFold DB page, and run a mapping step for non-UniProt identifiers [1]. ### Can I download every structure for one organism in one command? Yes. rsync the proteome directory from the AlphaFold DB mirror, for example `rsync -rpltvz rsync.ebi.ac.uk::ftp/databases/alphafold/UP000005640 .` for human, where `UP000005640` is the human proteome identifier. Whole-proteome transfers are large, so check the published size on the AlphaFold DB download page first. ### Why does an AlphaFold PDB file contain five models? Each AlphaFold DB PDB file contains five independently generated predictions ranked by confidence, with model 1 ranked best. Tools built for single-model experimental structures may read only model 1 or fail on the multi-model file, so extract model 1 explicitly when needed. Verify the count with `grep -c "^MODEL" yourfile.pdb`, which should return 5. ### What pLDDT cutoff should I use before trusting a model? There is no single correct cutoff. The standard interpretation places very high confidence above 90, solid backbone modeling from about 70 to 90, uncertain side chains from about 50 to 70, and likely disorder below about 50. Match the cutoff to your question, and remember that low pLDDT often reflects genuine disorder rather than a prediction failure, a relationship examined directly in work on classifying AlphaFold models [3]. ### How do I download structures using RefSeq accessions or locus tags instead of UniProt accessions? Use the AlphaFoldDB Structure Extractor, which accepts NCBI Taxonomy IDs, RefSeq accessions, old and new locus tags, and UniProt or AlphaFold accessions, maps them to standard accessions, and returns the requested formats along with an ID mapping file and a separate report of unmapped identifiers [1]. Test batches up to 5,000 accessions were used in validating the tool [1]. ### Can I use downloaded AlphaFold structures directly in molecular dynamics or other downstream tools? Often not without preparation. AlphaFold models lack experimental information such as ligands, cofactors, and protonation states, and protonation state assignment matters for simulation correctness. Tools such as the PypKa server provide pKa-based protonation states compatible with AMBER, CHARMM, and GROMOS force fields, with precomputed results for over 200 thousand PDB and AlphaFold DB structures available through its web server and API [5]. Also handle the five-model-per-file issue and low-confidence regions before running any simulation. ## Sources 1. [AlphaFold Database Structure Extractor: a web server and API to download AlphaFold structures using common protein accessions.](https://pubmed.ncbi.nlm.nih.gov/41291409/) 2. [AlphaFind: discover structure similarity across the proteome in AlphaFold DB.](https://pubmed.ncbi.nlm.nih.gov/38747341/) 3. [Real-time structure search and structure classification for AlphaFold protein models.](https://pubmed.ncbi.nlm.nih.gov/35383281/) 4. [MrParse: finding homologues in the PDB and the EBI AlphaFold database for molecular replacement and more.](https://pubmed.ncbi.nlm.nih.gov/35503204/) 5. [PypKa server: online pKa predictions and biomolecular structure preparation with precomputed data from PDB and AlphaFold DB.](https://pubmed.ncbi.nlm.nih.gov/38619040/) 6. [AlphaCross-XL: A Seamless Tool for Automated and Proteome-Scale Mapping of Cross-Linked Peptides Onto 3D Protein Structures.](https://pubmed.ncbi.nlm.nih.gov/40840759/) 7. [DRAVP: A Comprehensive Database of Antiviral Peptides and Proteins.](https://pubmed.ncbi.nlm.nih.gov/37112801/) 8. [BoMiProt 2.0: An update of the bovine milk protein database.](https://pubmed.ncbi.nlm.nih.gov/35995382/) 9. [RNAffinityDB: a curated database of experimental RNA-protein binding affinities.](https://pubmed.ncbi.nlm.nih.gov/42894967/)