# How to Automatically Import References from PubMed Using the NCBI API

## Quick Answer

- Use the NCBI E-utilities API endpoints esearch.fcgi and efetch.fcgi to programmatically search PubMed and retrieve citation data in XML or JSON format.
- Build a script that queries the API with your search terms, collects PMIDs, then fetches full citation records and converts them to RIS or BibTeX for import into Zotero, EndNote, or other reference managers.
- Respect NCBI rate limits of 3 requests per second without an API key and 10 requests per second with one, and always include your email and tool name in API requests to avoid being blocked.

## Understanding the NCBI E-utilities API for PubMed

The National Center for Biotechnology Information provides a set of server-side programs called E-utilities that allow external applications to access databases like PubMed through stable URLs. These tools form the backbone of programmatic literature retrieval for researchers who need to move beyond manual copy-paste workflows.

The two most relevant E-utilities for reference import are esearch and efetch. The esearch utility retrieves PubMed identifiers (PMIDs) that match a query, while efetch retrieves the full citation records for those identifiers in a variety of formats. A third utility, esummary, provides brief document summaries that can be useful for quick screening before committing to full downloads.

The API operates through simple HTTP GET requests. You construct a URL with parameters that define your search, then parse the response. This design makes the system accessible from any programming language with HTTP capabilities, including Python, R, JavaScript, and even command-line tools like curl.

The National Library of Medicine hosts the Research Methods Resources portal as a gateway to authoritative biomedical books and research-method references, which can help you design your literature search strategy before you automate it. The EQUATOR Network provides reporting guidelines that can inform how you document your search methodology for publication.

## Why Automate PubMed Reference Import

Manual reference collection breaks down when your search returns hundreds or thousands of results. Copying citations one at a time from the PubMed web interface introduces transcription errors, consumes hours of repetitive work, and makes it difficult to reproduce your search strategy later.

Automated import solves several concrete problems. First, it ensures consistency. Every citation is retrieved through the same code path, so formatting errors from manual entry disappear. Second, it enables reproducibility. Your search terms and date filters live in your script, so you can rerun the exact same search months later and compare results. Third, it scales to large result sets. A script can retrieve 10,000 citations in minutes, a task that would take days by hand.

The Committee on Publication Ethics Core Practices emphasize transparency in research conduct, and a documented, reproducible search workflow supports that principle. When you can show exactly how you identified your literature, reviewers and collaborators can verify your process.

## Prerequisites for Using the NCBI API

Before writing code, you need three things: a stable internet connection, a tool for making HTTP requests, and a basic understanding of how to parse structured data.

For programming languages, Python with the requests library is the most common choice in academic settings. R users can use the httr package. If you prefer not to write code, you can use command-line tools like curl to make requests and save the output, though you will still need some way to process the returned XML.

You should also create an NCBI account and request an API key. The key increases your rate limit from 3 to 10 requests per second and provides a way for NCBI to contact you if your usage causes problems. The key is free and takes only a few minutes to obtain through the NCBI website.

The National Institutes of Health Grants and Funding portal describes the broader research ecosystem in which NIH-funded work operates, and proper citation management is part of responsible research practice. The NIH Data Management and Sharing Policy outlines expectations for managing research outputs, and your literature search records are part of that data landscape.

## Core API Workflow for Reference Import

The automated import process follows a consistent sequence of steps. Understanding each step helps you debug problems when they arise.

### Step 1: Construct Your Search Query

Your search query uses the same syntax as the PubMed web interface. You can combine terms with Boolean operators, apply field tags, and use date filters. For example, a search for recent articles on bovine respiratory disease might look like this:

```
"bovine respiratory disease"[Title/Abstract] AND ("2020"[Date - Publication] : "2024"[Date - Publication])
```

The esearch utility accepts this query through the term parameter. You also specify the database with the db parameter, set to pubmed, and choose a return format with retmode, typically json for easier parsing.

### Step 2: Retrieve PMIDs with esearch

Your first API call sends the search query to esearch.fcgi. The response contains a list of PMIDs that match your criteria, along with a count of total results. You can paginate through large result sets using the retstart and retmax parameters.

A basic esearch request looks like this:

```
https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&term=bovine+respiratory+disease&retmode=json&retmax=100
```

The response includes the PMIDs in a JSON structure under esearchresult.idlist. You store these identifiers for the next step.

### Step 3: Fetch Full Citations with efetch

