Written and maintained by CASRAI Editorial Board
Last updated
RAPPOR (Randomized Aggregatable Privacy-Preserving Ordinal Response) is a technique for collecting statistics from many users’ software while giving each user strong, quantifiable privacy. Each client randomises its own answer before sending it, so the collector can estimate how common values are across a population without being able to trust, or link, any single report. It is an early and widely cited example of local differential privacy. This page is for researchers and data-protection staff who need to understand what RAPPOR does, run the official research code, and read its parameters and output correctly.
Not the word “rapport”. RAPPOR is an acronym from a 2014 computer-science paper. It is unrelated to “rapport” (a relationship) or “rapporteur” (a person who reports for a committee), and the search term also overlaps with an unrelated UK business of a similar name.
What RAPPOR is used for in research
RAPPOR answers one kind of question: what fraction of a large population has each of a set of string values (for example, which home-page setting or process name is most common), when the collector does not want to hold raw individual values. The original paper (Erlingsson, Pihur and Korolova, ACM CCS 2014, arXiv 1407.6981) describes it as collecting statistics from client software with strong privacy guarantees for each client, and says individual reports are not linkable to a person. Its main deployment described in the paper was Google Chrome, where about 14 million daily respondents who had opted in to usage statistics reported settings such as home-page domains.
It belongs to the local model of differential privacy: noise is added on the user’s device before anything is transmitted. For the central model, where a trusted curator adds noise to released results, see Differential Privacy for Research Data Release. For classical disclosure-control techniques that RAPPOR is often contrasted with, see Data Anonymisation in Research and k-Anonymity and Disclosure Risk in Shared Datasets.
How RAPPOR works, in the paper’s own parameters
The client hashes its value into a Bloom filter, then applies two layers of randomised response. The paper names these parameters:
- k: Bloom filter size in bits. It is chosen for decoding efficiency, not for privacy.
- h: number of hash functions.
- m: number of cohorts. Each client belongs to one cohort and reports its cohort number.
- f: permanent randomised response. Each Bloom filter bit is replaced by 1 with probability f/2, by 0 with probability f/2, and kept with probability 1 – f. The result is memoised, so the same value always produces the same permanent answer on that client.
- p, q: instantaneous randomised response, applied freshly to each report. A bit is reported as 1 with probability q if the memoised bit is 1, and with probability p if it is 0.
The privacy guarantee for a client reporting the same value over time (the longitudinal bound) is ε∞ = 2h ln((1 – f/2) / (f/2)), which does not depend on k. The guarantee for a single report is ε₁ = h log( q*(1 – p*) / (p*(1 – q*)) ), where q* = f/2 (p + q) + (1 – f) q and p* = f/2 (p + q) + (1 – f) p.
Worked parameter table
| Setting (as reported in the paper) | k | h | m | p | q | f | ε₁ |
|---|---|---|---|---|---|---|---|
| Chrome home-page deployment | 128 | 2 | 32 | 0.5 | 0.75 | 0.75 | 0.5343 |
| Windows process-name example | 128 | 2 | 8 | 0.5 | 0.75 | 0.5 | 1.0743 |
For the one-time collection case in the paper (f = 0, p = 0.5, q = 0.75) the ratio inside the logarithm equals 3, giving ε = ln 3 for a single bit. Applying the ε∞ formula to the Chrome row (h = 2, f = 0.75) gives about 2.04; to the Windows row (h = 2, f = 0.5), about 4.39. These two values are computed here from the paper’s formula, not quoted from it. Smaller ε means stronger privacy and noisier estimates. The paper also reports that in the Chrome setting, home-page domains above roughly 0.1% frequency were detectable.
Getting the official code (archived repository)
The reference implementation is the google/rappor repository on GitHub, licensed Apache-2.0. The owner archived it on 27 September 2023, so it is read-only and no longer maintained. Its README describes it as research code in Python and R for simulation and analysis, says it is not yet production quality, and states that the fastrand C extension uses non-cryptographic randomness and must not be used in production. The README points to Chrome’s separate implementation for production use. Treat the repository as a way to reproduce and study the method, not as a deployable privacy component.
Requirements stated in the README: the R analysis needs the packages glmnet and limSolve; the demo additionally needs ggplot2, optparse and bash with coreutils; the Python client needs nothing beyond rappor.py. It was tested on Linux with R 3.0 and Python 2.7.
Running the demo step by step
From the repository root, as listed in the README:
./setup.shinstalls dependencies (Linux)../build.shcompiles and tests thefastrandextension../demo.shruns an end-to-end demo: it simulates client inputs, runs the reporting and analysis, and plots the estimates against the true values.- Open
_tmp/regtest/results.htmlin a browser to see the result. ./test.shruns the Python unit tests, lint checks and the R unit tests.
Reading the output
The demo compares the distribution RAPPOR recovered from noisy reports with the simulated ground truth. Understanding it requires the decoding steps described in the paper:
- For each Bloom filter bit j, the analyst counts reports where that bit is 1 (cij within cohort i). The expected true count is recovered with tij = (cij – (p + f q/2 – f p/2) Ni) / ((1 – f)(q – p)), where Ni is the number of reports in the cohort.
- A design matrix of size km by M is built from the M candidate strings, because each candidate hashes to specific bits in each cohort.
- Lasso regression selects which candidates plausibly occur, and ordinary least squares on the selected strings then yields estimated counts, standard errors and p-values.
- A string is reported as present only if p is below the multiple-testing threshold: the Bonferroni value 0.05/M, or a Benjamini-Hochberg false-discovery-rate procedure.
Two consequences matter when interpreting results. First, decoding works over a set of candidate strings you supply: RAPPOR estimates the frequency of strings you propose. Second, rare values fall below the detection threshold by design, which is the privacy trade-off visible in the roughly 0.1% figure above.
Free alternatives (table)
RAPPOR’s repository is archived, so researchers often look at other free tools and published methods. They are not drop-in replacements: they differ in privacy model, language and purpose. The table records only what each project’s own documentation states, read 7 November 2026.
| Tool or method | What its documentation says | Licence | Official source |
|---|---|---|---|
| OpenDP | A framework for differential privacy; the core is written in Rust with bindings for Python and R. Its front page and repository README do not mention randomized response or the local model, so check its API reference before assuming a local-DP mechanism is available. | MIT (per the repository) | docs.opendp.org; github.com/opendp/opendp |
| Google differential-privacy libraries | Libraries to generate epsilon- and (epsilon, delta)-differentially private statistics over datasets, with building blocks in C++, Go and Java plus end-to-end tools such as Privacy on Beam and PipelineDP4j. The README does not describe them as a local-DP system, so they are not a like-for-like substitute for RAPPOR. | Apache-2.0 | github.com/google/differential-privacy |
| Apple’s local differential privacy | A published method, not a downloadable tool. Apple describes privatising data on the device so the server never receives raw data, using techniques such as Count Mean Sketch, a Hadamard variant that sends one bit, and subsampling of stored records. | Not applicable (no code released through this source) | Apple Machine Learning Research: Learning with Privacy at Scale |
If you need the central model instead, see Differential Privacy for Research Data Release.
Troubleshooting
- Setup fails on Windows or macOS. The README lists Linux as the tested platform and
setup.shas a Linux installer. - Dependency or syntax errors. The code was tested on Python 2.7 and R 3.0; newer interpreters are outside the tested configuration.
- Demo produces no plots. Confirm
ggplot2andoptparseare installed in R, since the demo needs them beyond the core analysis packages. - Wanting to deploy it. The README says not to: the repository is not production quality and its random-number generation is non-cryptographic.
Frequently asked questions
What is RAPPOR?
RAPPOR is a method, published in 2014, in which each client applies randomised response to a Bloom-filter encoding of its value before reporting, letting a collector estimate population frequencies while each client keeps a formal differential-privacy guarantee.
What is the meaning of “rappore”?
In this context it is a misspelling or variant of RAPPOR, the acronym above, which is not a dictionary word. For the relationship sense, the word you want is “rapport”.
What does “rapporter” mean?
“Rapporter” is not part of RAPPOR. The privacy technique takes its name from the acronym Randomized Aggregatable Privacy-Preserving Ordinal Response, so the word has no connection to reporting in the everyday sense.
Is RAPPOR the same as differential privacy?
No. Differential privacy is the general definition; RAPPOR is a specific local mechanism with the ε values given above.
Can I use the GitHub code in production?
The repository’s own README says no. See the archived-repository section.
Sources
- Erlingsson, Ú., Pihur, V. and Korolova, A. RAPPOR: Randomized Aggregatable Privacy-Preserving Ordinal Response. ACM CCS 2014. arXiv:1407.6981, https://arxiv.org/abs/1407.6981 (read 7 November 2026).
- google/rappor repository README, https://github.com/google/rappor (archived 27 September 2023; read 7 November 2026).
- OpenDP documentation, https://docs.opendp.org/en/stable/ and repository https://github.com/opendp/opendp (read 7 November 2026).
- Google differential-privacy libraries, https://github.com/google/differential-privacy (read 7 November 2026).
- Apple Machine Learning Research, Learning with Privacy at Scale, https://machinelearning.apple.com/research/learning-with-privacy-at-scale (read 7 November 2026).
Related CASRAI page: Anonymization vs. Pseudonymization in Research Data.
