Twitter Community Notes Scoring Code and Data

What Community Notes Repository Contains

Community Notes is described as a system for adding notes to posts that may be misleading. The repository is not presented as a general-purpose classifier that accepts arbitrary content and returns a misinformation score. Instead, it exposes selected parts of Twitter's implementation and written documentation so that outside researchers can examine the scoring algorithm, read explanations of the program, and conduct downstream analyses.

The repository separates several concerns. The `scoring/src` directory contains the open-source code powering the Community Notes scoring algorithm. The `documentation` directory contains Markdown files used as the source for the Community Notes Guide website. The `template-api-note-writer` directory contains a starter project for the Community Notes AI Note Writer API, while the repository also includes a research paper and several analysis directories, including `evaluator`, `collaborative-note-generator`, and `liked-by-different-perspectives`.

That layout makes the repository useful for engineers who want to work with published artifacts rather than a conventional application package. The README does not describe the repository as a self-hosted service with its own database, frontend, authentication system, or production deployment process. The code is specifically identified as the scoring component, and the public data is published separately through X's Community Notes data download page. Anyone expecting the complete operational system would need to account for the gap between this public repository and X's internal production infrastructure.

Scoring Source and Repository Architecture

The documented entry point for running the scorer is `scoring/src/main.py`. The README instructs users to place downloaded data files in `/scoring/src/` and then run `python main.py` from that directory. This indicates a file-oriented workflow: a user prepares an environment, installs the package versions listed in `requirements.txt`, downloads public data, places the files where the scorer expects them, and starts the program through the Python entry point.

The repository's top-level structure also shows that scoring is one component of a broader research and documentation collection. The documentation directory is the source of truth for the Guide, and the scoring source is published separately from the website content. The README says that the scoring code is developed in an internal repository and exported to GitHub whenever X deploys an update to the scorer. That publication model directly affects how outside changes should be evaluated.

The README accepts pull requests in selected areas, including downstream analyses of scoring model output and alternate scoring algorithm ideas outside the core algorithm. It does not currently accept changes that alter existing APIs because production infrastructure at X depends on those APIs remaining stable. This boundary matters for adoption. The code can be studied and analyzed, but the repository is not an unconstrained upstream fork where every proposed algorithm change is expected to enter production.

Installing the Scorer with the Tested Dependencies

The README gives a virtual environment procedure for installing the exact package versions used with the code. It says that a normal Python installation may work, but recommends `requirements.txt` when the user wants reproducibility. The documented commands create an environment named `communitynotes_env`, activate it, and install the requirements before changing into the source directory.

The README states that multiple versions of Python3 should work and that the code has been tested with Python 3.10. The following is the documented installation sequence:

$ cd scoring
$ python -m venv communitynotes_env
$ source communitynotes_env/bin/activate
$ pip install -r requirements.txt

After installation, the reader needs the data files described in the next section. The README does not provide the file names, download command, or complete preparation procedure in this repository overview. It links to the public Community Notes download page instead. Consequently, the install command alone does not produce a complete runnable example. The user must obtain the appropriate files and place them in `/scoring/src/` as instructed by the README.

Downloading Data and Running the First Scoring Process

The README identifies notes, ratings, and contributor data as publicly available and says they are published daily. It points to the Community Notes download page for the files and to the Guide for instructions on using them. The repository does not include a command for downloading the data, so the first real use is a manual preparation step followed by local execution.

Once the downloaded files are in `/scoring/src/`, the documented first run is:

$ cd scoring/src
$ python main.py

This is a real first use, but the README does not state what output, files, summary, or terminal format the reader should expect from `main.py`. That omission limits how confidently a new user can judge whether a run succeeded. A sensible documentation improvement would be to document the expected inputs and output, but that recommendation is outside the repository's stated instructions and should not be treated as existing functionality.

The daily publication schedule makes the repository suitable for analysis over changing inputs, but it also means a local run is not necessarily reproducible unless the downloaded files are retained. The README does not document versioning of those files, pinning data snapshots, rollback of downloads, or a command for producing a stable analysis archive.

Contribution Boundaries and Deployment Cost

Contribution is possible, but the route is deliberately narrower than a normal open-source project. The README says that pull requests are considered for downstream analyses of scoring model output, alternate scoring algorithm ideas outside the core algorithm, documentation changes in the documentation directory, and open issues. It specifically says that changes to existing APIs are not currently accepted because other utility and production infrastructure code at X depends on those APIs remaining stable.

There is another maintenance boundary for `scoring/src`. The README says this code is developed in a separate internal repository and exported to GitHub when X deploys an update to the scorer. It also says that minor cleanup pull requests touching that directory are unlikely to be merged because of the heavyweight deployment process. That means an engineer considering a pull request should distinguish between documentation work, external analysis, and changes to the deployed scorer. Only the documentation route is described as more likely to be accepted.

The repository is not archived. Its last push was on 2026-10-01, which is a recent push relative to the current repository state. However, the README provides no release history or GitHub releases, so a release-based upgrade process cannot be confirmed. The Apache-2.0 license and `THIRD_PARTY_LICENSES` file are present at the repository level. The repository does not state that the license grants rights to operate X's production service or covers internal infrastructure not included here.

When Community Notes Is the Wrong Tool

This repository is the wrong choice for a team that needs a turnkey API for detecting misleading posts. The public code is identified as a scoring algorithm, and the README directs users to download separate public data and run `main.py`. It does not claim to provide content ingestion for arbitrary posts, account verification, automated enforcement, or a hosted moderation endpoint.

It is also a limited foundation for building an independent alternative ranking system. The core code is published through a deployment export process, API changes are not currently accepted, and the repository does not document a supported fork workflow or a release cadence. Alternate scoring ideas and downstream analysis are accepted categories, but that is different from promising that an outside implementation can replace Twitter's scorer.

For research questions about how Community Notes output is produced or how its published notes and ratings change, the repository is more relevant. For operational moderation, the documented AI Note Writer template is the separate integration path. Users should not infer that the template writer, scoring code, and data download represent one deployable application. They are separate parts of a public repository with different purposes.

Editorial conclusion

Researchers and engineers who need to inspect Community Notes scoring code or analyze its published datasets may adopt this repository for study and downstream analysis. It is a poor fit for teams expecting a complete misinformation detection API, automated moderation service, or independently deployable production platform. Verify the documented Python version, required data files, API stability constraints, and the exact deployment process before modifying scoring code.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. Project website
4. README
5. twitter/communitynotes on GitHub