OpenReview API: Python Client Guide

The OpenReview API provides programmatic access to scholarly peer review workflows, conference submissions, reviewer evaluations, and discussion threads hosted on the OpenReview platform. In contemporary computer science research, major venues including NeurIPS, ICLR, and ICML rely on OpenReview to coordinate double-blind and open review cycles. Through the official Python client library, researchers, conference chairs, and bibliometricians can automate submission tracking, analyze review score distributions, and ingest peer review datasets directly into computational pipelines.

What it is used for in research

The OpenReview API is primarily used to interact with venue submission systems and study the scholarly evaluation process. While traditional publisher portals keep review records hidden or siloed, OpenReview structures conferences around open, addressable objects. Research teams utilize the API for three core activities:

• Conference Workflow Automation: Program chairs and track managers write automated scripts to monitor reviewer assignment density, track pending meta-reviews, and verify author conflict-of-interest declarations.
• Meta-Research and Peer Review Analysis: Computational social scientists and scientometricians query historical venues to examine reviewer calibration, sentiment patterns, and the dynamics of author rebuttals within open peer review systems.
• Dataset Ingestion for Machine Learning: Researchers building natural language processing models for automated summarization, review generation, and scientific claim verification ingest structured submissions and reviewer threads to benchmark performance on venues where authors have submitted a double-blind conference rebuttal.

Install or access (official source only)

Programmatic access to OpenReview is provided through the official Python package openreview-py, which is maintained by the OpenReview team and distributed on PyPI. The client supports both public read-only queries and authenticated administrative operations across two distinct server tiers: API v1 (legacy venues) and API v2 (modern venues active from 2024 onward).

To install the official client, run the standard package installer in your Python environment:

pip install openreview-py

OpenReview does not charge access fees or require paid enterprise tiers. Publicly released venue data can be queried anonymously, but submitting notes, reviewing papers, or accessing administrative conference tracks requires valid OpenReview account credentials (username and password or an API token). Multi-Factor Authentication (MFA) must be handled during client instantiation if enabled on the user account.

Step-by-step task

The following workflow demonstrates how to authenticate with the modern OpenReview API v2 server, query conference submissions, and extract reviewer scores and evaluation text using the openreview-py client.