With your list of PMIDs, you call efetch.fcgi to retrieve complete citation records. You can request multiple PMIDs in a single call by joining them with commas in the id parameter. The rettype parameter controls the output format, with medline being the most useful for reference import because it contains structured fields for authors, journal, volume, pages, and DOI.

An efetch request looks like this:

```
https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=pubmed&id=12345678,23456789&rettype=medline&retmode=xml
```

The response contains full MEDLINE records for each citation. You can also request XML format for easier programmatic parsing.

### Step 4: Convert to Reference Manager Format

Reference managers like Zotero and EndNote accept RIS and BibTeX files for import. You need to transform the MEDLINE records into one of these formats. Several open-source libraries handle this conversion, including the Python package metapub and the R package easyPubMed.

The conversion maps MEDLINE fields to RIS tags. For example, the AU field becomes the AU tag in RIS, the TI field becomes the TI tag, and the JT field becomes the JF tag. The DOI appears in the AID field with a [doi] qualifier and maps to the DO tag in RIS.

### Step 5: Import into Your Reference Manager

Once you have a RIS or BibTeX file, you import it through your reference manager's standard import function. Zotero accepts RIS files through File, Import. EndNote uses File, Import, and you select the RIS filter. The import creates new library entries with the metadata from your file.

## Python Code Example for Automated Import

The following Python script demonstrates the complete workflow. It searches PubMed, fetches citations, converts them to RIS format, and saves the output to a file.

```python
import requests
import time
import xml.etree.ElementTree as ET

API_KEY = "your_api_key_here"
BASE_URL = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"

def search_pubmed(query, retmax=100):
    params = {
        "db": "pubmed",
        "term": query,
        "retmode": "json",
        "retmax": retmax,
        "api_key": API_KEY
    }
    response = requests.get(f"{BASE_URL}/esearch.fcgi", params=params)
    response.raise_for_status()
    data = response.json()
    return data["esearchresult"]["idlist"]

def fetch_citations(pmids):
    id_string = ",".join(pmids)
    params = {
        "db": "pubmed",
        "id": id_string,
        "rettype": "medline",
        "retmode": "xml",
        "api_key": API_KEY
    }
    response = requests.get(f"{BASE_URL}/efetch.fcgi", params=params)
    response.raise_for_status()
    return response.text

def medline_to_ris(xml_text):
    root = ET.fromstring(xml_text)
    ris_entries = []
    for article in root.findall(".//PubmedArticle"):
        medline = article.find("MedlineCitation")
        pmid = medline.find("PMID").text
        article_data = medline.find("Article")
        title = article_data.find("ArticleTitle").text
        journal = article_data.find("Journal/Title").text
        year = article_data.find("Journal/JournalIssue/PubDate/Year")
        year = year.text if year is not None else ""
        volume = article_data.find("Journal/JournalIssue/Volume")
        volume = volume.text if volume is not None else ""
        pages = article_data.find("Pagination/MedlinePgn")
        pages = pages.text if pages is not None else ""

        ris = ["TY  - JOUR"]
        ris.append(f"TI  - {title}")
        ris.append(f"JF  - {journal}")
        ris.append(f"PY  - {year}")
        ris.append(f"VL  - {volume}")
        ris.append(f"SP  - {pages}")
        ris.append(f"ID  - {pmid}")
        ris.append("ER  -")
        ris_entries.append("\n".join(ris))
    return "\n\n".join(ris_entries)

query = "bovine respiratory disease[Title/Abstract]"
pmids = search_pubmed(query, retmax=50)
print(f"Found {len(pmids)} PMIDs")

xml_data = fetch_citations(pmids)
ris_data = medline_to_ris(xml_data)

with open("references.ris", "w") as f:
    f.write(ris_data)
print("Saved references.ris")
```

This script provides a working foundation. You will need to adapt the XML parsing to handle edge cases like missing fields, multiple authors, and articles with subtitles.

## Rate Limits and Responsible API Usage

NCBI enforces rate limits to protect its servers from overload. Without an API key, you can make 3 requests per second. With an API key, the limit rises to 10 requests per second. Exceeding these limits triggers an error response, and repeated violations can lead to your IP address being blocked.

The responsible approach involves several practices. Always include your email address and tool name in the tool and email parameters of every request. This allows NCBI staff to contact you if your usage becomes problematic. Add a small delay between requests, especially when processing large result sets. The time.sleep function in Python provides a simple way to throttle your requests.

