# How to Visualize AlphaFold Structures in PyMOL By the end of this article you will be able to download a predicted [protein structure](/blog/guides/protein-structure) from the AlphaFold Protein Structure Database, load it into PyMOL, color it by model confidence, split the model into reliable and unreliable regions, align it against an experimental structure from the [Protein Data Bank](/blog/guides/protein-data-bank), and export a publication-quality image. The whole workflow takes about fifteen minutes per protein once you have PyMOL installed. You need three things on hand before you start: - PyMOL, either the licensed version from Schrödinger or the open-source build - A protein identifier, most usefully a UniProt accession such as P04637 - An internet connection for the download and fetch steps This is a hands-on alphafold tutorial. Every command shown is meant to be typed directly into the PyMOL command line at the top of the viewer or into a `.pml` script you run with `run script.pml` or `@script.pml`. ## What You Need Before You Start If you do not have PyMOL yet, the fastest free route on Linux, macOS, or Windows is the open-source build through conda: ```bash conda create -n pymol -c conda-forge pymol-open-source conda activate pymol pymol ``` The licensed Schrödinger version installs with its own launcher and adds features such as better rendering and the plugin manager, but every command in this article works in both versions. When PyMOL opens, you will see three panels: the viewer on the left, the command line at the top, and the object panel at the right where loaded structures appear with action buttons. You also need a way to download files. On the command line, `wget` or `curl` works. In a browser, the download button on each AlphaFold structure page does the same job. ## Understanding an AlphaFold Model Before You Open It ![Decision path for picking mmCIF or PDB and for deciding whether pLDDT alone is enough or PAE is needed.](/article-images/illustrations/visualize-alphafold-pymol-format-choice.webp) An AlphaFold model is a coordinate file like any PDB file, but it carries extra information that changes how you should visualize it. Two numbers matter. The first is pLDDT, the predicted local distance difference test score. It is a per-residue confidence value that runs from 0 to 100 and describes how well the model predicts the position of each residue relative to experiment. pLDDT is stored in the B-factor column of the coordinate file, which is exactly the column PyMOL reads for B-factor-based coloring. This single design choice is what makes PyMOL so convenient for AlphaFold work. The second is PAE, the predicted aligned error. It is a matrix that gives, for every pair of residues, the expected position error in Angstroms if you align the model on one of the two residues. pLDDT tells you whether local geometry is trustworthy. PAE tells you whether the relative placement of two residues, for example residues in different domains, is trustworthy. pLDDT is in the coordinate file, PAE ships in a separate JSON file. Confidence bins follow the official AlphaFold convention: | pLDDT range | Interpretation | Official color | |--|--|--| | 90 to 100 | Very high backbone accuracy | Dark blue | | 70 to 90 | Confident backbone, side chains approximate | Light blue | | 50 to 70 | Low confidence, backbone position approximate | Yellow | | Below 50 | Very low confidence, often genuinely disordered | Orange | Models are distributed as mmCIF (`.cif`) and PDB format. mmCIF is the format the database recommends, and it is what you should use for anything large or multi-chain. The PDB format files exist for compatibility with older tools. Both carry pLDDT in the B-factor column, so the visualization workflow below works identically with either. One more thing to internalize early. An AlphaFold model from the database contains protein atoms only. There are no ligands, no cofactors, no metal ions, and no waters. Sections further down cover how to handle that when your question depends on a bound molecule. ## Getting Structures from the AlphaFold Server The AlphaFold Protein Structure Database, hosted by EMBL-EBI and often called the AlphaFold server, lets you search by protein name, UniProt accession, or gene and download every predicted structure it holds. Coverage is enormous, spanning proteomes from many species, and third-party databases now distribute AlphaFold models for their own domains. BoMiProt 2.0, a bovine milk [protein database](/blog/guides/protein-database), cross-references each entry with AlphaFold predicted models alongside crystal structures [1], and DRAVP, a database of antiviral peptides and proteins, used AlphaFold to predict structures for entries that lack experimentally determined ones [2]. The point is that AlphaFold models have become the default structural representation in many resources, so the visualization skill transfers everywhere. ### Downloading a single structure Every entry has a stable file naming pattern: ``` AF-{UniProt accession}-F{fragment}-model_v{version}.cif ``` For human p53 (UniProt P04637), a download looks like this: ```bash wget https://alphafold.ebi.ac.uk/files/AF-P04637-F1-model_v4.cif wget https://alphafold.ebi.ac.uk/files/AF-P04637-F1-predicted_aligned_error_v4.json ``` The version number changes as the database is rebuilt, so check the current version on the structure page if a link fails. The JSON file is optional for basic viewing but required for the PAE analysis described later. ### Downloading many structures at once For pipelines that need hundreds or thousands of models, manual downloads are not viable. The AlphaFoldDB Structure Extractor accepts NCBI Taxonomy IDs, RefSeq accessions, locus tags, UniProt accessions, and AlphaFold accessions, and returns structures in PDB, mmCIF, bCIF, or PAE JSON formats. It also produces an ID mapping file so you can trace each downloaded model back to its standard accession, reports unmapped IDs separately, and provides an API for programmatic use. The tool was tested with individual inputs and batches of up to 5,000 accessions [3]. If your workflow starts from a genome annotation or a proteome rather than a single accession list, this kind of bulk retrieval is the practical entry point. ### Finding the right model when you do not know the accession Several search tools accept inputs you already have. AlphaFind performs structure similarity search across all of AlphaFold DB, accepts any valid UniProt ID, Protein Data Bank ID, or gene symbol, and returns ranked similar chains with 3D superpositions you can inspect before downloading anything [4]. 3D-AF-Surfer offers real-time structure-based search over AlphaFold2 models using 3D Zernike descriptors and a neural network that classifies models by fold [5]. MrParse finds homologues in both the PDB and the EBI AlphaFold database, ranks experimental homologues by eLLG when reflection data are available, and flags predicted secondary structure, coiled coils, and transmembrane regions, which is useful when you are choosing a model as a molecular replacement search candidate or deciding which regions of a prediction to trust [6]. ## Visualize AlphaFold Structures in PyMOL, Step by Step ![Ten-step flow from loading the AlphaFold file through confidence coloring, trimming, aligning and exporting a session.](/article-images/illustrations/visualize-alphafold-pymol-pymol-workflow.webp) This walkthrough uses the human p53 model, AF-P04637-F1, because it shows both a well-ordered core and long disordered tails, which is the situation you will meet most often. Follow the steps in order. ### Step 1. Load the model In the PyMOL command line: ```pymol cd /path/to/your/models load AF-P04637-F1-model_v4.cif, af_model ``` The `cd` command changes PyMOL's working directory so you can use short file names. After `load`, PyMOL prints a confirmation that the object was created and `af_model` appears in the object panel on the right. The structure shows as a forest of raw lines, which is normal. ### Step 2. Set a clean initial display ```pymol hide everything show cartoon bg_color white orient ``` You should now see a full protein cartoon on a white background, rotated so the whole model fills the viewport. For p53 you will see a compact folded region in the middle with apparently unraveled chains hanging off both ends. Those chains are not a rendering bug. They are the N- and C-terminal tails, and Step 4 will show you what their confidence values say about them. ### Step 3. Confirm that pLDDT is in the B-factor column Before coloring, verify the assumption the whole workflow depends on: ```pymol get_b af_model and name CA and resi 100 ``` PyMOL returns the B-factor of the selected atom. For a trustworthy AlphaFold file it will be a value between 0 and 100, and values in the folded core will sit in the 80s and 90s. If you get 0.00 or values in the tens across the folded core, you may have loaded the wrong file or a file that stores something else in the B-factor column. ### Step 4. Color by pLDDT using the official AlphaFold scheme This script reproduces the exact colors used on the AlphaFold DB website: ```pymol set_color af_blue, [0.00, 0.325, 0.839] set_color af_lightblue, [0.396, 0.796, 0.953] set_color af_yellow, [1.00, 0.859, 0.075] set_color af_orange, [1.00, 0.490, 0.271] select plddt_veryhigh, af_model and b >= 90 select plddt_confident, af_model and b >= 70 and b < 90 select plddt_low, af_model and b >= 50 and b < 70 select plddt_verylow, af_model and b < 50 color af_blue, plddt_veryhigh color af_lightblue, plddt_confident color af_yellow, plddt_low color af_orange, plddt_verylow ``` Save this as `af_confidence.pml` and rerun it any time with `@af_confidence.pml`. The four selection names persist in the session, so you can reuse them for further work. For p53, the DNA binding core should light up blue, and both tails should appear yellow to orange. Save these selections permanently if you plan to reopen the session later: ```pymol select plddt_veryhigh, af_model and b >= 90 select plddt_confident, af_model and b >= 70 and b < 90 select plddt_low, af_model and b >= 50 and b < 70 select plddt_verylow, af_model and b < 50 ``` Selections made through the command line already persist in the object panel, so no extra step is needed. The point of keeping them named is that every later command can refer to `plddt_low` instead of re-typing the B-factor cutoff. ### Step 5. Alternative, a continuous color ramp If you prefer a gradient over discrete bins: ```pymol spectrum b, rainbow, af_model, minimum=0, maximum=100 ``` The `spectrum` command maps the B-factor column onto a color ramp. Setting `minimum=0` and `maximum=100` pins the ramp to the full pLDDT scale so colors are comparable between proteins. Without those arguments, PyMOL scales to the minimum and maximum B-factors actually present in the object, which makes different models look deceptively similar. ### Step 6. Label and inspect specific residues Residue numbering in an AlphaFold model matches the UniProt sequence, which makes it easy to connect the structure to database annotations. To see residue numbers on the confident core: ```pymol label plddt_veryhigh and name CA, "%s" % resi set label_size, 12 zoom plddt_veryhigh ``` To check a single residue of interest, for example a mutation site: ```pymol select mut_site, af_model and resi 248 show spheres, mut_site color magenta, mut_site ``` p53 residue 248 sits inside the DNA binding core, so it should land on a blue region. If your residue of interest lands on yellow or orange, the model is telling you it has no reliable structural information there, and any downstream analysis of that residue is on sand. ### Step 7. Split the model into a reliable core and a low-confidence remainder ```pymol create af_core, af_model and b >= 70 create af_tail, af_model and b < 70 ``` `create` makes a new object from an atom selection, so `af_core` is a standalone coordinate object you can save, align, or export without carrying the unreliable regions along. You can then work with the core in isolation: ```pymol disable af_tail zoom af_core show surface, af_core set transparency, 0.6 ``` To count how many residues survived the confidence cutoff: ```pymol count_atoms af_core and name CA ``` PyMOL prints the count. Because one CA atom represents one residue, that number is your trusted residue count, and comparing it against the UniProt sequence length tells you exactly how much of the protein the model genuinely covers. ### Step 8. Save the trimmed model ```pymol save af_core.pdb, af_core ``` This writes only the confident core to a new PDB file, ready for docking, molecular dynamics setup, or as a search model. ### Step 9. Export a publication-quality image ```pymol hide everything show cartoon bg_color white set ray_opaque_background, off set antialias, 2 ray 2400, 1800 png af_p53_confidence.png, dpi=300 ``` `ray` renders the current view at the stated pixel dimensions. Ray tracing takes a few seconds on a complex scene, and the difference in quality between the live viewport and the ray-traced output is large, so always ray before final export. `set ray_opaque_background, off` writes a transparent background, which drops cleanly into slides and manuscripts. ### Step 10. Save the session ```pymol save af_p53_session.pse ``` A `.pse` session file preserves objects, selections, colors, representations, and camera angle. Reopening it later puts you exactly where you left off, which matters when a figure revision request arrives weeks later. ## A Quick Reference for AlphaFold Work in PyMOL | Task | Command | Notes | |--|--|--| | Load a model | `load AF-P04637-F1-model_v4.cif, af_model` | mmCIF loads cleanly, pLDDT lands in the B-factor column | | Official confidence colors | `color af_blue, plddt_veryhigh` (with the four `set_color` lines) | Matches AlphaFold DB website bins | | Continuous ramp | `spectrum b, rainbow, af_model, minimum=0, maximum=100` | Pin minimum and maximum or colors are not comparable | | Check a residue's confidence | `get_b af_model and name CA and resi 100` | Returns the pLDDT for that residue | | Trim low confidence | `create af_core, af_model and b >= 70` | 70 is the standard confident-backbone cutoff | | Count trusted residues | `count_atoms af_core and name CA` | One CA per residue | | Fetch an experimental structure | `fetch 1TUP, exp_p53` | Downloads from the PDB, needs internet | | Align model to experiment | `align af_model and resi 94-292 and name CA, exp_p53 and name CA` | Reports atom pairs and RMSD in the console | | Surface with transparency | `show surface` then `set transparency, 0.6` | Useful for inspecting pockets in the core | | Publication image | `ray 2400, 1800` then `png file.png, dpi=300` | Always ray trace before export | | Save session | `save session.pse` | Preserves everything for later revision | ## Going Beyond pLDDT, Working with PAE Around PyMOL PyMOL does not have a built-in PAE display, and pLDDT alone can mislead you about multi-domain proteins. A protein can have every domain colored blue and still have an entirely uncertain relative arrangement of those domains, because pLDDT measures local geometry while PAE measures global relationships. The AlphaFold DB structure page includes an interactive PAE viewer in the browser, and that is the fastest way to look at the matrix for a single protein. For scripted analysis, the JSON file parses in a few lines of Python: ```python import json import numpy as np with open("AF-P04637-F1-predicted_aligned_error_v4.json") as f: data = json.load(f) pae = np.array(data["predicted_aligned_error"]) print(pae.shape) # mean PAE within the core domain block (residues 94 to 292) core = pae[93:292, 93:292] print("within-domain mean PAE:", core.mean().round(2)) # mean PAE between core and N-terminal tail (residues 1 to 93) cross = pae[0:93, 93:292] print("cross-domain mean PAE:", cross.mean().round(2)) ``` The expected output is a square matrix with shape equal to the number of residues, a within-domain mean PAE typically a few Angstroms or less, and a cross-domain value for a genuinely flexible connection that can be several times larger. High cross-domain PAE between two otherwise confident domains means the model is confident about each piece and unconfident about how the pieces sit against each other. In PyMOL terms, that is your signal to treat domain orientations as illustrative and to define working selections along the boundaries the PAE matrix reveals: ```pymol select domain1, af_model and resi 1-93 select domain2, af_model and resi 94-292 ``` With domains as separate selections you can color them independently, measure inter-domain distances, or export individual domains as separate files. ## Comparing an AlphaFold Model with an Experimental Structure The most informative visualization in structural biology is often a superposition of prediction against experiment. Continue with p53, whose DNA binding domain has the well-known experimental structure 1TUP. ```pymol fetch 1TUP, exp_p53 ``` `fetch` downloads a structure directly from the Protein Data Bank into the session, so no manual download is needed. The 1TUP entry contains p53 cores and DNA, so restrict the experimental object to one protein chain before aligning: ```pymol remove exp_p53 and not chain A align af_model and resi 94-292 and name CA, exp_p53 and name CA ``` `align` performs a sequence-independent structural superposition and prints its output to the console, including the number of atom pairs superimposed and the final RMSD. Your numbers will differ depending on the structures, but the output takes a form like this: ``` Executive: RMSD = 0.913 (184 to 184 atoms) ``` Reading that output is a skill in itself. The atom count tells you how much of the selection actually matched. If you selected 199 residue pairs and only 184 atoms aligned, look at where the unmatched atoms sit, because alignment gaps cluster in loops with real differences or regions where the model and experiment disagree. The RMSD for a well-predicted core against a good experimental structure is commonly in the low single digits of Angstroms, and per-residue deviation is easy to see after alignment by coloring one object by B-factor and the other by distance: ```pymol color grey, exp_p53 show cartoon, exp_p53 set cartoon_color, grey, exp_p53 ``` Use `super` instead of `align` when the two structures are already known to correspond closely, because `super` uses a more permissive fitting routine that handles small conformational differences gracefully. Use `align` for the first pass between a prediction and a remote homologue. This prediction-versus-experiment comparison is exactly the kind of decision support MrParse was built for in the crystallographic setting, where it consolidates experimental homologues from the PDB and candidates from the EBI AlphaFold database in one pipeline and ranks them for molecular replacement suitability [6]. ## Visualizing Domains, Motifs, and Binding Sites ### Motif retrieval inside PyMOL PyProtif is a PyMOL plugin that automatically retrieves structural and functional motifs from databases such as PDBsum and Pfam and integrates them into the PyMOL interface, where each motif can be selected and manipulated separately across multiple proteins at once [7]. For structural studies where you want to see whether a predicted model actually contains the expected helix-turn-helix, coiled coil, or annotated domain architecture, this moves the lookup inside the viewer instead of forcing a round trip through web pages. ### Metal and cofactor sites that are not in the file Because AlphaFold DB models contain no ions or cofactors, a question such as "where does the zinc go" cannot be answered from the file itself. The MADE approach addresses this by superimposing homologous experimental apo structures on the query and clustering recurring species positions, and its authors show the method can be applied to computer-modeled structures such as AlphaFold models to predict likely cofactor locations [8]. In practice the output of such an analysis can be imported into PyMOL as pseudoatoms or sphere objects, letting you place candidate metal sites onto the predicted structure and judge whether they sit in a plausible pocket. ## Preparing AlphaFold Models for Downstream Analysis Visualization is usually the first step toward simulation or modeling, and two preparation stages matter. The first is protonation. Setting up molecular dynamics with default residue protonation states leads to wrong electrostatics, and physics-based pKa prediction fixes it. The PypKa server computes pKa values, titration curves, and pH-dependent protonation states compatible with AMBER, CHARMM, and GROMOS force fields, and it has precomputed results for over 200,000 structures taken from the PDB and AlphaFold DB that can be retrieved directly, with an API for pipeline integration [9]. For a trimmed AlphaFold core destined for simulation, checking precomputed pKa data takes minutes and prevents the most common electrostatic error. The second is experimental restraint mapping. Crosslinking mass spectrometry captures distance constraints between residues in the native state, and AlphaCross-XL automates the mapping of cross-linked peptides onto protein structures at proteome scale, retrieving structures from the AlphaFold DB rather than requiring manual selection of individual PDB entries [10]. When mapped crosslinks are consistent with an AlphaFold model, confidence in the domain arrangement rises. When they contradict it, the model's inter-domain geometry, the part PAE already flagged as uncertain, is the suspect. ## How Researchers Actually Use This Workflow The pattern described in this alphafold tutorial, download, load, color by confidence, trim, compare, export, is a genuine research workflow, not just an exercise. A study engineering a skeletal muscle-targeted FGF1 conjugate for type 2 diabetes used AlphaFold2 together with PyMOL visualization to construct a fusion protein, MT-FGF1 with a flexible peptide linker joining a muscle-targeting peptide to the engineered growth factor [11]. That is the same command set you practiced above, applied to design decisions about where to attach a linker and which surface to leave exposed. The same workflow scales into database construction. RNAffinityDB, a curated database of experimental RNA-protein binding affinities, anchors each record to a defined protein construct and RNA sequence and links records to interactive visualizations of AlphaFold 3-predicted complex structures [12]. The lesson for your own work is that PyMOL remains the standard inspection layer even as the upstream prediction engines move from AlphaFold2 to AlphaFold3, and coordinate files from the newer systems load in PyMOL the same way. ## Common Mistakes and Limitations These are the errors that account for most wasted hours when people first visualize AlphaFold structures in PyMOL. **Reading yellow as "wrong" instead of "uninformative."** Low pLDDT regions are frequently intrinsically disordered segments, not prediction failures. Analysis of AlphaFold2 models found a correlation between confidence levels and intrinsic disordered regions, which means a long orange tail often reflects real biology, a flexible region, rather than a modeling error [5]. Before deleting a low-confidence region, check whether UniProt annotates that region as disordered. **Overwriting the B-factor column.** pLDDT lives in the B-factor column, and several PyMOL operations write to that same column. Running `alter af_model, b=0` or loading per-atom values into B destroys your confidence data in the loaded session. Keep the original file untouched on disk and keep a `save af_original.pdb` copy in the session before any B-factor manipulation. **Trusting domain arrangements in multi-domain proteins on pLDDT evidence alone.** Blue everywhere does not mean the inter-domain geometry is known. Check the PAE matrix as described above whenever a model has more than one folded region. **Expecting ligands, metals, or waters in the model.** AlphaFold DB models contain none. Any figure implying a bound ligand requires either an experimental structure or an explicit, sourced prediction of where the ligand goes, for example via homologous-structure cluster analysis [8]. **Mixing database versions.** File names carry the model version for a reason. Comparing a v2 model against a v4 model, or quoting a figure from one version with a file from another, creates irreproducible results. Record the version in your methods, and re-download everything from the same version when a figure set must be internally consistent. **Using PDB format files for large or multi-chain systems.** Legacy PDB format has hard limits on chain identifiers and atom counts. For chains beyond the first, for large complexes, and for anything feeding into modern pipelines, download and work with mmCIF. **Assuming residue numbering matches your construct.** AlphaFold models use UniProt numbering. If your plasmid expresses a truncated construct, a tagged fusion, or a different isoform, residue numbers in PyMOL will not match your construct numbering until you map them. Confirm the isoform in UniProt before annotating mutation sites. **Over-trimming before docking or simulation.** Cutting everything below pLDDT 70 produces a clean core but can remove short structured elements and functional loops near the cutoff. Trim thoughtfully, inspect what you are deleting with the `af_tail` object still visible, and remember that downstream physics also needs correct protonation states, which tools such as PypKa handle against both PDB and AlphaFold DB structures [9]. **Treating the model as ground truth.** An AlphaFold prediction is a hypothesis with quantified uncertainty, not an experiment. The confidence metrics tell you where the hypothesis is strong. Where it is weak, seek experimental restraints such as crosslinking mass spectrometry data mapped through tools built for the purpose [10], or an experimental structure from the PDB. ## Next Steps Once the basic visualization loop is comfortable, three directions pay off quickly. First, use AlphaFind to search AlphaFold DB for structural relatives of your protein, accepting a UniProt ID, PDB ID, or gene symbol, and inspect the returned superpositions to decide which homologues are worth downloading [4]. Second, if your work touches crystallography, put MrParse at the front of your pipeline so homologues from the PDB and the AlphaFold database arrive pre-ranked with disorder and transmembrane annotations already visible [6]. Third, automate retrieval for proteome-scale projects through the API of a bulk extraction tool so that structure downloads, ID mapping, and unmapped-ID reporting happen in one step [3]. ## Frequently Asked Questions ### Can PyMOL fetch AlphaFold structures directly? The built-in `fetch` command retrieves structures from the Protein Data Bank, not from the AlphaFold DB. Download AlphaFold files from the AlphaFold DB website or through a bulk download tool, then open them in PyMOL with `load`. ### What is the difference between pLDDT and PAE? pLDDT is a per-residue confidence score from 0 to 100 stored in the B-factor column, describing local geometry. PAE is a residue-pair error matrix in Angstroms stored in a separate JSON file, describing whether the relative positions of residues, especially in different domains, are trustworthy. ### Why do the ends of my AlphaFold model look like spaghetti? Flexible N- and C-terminal termini and other disordered regions receive low pLDDT scores, below 50, because their positions genuinely vary and no single conformation is correct. The spaghetti appearance is the model honestly reporting that uncertainty. ### How do I color an AlphaFold structure by confidence in PyMOL? Color by the B-factor column, where pLDDT is stored. Either define selections at the official cutoffs of 90, 70, and 50 with the matching blue, light blue, yellow, and orange colors, or run `spectrum b, rainbow, object_name, minimum=0, maximum=100` for a continuous ramp. ### Which file format should I download, mmCIF or PDB? Download mmCIF. It is the recommended format, handles any structure size, and carries the same pLDDT information in the B-factor column. The PDB format files exist mainly for compatibility with older software. ### Can I visualize AlphaFold-Multimer or AlphaFold 3 complexes in PyMOL? Yes. Multi-chain coordinate files load with `load` as usual, with chains labeled A, B, C and so on. Interpretation needs care because confidence for interfaces is judged through PAE, and resources such as RNAffinityDB link their records to AlphaFold 3-predicted complex visualizations as the standard display layer [12]. ### How do I trim low-confidence regions before docking or molecular dynamics? Create a new object restricted to residues with pLDDT at or above 70 using `create af_core, af_model and b >= 70`, then `save af_core.pdb, af_core`. Inspect what you are removing first, because short structured loops near the cutoff can be functionally important. ### Can I use PyMOL to compare an AlphaFold model with an experimental PDB structure? Yes. Fetch the experimental structure with `fetch`, restrict it to the chain you want, then run `align` between matching CA atoms. PyMOL reports the number of superimposed atom pairs and the RMSD, and the aligned pair can be colored and exported together. ## Sources 1. [BoMiProt 2.0: An update of the bovine milk protein database.](https://pubmed.ncbi.nlm.nih.gov/35995382/) 2. [DRAVP: A Comprehensive Database of Antiviral Peptides and Proteins.](https://pubmed.ncbi.nlm.nih.gov/37112801/) 3. [AlphaFold Database Structure Extractor: a web server and API to download AlphaFold structures using common protein accessions.](https://pubmed.ncbi.nlm.nih.gov/41291409/) 4. [AlphaFind: discover structure similarity across the proteome in AlphaFold DB.](https://pubmed.ncbi.nlm.nih.gov/38747341/) 5. [Real-time structure search and structure classification for AlphaFold protein models.](https://pubmed.ncbi.nlm.nih.gov/35383281/) 6. [MrParse: finding homologues in the PDB and the EBI AlphaFold database for molecular replacement and more.](https://pubmed.ncbi.nlm.nih.gov/35503204/) 7. [PyProtif: a PyMol plugin to retrieve and visualize protein motifs for structural studies.](https://pubmed.ncbi.nlm.nih.gov/37698713/) 8. [Identifying Metal Binding Sites in Proteins Using Homologous Structures, the MADE Approach.](https://pubmed.ncbi.nlm.nih.gov/37557084/) 9. [PypKa server: online pKa predictions and biomolecular structure preparation with precomputed data from PDB and AlphaFold DB.](https://pubmed.ncbi.nlm.nih.gov/38619040/) 10. [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/) 11. [Novel Muscle-Homing Peptide FGF1 Conjugate Based on AlphaFold for Type 2 Diabetes Mellitus.](https://pubmed.ncbi.nlm.nih.gov/36625595/) 12. [RNAffinityDB: a curated database of experimental RNA-protein binding affinities.](https://pubmed.ncbi.nlm.nih.gov/42894967/)