# How to Convert UniProt IDs to RefSeq Protein IDs By the end of this guide you will be able to take a list of UniProt accession numbers, such as `P04637` or `Q9Y6K9`, and produce a matching list of NCBI RefSeq protein accessions, such as `NP_000537.3`, using three independent routes. You will also know how to verify each mapped accession against NCBI directly, how to handle the cases where one UniProt entry maps to several RefSeq records, and how to troubleshoot the errors that show up most often in real pipelines. Here is what you need on hand before you start: - A plain text list of UniProt accession numbers, one per line or comma separated. UniProt accessions look like `P04637` or `Q9Y6K9`. Entry names such as `TP53_HUMAN` are not accessions and behave differently in mapping tools. - Python 3.8 or later with the `requests` package installed (`pip install requests`), or `curl` if you prefer the command line. - A web browser for the graphical routes. - Optional but useful for large recurring jobs, an NCBI account with an API key, which raises the E-utilities rate limit above the default three requests per second. The conversion matters because UniProt and RefSeq are separate databases maintained by separate organizations. UniProt, hosted through EMBL-EBI and partners, assigns its own stable accessions. RefSeq, maintained by NCBI, assigns accessions like `NP_` (curated reference proteins) and `XP_` (predicted proteins). Each major [protein database](/blog/guides/protein-database) uses its own conventions when assigning identifiers, and resolving the various, potentially unstable, identifiers that refer to identical proteins is a recognized challenge when unifying datasets from multiple sources [1]. There is no global rule that turns one identifier into the other by string manipulation. You need a mapping service, a cross-reference lookup, or a sequence comparison. This article covers all three, and shows when to trust each one. ## Why UniProt and RefSeq identifiers do not line up Before running any conversion, understand what you are mapping between. The confusion behind most failed conversions starts here. **UniProtKB** is the UniProt Knowledgebase. It has two sections. **Swiss-Prot** contains reviewed entries, curated by human annotators with literature-backed function, cross-references, and sequence annotations. **TrEMBL** contains unreviewed entries, generated automatically from coding sequences in the nucleotide databases. Both sections use six-character accessions in the same format, but a TrEMBL accession carries far less curation. **RefSeq** is NCBI's reference sequence database. Curated human and mouse proteins carry `NP_` accessions. Predicted proteins on genome annotation scaffolds carry `XP_` accessions. Many bacterial, archaeal, and viral proteins carry `WP_` accessions, which represent a single non-redundant protein shared across organisms or strains. Three structural differences cause most mapping surprises: 1. **Isoforms.** A UniProt entry can describe several isoforms of one gene, written with a hyphen and a number, for example `P04637-1` and `P04637-2`. RefSeq may represent the same isoforms as separate `NP_` records or collapse them differently. A one-to-one mapping does not exist by design. 2. **Version suffixes.** RefSeq accessions carry a version number, for example `NP_000537.3`. The version increments when the sequence changes. The base accession `NP_000537` stays the same, so most mappings and analyses should compare base accessions, then record the version separately. 3. **Entry churn.** Identifiers in any database can be merged, deleted, or replaced over time. The PICR authors built their service precisely because identifiers are potentially unstable and partial solutions limited to specific species or a small number of databases were not enough for general use [1]. A mapping file you downloaded two years ago may contain pairs that no longer resolve. A fourth difference matters for output interpretation. UniProt cross-references to RefSeq are many-to-many in practice. One UniProt entry can list several RefSeq proteins, and one RefSeq protein can appear under several UniProt entries, especially in TrEMBL where redundancy is higher. ## Three reliable routes to convert UniProt IDs to RefSeq protein IDs ![Decision flowchart leading from a list of UniProt accessions to the website, REST API, cross-reference or sequence-based mapping route.](/article-images/illustrations/convert-uniprot-id-to-refseq-protein-route-choice.webp) | Route | What you provide | What you get back | Best for | |, - |, - |, - |, - | | UniProt ID mapping website | A pasted list of UniProt accessions | A downloadable table of source and target pairs | One-off conversions you want in a spreadsheet | | UniProt ID mapping REST API | The same list, sent from a script | JSON pairs returned to your code | Pipelines and recurring batch jobs | | UniProt cross-references | A single UniProt accession | Every RefSeq ID listed on that entry | Checking one protein in detail, or auditing a mapping | | Sequence-based mapping | The [protein sequence](/blog/guides/protein-sequence), or a UniParc lookup | RefSeq IDs sharing 100 percent sequence identity [1] | Obsolete accessions, ambiguous cases, final validation | The first two routes use the same underlying service. The third reads curated cross-references already stored on the UniProt entry. The fourth sidesteps identifiers entirely and compares sequences, which the PICR service automates through the UniProt Archive (UniParc), a warehouse that stores every distinct protein sequence ever loaded from its source databases [1]. ## Method 1. Convert UniProt IDs to RefSeq proteins on the UniProt website, step by step This route needs no code and works well for lists up to tens of thousands of identifiers. 1. Open the UniProt ID mapping page at `https://www.uniprot.org/id-mapping` in your browser. 2. In the source database selector, choose **UniProtKB**. This covers both Swiss-Prot and TrEMBL accessions. 3. Paste your identifiers into the text box, one per line, or upload a file. A comma-separated list also works. Do not mix entry names and accessions in the same job unless you want both treated as input. 4. In the target database selector, open the group containing NCBI resources and choose **RefSeq Proteins**. 5. Click **Map**. The job runs in seconds for small lists. The page shows a job summary with the number of mapped and unmapped identifiers. 6. Review the summary. If a large fraction came back unmapped, check the format of your input before troubleshooting further. A trailing space, a lowercase letter in an accession, or an entry name in an accession-only field are the usual causes. 7. Download the results as TSV or Excel. The default table has two columns of interest, the source identifier under **From** and the RefSeq accession under **To**. 8. Save both the original input list and the mapping table. Record the date. Because database contents shift over time, a mapping table is a snapshot, and repeating the job months later can give different results. A typical downloaded table looks like this, with tab characters between columns: ``` From To P04637 NP_000537.3 P04637 NP_001268362.1 P01308 NP_000198.1 P68871 NP_000517.2 ``` The version numbers you see reflect the RefSeq records current at the time you ran the job. Later runs may show higher version numbers for the same base accessions, which is expected behavior, not an error. ## Method 2. Convert UniProt IDs to RefSeq proteins with the REST API in Python For anything that repeats, script it. The UniProt ID mapping service exposes the same job through three REST calls. You submit a job, poll its status, then stream the results. ### Step 1. Submit the mapping job ```python import requests import time ID_LIST = [ "P04637", "P01308", "P68871", ] response = requests.post( "https://rest.uniprot.org/idmapping/run", data={ "from": "UniProtKB_AC-ID", "to": "RefSeq_Protein", "ids": ",".join(ID_LIST), }, ) response.raise_for_status() job_id = response.json()["jobId"] print("Job ID:", job_id) ``` ### Step 2. Poll until the job finishes ```python status_url = f"https://rest.uniprot.org/idmapping/status/{job_id}" while True: response = requests.get(status_url) response.raise_for_status() status = response.json() if status.get("jobStatus") == "FINISHED" or "results" in status: break time.sleep(2) print("Done") ``` Small jobs finish between two polls. Large jobs of tens of thousands of identifiers can take a few minutes. Keep the polling interval at two seconds or more and treat the service politely when you loop over many jobs in one session. ### Step 3. Stream the results ```python results_url = f"https://rest.uniprot.org/idmapping/stream/{job_id}" response = requests.get(results_url) response.raise_for_status() pairs = response.json()["results"] for pair in pairs: print(pair["from"], "->", pair["to"]) ``` ### Expected output ``` Job ID: 5a1f0d7c9e2b4a3f8c6d0e1b2a3f4c5d Done P04637 -> NP_000537.3 P04637 -> NP_001268362.1 P01308 -> NP_000198.1 P68871 -> NP_000517.2 ``` Notice two things. First, `P04637` produced more than one line, because the human p53 entry cross-references several RefSeq records covering its isoforms. Second, an input identifier with no RefSeq counterpart simply produces no output row. Your script should detect those silently dropped identifiers and report them, for example like this: ```python mapped_sources = {pair["from"] for pair in pairs} unmapped = [x for x in ID_LIST if x not in mapped_sources] if unmapped: print("No RefSeq mapping for:", ", ".join(unmapped)) ``` ### What each parameter does | Parameter | Value used here | What it does | |, - |, - |, - | | `from` | `UniProtKB_AC-ID` | Declares the identifier type you are submitting. Accessions and entry names both resolve under this type | | `to` | `RefSeq_Protein` | Declares the target database. This returns RefSeq protein accessions, not nucleotide records | | `ids` | Comma-separated accessions | The identifiers to convert. Whitespace is tolerated but commas are the safe separator | | `jobId` | Returned by the run call | The handle for polling status and fetching results. Save it if your script might resume later | The `to` parameter accepts many other values, including `EMBL-GenBank-DDBJ_CDS` for coding sequences and `Gene_Name` for gene symbols. If you pass an unknown value, the run call fails with HTTP status 400 and the response body names the offending field. Fix the value rather than retrying, because the failure is deterministic. ### A compact version using curl If you prefer the shell, the same three steps compress into a short sequence: ```bash JOB=$(curl -s -X POST "https://rest.uniprot.org/idmapping/run" \ -d "from=UniProtKB_AC-ID" \ -d "to=RefSeq_Protein" \ -d "ids=P04637,P01308" | sed 's/.*"jobId":"\([^"]*\)".*/\1/') sleep 5 curl -s "https://rest.uniprot.org/idmapping/stream/$JOB" ``` The response is a JSON document containing a `results` array of `from` and `to` pairs. Parse it with `jq` or any JSON tool rather than regular expressions in production code. ## Method 3. Read the RefSeq cross-references stored on the UniProt entry Every curated Swiss-Prot entry carries a cross-reference section that lists identifiers in other databases, including RefSeq. On the website, open an entry such as `https://www.uniprot.org/uniprotkb/P04637`, scroll to the **Cross-references** section, and expand the **RefSeq** subsection. You will see each RefSeq protein accession with a short note on the evidence for the link. In the legacy flat file format these lines begin with the `DR` prefix followed by the database name, which is why long-time users call them DR lines. In the current REST API the same information lives in the JSON. This is the quickest scripted check for one protein: ```python import requests accession = "P04637" entry = requests.get( f"https://rest.uniprot.org/uniprotkb/{accession}.json" ).json() for xref in entry["uniProtKBCrossReferences"]: if xref["database"] == "RefSeq": print(xref["id"]) ``` Expected output: ``` NP_000537.3 NP_001268362.1 ``` The cross-reference route differs from ID mapping in one useful way. ID mapping computes pairs against the current state of both databases on demand. Cross-references are stored annotations on the UniProt entry, refreshed on UniProt's release schedule. For a handful of proteins the two routes agree. For a large dataset they can drift apart slightly, which is why the verification step later in this article matters. ## Method 4. Sequence-based mapping when identifiers fail or disagree Sometimes you inherit a list of identifiers that no longer resolve, or a mapping that looks wrong. The sequence itself is the ground truth you can fall back on. Two tools cover this well. ### PICR, the Protein Identifier Cross-Referencing service PICR is a web application that provides interactive and programmatic access through both SOAP and REST to a mapping algorithm built on UniParc. It offers protein cross-references based on 100 percent sequence identity to proteins from over 70 distinct source databases loaded into UniParc [1]. Users can copy and paste identifiers or upload files containing sequences in FASTA format, filter mappings by source database, taxonomic ID, and activity status in the source database, and view results as simple or detailed HTML tables or download them [1]. The design principle is the whole point. PICR only reports a cross-reference when the two sequences are identical, base for base. That gives you a defensible mapping when identifier-based routes give you several candidates or none. The practical workflow is: 1. Retrieve the FASTA sequence for your UniProt accession from the entry page or from `https://rest.uniprot.org/uniprotkb/P04637.fasta`. 2. Paste or upload the sequence into the PICR interface. 3. Restrict the output databases to RefSeq. If you know the organism, restrict the taxonomic ID too, for example 9606 for human. Filtering by taxonomy removes cross-species hits that are real sequence matches but wrong for your dataset. 4. Read off the returned RefSeq accessions. Sequence identity is the deepest foundation available for identifier reconciliation. It is no accident that modern sequence classification methods also start from UniProt Knowledgebase data and group identical sequences under shared headings before assigning them identifiers [2]. When two databases describe the same string of amino acids, mapping at the sequence level removes every question about naming conventions. ### NCBI BLAST as a scripted fallback If you need sequence confirmation inside your own pipeline, the NCBI BLAST URL API works from a shell with no extra software: ```bash curl -s -X POST "https://blast.ncbi.nlm.nih.gov/Blast.cgi" \ -d "CMD=Put" \ -d "PROGRAM=blastp" \ -d "DATABASE=refseq_protein" \ -d "QUERY=P04637" ``` The response contains a request identifier line that looks like `RID = ABCD1234EXAMPLE`. Wait for the search to finish, then fetch results: ```bash sleep 30 curl -s "https://blast.ncbi.nlm.nih.gov/Blast.cgi?CMD=Get&RID=ABCD1234EXAMPLE&FORMAT_TYPE=JSON2&ALIGNMENTS=10" ``` In the returned hits, look for a RefSeq accession with 100 percent identity over full query coverage. Anything less is an ortholog or a truncated match, not the same protein. Respect NCBI's guidance on polling intervals when running many searches. For bulk work, downloading precomputed data is more efficient than submitting thousands of individual BLAST jobs. ## Verify every mapped RefSeq ID against NCBI A mapped accession is a claim. Confirm it before it enters a downstream analysis. NCBI E-utilities make this cheap, and the default limit is three requests per second without an API key. Check that the accession exists and see its current metadata: ```bash curl -s "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=protein&id=NP_000537.2" ``` Then pull the actual sequence: ```bash curl -s "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=protein&id=NP_000537.2&rettype=fasta&retmode=text" ``` Expected output: ``` >NP_000537.2 tumor protein p53 [Homo sapiens] MEEPQSDPSIEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGP... ``` Two checks close the loop. First, the organism in the RefSeq header must match the organism of your UniProt entry. Second, a quick sequence comparison against the UniProt FASTA should show identical or near-identical strings. If the header says the wrong species, or the sequence diverges well beyond a few residues, your mapping picked an ortholog instead of the intended protein. If you are verifying thousands of accessions, batch the IDs in the `id` parameter, space separated, and use an NCBI API key. Combine that with a sleep of at least 0.34 seconds between calls, which keeps you under the documented three-per-second default limit. ## A short UniProt database tutorial for everyday work Most identifier problems shrink once you are comfortable navigating UniProt itself. These habits pay off every time you prepare a mapping job. **Search with field qualifiers.** The UniProt search box accepts structured queries. `gene:TP53 AND organism_id:9606` finds the human TP53 entries. Adding `reviewed:true` restricts results to curated Swiss-Prot entries, which carry richer cross-references and are the safer starting point for mapping. **Read the entry page top to bottom.** The header gives the recommended name, the accession, and the entry name. The **Sequence** section shows the canonical sequence and every isoform, each with its own FASTA download. The **Cross-references** section lists RefSeq, PDB structures, and dozens of other databases. The **Function** and **PTM** sections carry the curated biology you often need right after mapping. **Download sequences in batch.** Once you have a set of accessions, retrieve all sequences in one call: ```bash curl -s "https://rest.uniprot.org/uniprotkb/stream?query=accession%3AP04637+OR+accession%3AP01308&format=fasta" ``` **Pull structured tables.** The same search endpoint returns TSV when you ask for it, which drops straight into a spreadsheet alongside your RefSeq mapping: ```bash curl -s "https://rest.uniprot.org/uniprotkb/search?query=reviewed:true+AND+organism_id:9606&format=tsv&fields=accession,id,protein_name,gene_names" ``` **Keep isoform identifiers intact when they matter.** If your experiment measured a specific isoform, map `P04637-2` rather than the canonical `P04637`, because the canonical entry defaults to isoform 1 in most tools. ## Common Mistakes and Limitations These are the errors that account for most bad conversions, with the specific fix for each. 1. **Using entry names as accessions.** `TP53_HUMAN` is an entry name, `P04637` is an accession. The ID mapping service accepts both under `UniProtKB_AC-ID`, but some third-party tools accept only one. If your results contain entries you did not expect, check which form you submitted. 2. **Sending the wrong source or target type.** Mapping with `from=UniProtKB_AC-ID` and `to=RefSeq_Protein` is correct. Passing a plain word like `UniProt` as the source returns HTTP 400 from the run endpoint, and the response body names the invalid field. Fix the parameter value, do not retry. 3. **Treating an empty result as a bug.** A missing row in the output usually means no RefSeq record currently corresponds to that UniProt entry. This is common for TrEMBL entries and for proteins from organisms with thin RefSeq coverage. Confirm with the sequence-based route before concluding the protein has no RefSeq counterpart. 4. **Reading results before the job finishes.** If you request the results stream immediately after submitting a large job, you may get a partial result set. Poll the status endpoint until it reports completion, then stream. 5. **Comparing versioned accessions literally.** `NP_000537.2` and `NP_000537.3` are the same base record at different versions. If you join two tables on the full accession string, a version bump breaks the join. Normalize to the base accession for joins, and track versions in a separate column. 6. **Ignoring one-to-many mappings.** Choosing the first RefSeq hit arbitrarily can silently swap isoforms or pick a predicted `XP_` record over a curated `NP_` record. Decide on a rule, for example prefer `NP_` over `XP_`, prefer the record whose sequence matches the UniProt canonical sequence, and apply it consistently. 7. **Skipping the taxonomy filter in sequence-based mapping.** A 100 percent identical sequence in another species is a real match but the wrong protein for your dataset. When you filter mappings by taxonomic ID, as PICR allows, near-identical paralogs and orthologs stop polluting the output [1]. 8. **Reusing stale mapping files.** Identifier churn is inherent to the problem, which is a core motivation for services that recompute mappings against current data [1]. Regenerate mappings at the start of each analysis cycle rather than copying old tables forward. 9. **Assuming the map is the biology.** A mapping says the databases link two records. It does not guarantee the two records describe exactly the same biological entity, especially for predicted RefSeq models. When a result hinges on one protein, read both entries and compare the sequences. The honest limitation is that identifier mapping is a snapshot of two moving databases. Mappings are reproducible on the day you generate them and auditable if you record your inputs, parameters, and dates. They are not permanent facts. For any result where a single protein drives the conclusion, verify the mapping at the sequence level and cite the database releases you used. ## Frequently Asked Questions ### Can I convert a large batch of UniProt IDs to RefSeq protein IDs at once? Yes. The UniProt ID mapping website accepts pasted or uploaded lists up to tens of thousands of identifiers, and the REST API accepts the same volumes from a script. For very large sets, chunk the input into jobs of a few thousand to keep polling simple and failures recoverable. ### Why does one UniProt ID map to several RefSeq protein IDs? One UniProt entry often describes a gene with multiple isoforms, and RefSeq may represent those as separate protein records. RefSeq also lists both curated and predicted models in some cases. Pick the record that matches your isoform of interest, usually the one whose sequence matches the UniProt canonical sequence. ### What is the difference between NP_ and XP_ RefSeq accessions? ![Two column comparison of NP and XP RefSeq accessions covering curation, source, and which to prefer when both exist.](/article-images/illustrations/convert-uniprot-id-to-refseq-protein-np-vs-xp.webp) `NP_` accessions denote curated RefSeq protein records, generally backed by reviewed annotation. `XP_` accessions denote predicted proteins from automated genome annotation. When both exist for your protein, the `NP_` record is usually the safer reference. ### Why did my UniProt ID fail to map to any RefSeq ID? The identifier may be a TrEMBL entry with no RefSeq counterpart, a deprecated accession, a protein from an organism with limited RefSeq coverage, or simply a typo. Check the accession on the UniProt website first, then try sequence-based mapping with PICR or BLAST before assuming the protein has no RefSeq record. ### Should I keep the version number after the RefSeq accession? Keep it when you need to reproduce an exact sequence, for example in a methods section. Strip it when joining tables or counting distinct proteins, because version increments would otherwise split one record into several. ### Is the UniProt ID mapping service the same thing as PICR? No. UniProt ID mapping is UniProt's own service built on its cross-references and identifier relationships. PICR is a separate EMBL-EBI service that computes cross-references from UniParc using 100 percent sequence identity across more than 70 source databases. Use UniProt ID mapping first and PICR when you need identity-backed confirmation. ### Can I map RefSeq IDs back to UniProt IDs the same way? Yes. Run the same job with `from=RefSeq_Protein` and `to=UniProtKB_AC-ID` in the API, or reverse the direction selectors on the website. Expect one-to-many results in that direction too, because redundant TrEMBL entries can all correspond to one RefSeq record. ### How do I check that a mapped RefSeq ID is still current? Send the accession to NCBI E-utilities. An `esummary` call to the protein database returns the record's current status, and an `efetch` call returns the sequence. If the accession was replaced, the record metadata points to the current one. Re-running your UniProt mapping job on a fresh date is the other quick check. ## Sources 1. [The Protein Identifier Cross-Referencing (PICR) service: reconciling protein identifiers across multiple source databases.](https://pubmed.ncbi.nlm.nih.gov/17945017/) 2. [MehNet: a vigesimal-based model by amino acid melting points generates unique ID numbers for protein sequences](https://pubmed.ncbi.nlm.nih.gov/38230442/)