For very large downloads, NCBI recommends using their E-utilities in batches. Fetch citations in groups of 200 or fewer PMIDs per request. This keeps individual responses manageable and reduces the chance of timeout errors.

The National Library of Medicine provides documentation on E-utilities through its books portal, and you should consult that documentation when you need details about specific parameters or response formats.

## Handling Large Reference Sets

When your search returns thousands of results, you need a strategy for managing the volume. The esearch utility returns a count of total results in the count field. You can use this number to plan your retrieval.

For result sets larger than the default retmax of 20, you must paginate. Set retstart to the starting position and retmax to the number of records you want. A loop that increments retstart by retmax until you have retrieved all records handles this cleanly.

A practical approach for very large sets involves a two-phase workflow. First, run esearch to collect all PMIDs and save them to a file. Second, process the PMIDs in batches through efetch. This separation lets you review the search results before committing to the full download.

The NIH Data Management and Sharing Policy emphasizes planning for data outputs, and your literature retrieval records should be part of that planning. Saving your search queries, date stamps, and PMID lists creates an audit trail that supports reproducibility.

## Common Failure Patterns and Troubleshooting

Several problems recur when researchers automate PubMed imports. Recognizing these patterns helps you resolve them quickly.

### HTTP 429 Rate Limit Errors

The most common failure is exceeding the rate limit. The API returns an HTTP 429 status code with a message about too many requests. The fix involves adding delays between requests and ensuring your API key is included in every request.

### Empty Results from esearch

If your search returns no PMIDs, check your query syntax. Common issues include mismatched quotation marks, incorrect field tags, and date ranges that exclude all results. Test the same query in the PubMed web interface to confirm it returns results there.

### XML Parsing Errors

MEDLINE XML can contain unexpected structures. Some articles lack volume or page numbers. Others have multiple titles or complex author lists. Your parser must handle missing elements gracefully, typically by using conditional checks before accessing fields.

### Incomplete Citation Data

Some records in PubMed lack complete metadata. Conference abstracts, ahead-of-print articles, and older records may have missing fields. Your conversion script should handle these gaps without crashing, and you should review the output for completeness after import.

### Character Encoding Problems

Titles and author names can contain special characters, including accented letters and Greek symbols. Ensure your script handles UTF-8 encoding properly. In Python, this means reading and writing files with the encoding parameter set to utf-8.

## Choosing Between Reference Managers

The import workflow produces files that work with most major reference managers, but your choice of manager affects your ongoing workflow. Zotero offers free, open-source software with browser integration and cloud sync. EndNote provides extensive formatting options and integration with Microsoft Word. Mendeley combines reference management with social networking features.

The ORCID for Researchers portal describes how persistent researcher identifiers integrate with scholarly workflows. Your reference manager can connect to your ORCID record, which helps you maintain an accurate publication list and simplifies grant reporting.

Consider your specific needs when choosing a manager. If you collaborate with colleagues who use a particular tool, compatibility matters. If you need to format citations in a specific journal style, check that your manager supports that style. If you work across multiple devices, cloud sync becomes important.

## Records and Documentation for Reproducibility

Automated reference import supports reproducible research only when you document your process. Keep a record of your search queries, the date you ran them, the database version, and the exact parameters used. This information belongs in your methods section or supplementary materials.

The EQUATOR Network provides reporting guidelines that help you document your search methodology transparently. Following these guidelines ensures that other researchers can understand and replicate your literature identification process.

Your documentation should include the script or code used for the import, the version of any libraries, and the date of retrieval. PubMed content changes over time as new articles are indexed, so the date of your search is essential context.

## Professional Escalation Criteria

Most PubMed API issues resolve with basic troubleshooting, but some situations warrant escalation. Contact NCBI technical support if you experience persistent errors that you cannot resolve, if the API returns unexpected data structures, or if you believe your IP address has been incorrectly blocked.

For research integrity concerns, such as suspected duplicate publications or citation errors in PubMed records, contact the journal or the National Library of Medicine directly. The Committee on Publication Ethics Core Practices describe the responsibilities of researchers and journals in maintaining publication integrity.

If your institution has a research support office or library, their staff can provide guidance on literature search best practices and reference management. Many universities offer workshops and consultations on these topics.

## At a Glance