1. Initialize the API v2 Client: For modern venues, instantiate OpenReviewClient pointing explicitly to the v2 base URL (https://api2.openreview.net). If you only query public conference archives, you can omit credentials; otherwise, provide your account email and password:

   import openreview
   
   # Initialize authenticated API v2 client
   client = openreview.api.OpenReviewClient(
       baseurl='https://api2.openreview.net',
       username='[email protected]',
       password='your_secure_password'
   )

2. Handle Multi-Factor Authentication (MFA): When MFA is enabled, interactive terminal sessions prompt automatically for a verification code. In headless pipelines or automated cron jobs, supply a callable to the mfa_code_provider argument using a time-based one-time password (TOTP) generator:

   import os
   import pyotp
   import openreview
   
   client = openreview.api.OpenReviewClient(
       baseurl='https://api2.openreview.net',
       username='[email protected]',
       password='your_secure_password',
       mfa_code_provider=lambda method: pyotp.TOTP(os.environ['OPENREVIEW_TOTP_SECRET']).now()
   )

3. Locate the Target Venue Invitation: In OpenReview, invitations define schemas for submissions, reviews, and decisions. Identify the conference invitation path (for example, ICLR.cc/2026/Conference/-/Submission or NeurIPS.cc/2026/Conference/-/Submission) according to the venue’s published call for papers.

4. Fetch Submissions with Nested Replies: Use the get_all_notes() method to retrieve all accepted or submitted papers. Specifying details='directReplies' instructs the server to attach nested child notes—such as official reviews and author comments—directly to each submission object in a single request:

   venue_id = 'ICLR.cc/2026/Conference'
   submission_invitation = f'{venue_id}/-/Submission'
   
   # Fetch submissions along with all associated discussion threads
   submissions = client.get_all_notes(
       invitation=submission_invitation,
       details='directReplies'
   )
   print(f'Retrieved {len(submissions)} conference submissions.')

5. Extract Paper Metadata and Reviewer Ratings: Iterate over the retrieved notes. In API v2, every content field is wrapped inside a dictionary containing a value property. Extract titles, abstracts, and reviewer evaluation scores:

   for paper in submissions:
       paper_title = paper.content['title']['value']
       paper_id = paper.id
       print(f'Paper: {paper_title} (ID: {paper_id})')
   
       # Iterate over child notes attached via directReplies
       replies = paper.details.get('directReplies', [])
       for reply in replies:
           # Check if the child note represents an official review
           if 'Official_Review' in reply.get('invitations', [''])[0]:
               rating = reply['content'].get('rating', {}).get('value', 'N/A')
               confidence = reply['content'].get('confidence', {}).get('value', 'N/A')
               print(f'  - Review Score: {rating} | Confidence: {confidence}')

Understanding these evaluation structures provides essential clarity when analyzing computer science conference authorship conventions across top machine learning venues.

Output and how to read it

The OpenReview API returns information structured as Note objects. Each Note represents an individual communication artifact within the venue, such as a paper submission, an official review, a meta-review recommendation, or an author response. In API v2, the JSON representation follows a rigorous schema:

• id: A unique alphanumeric string identifying the note within OpenReview.
• invitation: The schema identifier governing the note type (e.g., .../-/Official_Review).
• forum: The root note ID representing the original paper submission thread to which all reviews and rebuttals are attached.
• signatures: An array of user or group IDs asserting authorship. For double-blind reviews, this is masked (e.g., ICLR.cc/2026/Conference/Submission123/Reviewer_1).
• readers: The permission list specifying who can view the note (e.g., public, program chairs, or reviewers only).
• content: The actual payload. Crucially, in API v2, each attribute is keyed to a dictionary containing a value field. For example, accessing the paper abstract requires reading note.content['abstract']['value'] rather than indexing a plain string.

Troubleshooting

When developing automated pipelines against OpenReview, developers frequently encounter several recurring failure modes:

• KeyError: 'value' or Type Errors: Occurs when migrating scripts between API v1 and API v2. In API v1, note.content['title'] returns a string directly. In API v2, it returns {'value': '...'}. Always verify whether your target venue uses openreview.Client (v1) or openreview.api.OpenReviewClient (v2).
• Authentication Failure on MFA Accounts: Scripts running in non-interactive CI/CD environments will hang or abort if the account has two-factor authentication enabled without a supplied mfa_code_provider callable. Configure a secret environment variable containing the TOTP seed.
• Empty Results from get_all_notes(): In many computer science conferences, active submissions are moved to blind invitation aliases during review (e.g., .../-/Blind_Submission). If the primary submission path returns zero records, inspect the venue’s active invitation list using client.get_invitations() to locate the current blind alias.
• HTTP 429 Rate Limiting: While OpenReview provides generous API quotas, scraping hundreds of full PDF attachments or polling threads in tight loops will trigger rate limits. Implement exponential backoff and pace requests using small batch sizes.
• OpenReviewException: Forbidden: Returned when querying reviews or decisions before the official venue notification date. Unpublished reviews remain restricted to senior program committee members until the chairs execute the public unblinding release.

Free alternatives

Depending on the research objective, other open bibliographic and scholarly APIs may offer better coverage for published papers, citation networks, or cross-publisher metadata:

Platform / API	Primary Focus	Access Model	Key Strength	Limitation
OpenReview API	Conference peer review workflows and submission tracking	Free REST & Python client (openreview-py)	Direct access to review scores, reviewer comments, and rebuttal threads	Limited to conferences and journals hosted natively on OpenReview
Crossref REST API	Global publisher DOI metadata and citation linking	Free REST API (Polite pool with User-Agent)	Comprehensive coverage of published journals, books, and conference proceedings	Does not index pre-publication review scores or reviewer discussions
Semantic Scholar API	Academic citation graphs and automated paper summaries	Free REST API with registration key	Extensive AI-generated TLDRs and citation velocity metrics across fields	Focuses on published literature rather than active conference review cycles
DBLP API	Computer science bibliographic indexing	Free XML, JSON, and RDF REST endpoints	Authoritative author disambiguation and conference proceeding lists	Contains bibliographic citation records only; no full texts or review data
arXiv API	Open-access scientific preprints	Free XML / OAI-PMH feeds	Instant access to preprints across computer science, physics, and mathematics	Preprint repository only; does not manage peer review or committee decisions

FAQ

Does OpenReview require an account to query public conference data?

No. Public conference submissions, unblinded reviews, and community comments can be retrieved without an account by initializing openreview.api.OpenReviewClient(baseurl='https://api2.openreview.net') without passing username or password credentials. However, authenticated credentials are mandatory when accessing private author submissions, managing reviewer assignments, or submitting administrative actions.

What is the difference between OpenReview API v1 and API v2?

API v1 (hosted at api.openreview.net) is the legacy system used for conferences hosted prior to 2024. In API v1, note content attributes are stored as direct key-value pairs (for example, note.content['title'] = "Paper Title"). API v2 (hosted at api2.openreview.net) introduces a modular schema where each content field contains a nested dictionary with a value property (for example, note.content['title']['value'] = "Paper Title"), allowing field-level permissions and validation.

How do I extract review scores and text using the openreview python client?

To extract review scores, query submissions using client.get_all_notes(invitation='/-/Submission', details='directReplies'). Then iterate through each note’s directReplies attribute, locate notes where the invitation string contains Official_Review, and read the score from reply['content']['rating']['value'].

How can automated data pipelines cite research software used for bibliometrics?

Data pipelines that rely on open-source scientific software and APIs should follow formal citation guidelines. Adopting the FAIR4RS software citation principles ensures that analysis scripts reference the specific software versions and persistent software identifiers used during academic research.

Sources

• OpenReview Documentation: Installing and Instantiating the Python Client. https://docs.openreview.net/getting-started/using-the-api/installing-and-instantiating-the-python-client (Read 2026-11-07).
• OpenReview Documentation: Using the API and Note Content Structure. https://docs.openreview.net/getting-started/using-the-api (Read 2026-11-07).
• OpenReview Python Client Repository: openreview/openreview-py on GitHub. https://github.com/openreview/openreview-py (Read 2026-11-07).