| Task | Tool or Method | Key Parameter | Common Pitfall |
|------|---------------|---------------|----------------|
| Search PubMed | esearch.fcgi | term, retmode=json | Incorrect query syntax returns empty results |
| Fetch citations | efetch.fcgi | id, rettype=medline | Requesting too many PMIDs per call causes timeouts |
| Convert format | Python or R library | RIS or BibTeX output | Missing fields produce incomplete entries |
| Import to manager | Zotero, EndNote, Mendeley | File import function | Duplicate detection requires cleanup |
| Rate limiting | API key and delays | 10 requests per second with key | Exceeding limits triggers HTTP 429 errors |

## Practical Implementation Steps

Follow these steps to implement automated PubMed reference import in your workflow.

1. Create an NCBI account and request an API key.
2. Test your search query in the PubMed web interface to confirm it returns the expected results.
3. Write a script that calls esearch with your query and saves the PMIDs.
4. Add error handling for rate limits and network failures.
5. Fetch citations in batches of 200 or fewer PMIDs.
6. Convert the MEDLINE XML to RIS format.
7. Import the RIS file into your reference manager.
8. Review a sample of imported records for completeness and accuracy.
9. Save your script and search parameters for future reuse.
10. Document the retrieval date and database version in your methods.

## Observations and Quality Control

After importing references, verify the quality of your library. Check that titles are complete, author names are correctly formatted, and DOIs are present where available. Spot-check 10 to 20 percent of imported records against the PubMed web interface to confirm accuracy.

Track the number of records retrieved versus the number expected from your search count. Discrepancies indicate problems with pagination or batch processing. Your script should log these numbers for review.

The NIH Grants and Funding portal emphasizes the importance of rigorous research practices for funded projects. Accurate reference management supports that rigor by ensuring your citations correctly represent the literature you reviewed.

## Limitations of Automated Import

Automated import has boundaries you should understand. The API returns records as they exist in PubMed, so errors in the source database propagate to your library. Some records lack complete metadata, particularly older articles and conference abstracts.

The API does not provide full-text content. You must obtain PDFs through other channels, such as publisher websites, institutional subscriptions, or interlibrary loan. Your reference manager can link to full text, but the import process itself only handles citation metadata.

Automated import also cannot assess relevance. Your search query determines what you retrieve, and you still need to screen results for relevance to your research question. The automation handles the mechanical work of collecting citations, not the intellectual work of selecting sources.

## Safety and Regulatory Context

The NIH Data Management and Sharing Policy applies to NIH-funded research and requires data management plans that address data preservation and sharing. Your literature search records, including automated retrieval scripts and result sets, fall within the broader data management landscape.

For researchers working with animal subjects, the National Library of Medicine resources include guidance on searching the veterinary and animal health literature. The Research Methods Resources portal provides access to authoritative references on research methodology that can inform your search strategy.

The Committee on Publication Ethics Core Practices address data integrity and authorship. When you use automated tools for literature retrieval, you should document their use in your methods and ensure that all contributors to the research receive appropriate credit.

## Building a Decision Framework for Batch Size and Retry Strategy

Choosing the right batch size and retry strategy determines whether your automated import completes in minutes or stalls for hours. The NCBI API documentation specifies that efetch requests should retrieve no more than 200 PMIDs per call, but that ceiling does not mean 200 is optimal for every workflow. Your network stability, the complexity of your XML parsing code, and the total size of your result set all influence the ideal batch size.

### Selecting Batch Size Based on Result Volume

For result sets under 500 records, a single efetch call with all PMIDs works reliably on most connections. The response size stays manageable, and a single failure means you only rerun one request. For result sets between 500 and 5,000 records, use batches of 100 to 200 PMIDs. This range balances the number of HTTP requests against the risk of timeout on large responses. For result sets above 5,000 records, drop to batches of 50 to 100 PMIDs. Smaller batches make it easier to resume after an interruption and reduce the memory footprint of parsing each response.

Your choice also depends on the rettype parameter. MEDLINE format produces compact records, so you can push toward the 200 PMID ceiling. XML format with retmode=xml produces larger responses because it includes full tag structure. If you request XML, use smaller batches of 50 to 100 PMIDs to avoid response sizes that slow down parsing or trigger gateway timeouts.

### Implementing a Retry Strategy with Exponential Backoff

Network failures and transient server errors happen even with careful rate limiting. A retry strategy distinguishes a robust script from one that crashes on the first hiccup. The standard pattern is exponential backoff with a maximum retry count.

Start with a base delay of 2 seconds. After each failed request, double the delay before retrying. Cap the delay at 30 seconds and limit retries to 5 attempts per request. This approach handles temporary network glitches without hammering the server. Track which PMIDs failed after exhausting retries and write them to a separate file for manual review.

Your retry logic should distinguish between error types. HTTP 429 rate limit errors mean you should wait longer before retrying. HTTP 400 errors indicate a malformed request that will not succeed no matter how many times you retry. HTTP 500 and 503 errors suggest temporary server problems that may resolve with a short wait. Log the status code for each failure so you can diagnose patterns later.

### Recording Progress for Resumable Imports

Large imports benefit from a progress record that survives interruptions. Write each successfully fetched batch to disk immediately instead of accumulating everything in memory. Use a simple text file that tracks which PMIDs have been processed. If your script crashes, you can restart it with a flag that skips already processed PMIDs.

A practical implementation writes three files during the import: a PMID list from esearch, a progress log with timestamps for each completed batch, and the accumulated RIS output. The progress log lets you see exactly where the process stopped. The PMID list lets you recompute which batches remain. The RIS output preserves completed work even if the final write fails.

### Comparing Single-Phase and Two-Phase Retrieval

The existing workflow retrieves PMIDs and citations in one continuous process. A two-phase approach separates these operations and offers distinct advantages for large result sets.

In the first phase, run esearch and save all PMIDs to a file. Review the count and sample the PMIDs before fetching any citations. This review catches search query errors early, before you spend time and API requests on a faulty retrieval. In the second phase, read the PMID file and process it in batches through efetch. This separation also makes it easier to rerun the citation fetch later when PubMed updates records or when you need to refresh your library.

The two-phase approach costs extra disk space for the PMID file but saves time when searches return unexpected results. A search that accidentally matches 50,000 records instead of the intended 500 becomes obvious in the first phase, and you can correct the query before fetching any citations.

### Common Failure Patterns in Batch Processing

Several failure patterns recur when researchers implement batch retrieval. Recognizing them helps you build defensive code from the start.

The first pattern is partial batch failure. One PMID in a batch of 200 causes the entire request to fail. The fix involves splitting batches further or implementing per-PMID retry logic that isolates failures. The second pattern is silent truncation. Some responses may be cut off mid-stream, producing XML that parses without error but contains fewer records than expected. Compare the number of parsed records against the number of PMIDs you requested to catch this issue.

The third pattern is duplicate processing after a crash. If your script crashes after fetching a batch but before logging it as complete, restarting from the beginning of that batch creates duplicate entries in your RIS output. Deduplicate by PMID after import, or design your progress log to record PMIDs as completed immediately after successful parsing instead of after writing to the output file.

### Practical Implementation Steps for Batch Processing

Follow these steps to implement a robust batch processing workflow.

1. Run esearch and save all PMIDs to a text file with one PMID per line.
2. Count the total PMIDs and divide by your chosen batch size to estimate the number of requests.
3. Write a loop that reads PMIDs in batches and calls efetch for each batch.
4. Add exponential backoff retry logic with a maximum of 5 attempts per batch.
5. Log the status code and timestamp for each batch attempt.
6. Write each successfully parsed batch to the RIS output file immediately.
7. Track processed PMIDs in a separate progress file.
8. After the loop completes, compare the number of processed PMIDs against the total from esearch.
9. Review any PMIDs that failed after all retries and fetch them manually or with a separate script.
10. Deduplicate the final RIS file by PMID before importing into your reference manager.

### Records and Measurements for Quality Assurance

Maintain a batch processing log that records the batch number, the range of PMIDs in the batch, the HTTP status code, the time taken, and the number of records parsed. This log serves as your audit trail for the import process. The National Library of Medicine Research Methods Resources portal provides guidance on documenting research methods, and your batch log supports that documentation.

Compare the total records parsed against the esearch count. A discrepancy of more than 1 percent indicates a problem with batch processing or response truncation. Investigate before importing into your reference manager. The NIH Data Management and Sharing Policy emphasizes planning for data quality, and your import log provides the evidence needed to verify that quality.

### Professional Escalation Criteria for Batch Failures

Most batch processing issues resolve with adjusted batch sizes or retry logic. Escalate to NCBI technical support if you experience persistent HTTP 500 errors across multiple batches, if responses consistently truncate regardless of batch size, or if your requests are blocked despite respecting rate limits. Document your batch sizes, retry attempts, and error patterns before contacting support so you can provide specific details.

For research integrity concerns related to citation accuracy, consult the Committee on Publication Ethics Core Practices. If you suspect that PubMed records contain errors that affect your import, contact the National Library of Medicine directly with specific PMIDs and the nature of the suspected error.

## Frequently Asked Questions

### What is the difference between esearch and efetch in the NCBI API?

The esearch utility finds PubMed identifiers that match your search query and returns a list of PMIDs. The efetch utility retrieves the full citation records for specific PMIDs. You use esearch first to identify relevant records, then efetch to download their complete metadata.

### How many requests per second can I make to the NCBI API?

Without an API key, the limit is 3 requests per second. With a free API key from NCBI, the limit increases to 10 requests per second. Always include your API key in requests to take advantage of the higher limit and to help NCBI contact you if needed.

### What format should I use for importing references into Zotero?

Zotero accepts RIS files through its import function. The RIS format uses tagged lines to represent citation fields, and most reference managers support it. Your conversion script should produce RIS output with tags for title, author, journal, year, volume, pages, and DOI.

### Can I use the NCBI API with R instead of Python?

Yes, the API works with any language that can make HTTP requests. R users can use the httr package to call the API and the xml2 package to parse responses. The easyPubMed package provides higher-level functions specifically designed for PubMed queries.

### How do I handle searches that return more than 10,000 results?

Use the retstart and retmax parameters to paginate through results. Set retmax to a manageable batch size, such as 200, and loop through the results by incrementing retstart. Save PMIDs to a file as you go to avoid losing progress if the process is interrupted.

### What should I do if my API requests return HTTP 429 errors?

An HTTP 429 error means you have exceeded the rate limit. Add a delay between requests using a sleep function, ensure your API key is included in every request, and reduce the number of PMIDs per efetch call. If problems persist, check whether your IP address has been blocked.

### How do I include my email address in API requests?

Add the email parameter to every request with your email address as the value. Also add the tool parameter with a name for your script or application. This information helps NCBI staff contact you if your usage causes problems.

### Can automated import replace manual literature screening?

No, automated import handles the mechanical collection of citation metadata but cannot assess relevance. You still need to screen retrieved records for relevance to your research question. The automation saves time on data entry, not on intellectual evaluation of sources.

## Using the Evidence

| Source | Best use in this topic | Important limitation |
|---|---|---|
| [Research Methods Resources](https://www.ncbi.nlm.nih.gov/books) | official guidance | Check the linked page for current local requirements |
| [EQUATOR Network](https://www.equator-network.org/) | official guidance | Check the linked page for current local requirements |
| [Core Practices](https://publicationethics.org/core-practices) | official guidance | Check the linked page for current local requirements |

## Related Articles

- [Ncbi Reference Genome](/blog/guides/ncbi-reference-genome)
- [The Role of the Research Ethics Committee: What Researchers Need to Know](/blog/guides/the-role-of-the-research-ethics-committee-what-researchers-need-to-know)
- [Reference Managers for Researchers: Choosing a Workflow That Survives Collaboration](/blog/careers/reference-managers-for-researchers-choosing-a-workflow-that-survives-collaborati)
- [Ncbi Genbank](/blog/guides/ncbi-genbank)
- [Ncbi Gene](/blog/guides/ncbi-gene)

## References and Further Reading

- [Research Methods Resources](https://www.ncbi.nlm.nih.gov/books). National Library of Medicine.
- [EQUATOR Network](https://www.equator-network.org/). EQUATOR Network.
- [Core Practices](https://publicationethics.org/core-practices). Committee on Publication Ethics.
- [NIH Grants and Funding](https://grants.nih.gov/). National Institutes of Health.
- [ORCID for Researchers](https://info.orcid.org/researchers). ORCID.
- [Data Management and Sharing Policy](https://sharing.nih.gov/data-management-and-sharing-policy). National Institutes of Health.
- [NCBI Literature Resources](https://www.ncbi.nlm.nih.gov/). National Center for Biotechnology Information.
- [PubMed](https://pubmed.ncbi.nlm.nih.gov/). National Library of Medicine.

> This article is educational and does not replace institutional policy, professional advice, or applicable safety and regulatory requirements.