rfair
Assess the FAIRness of Research Data Objects and Software
A native R implementation of the F-UJI (FAIRsFAIR Research Data
Object Assessment) and FRSM (FAIR for Research Software) metrics for
evaluating how well a research data object or piece of research software
satisfies the FAIR principles (Findable, Accessible, Interoperable,
Reusable). The software metrics operationalize the FAIR Principles for
Research Software (FAIR4RS) of Chue Hong et al. (2022)
rfair 
Assess the FAIRness of research data objects and software, natively in R.
rfair is a native R implementation of the
F-UJI (FAIRsFAIR Research Data
Object Assessment) metrics. Given a persistent identifier or URL it resolves the
object, harvests metadata from its landing page, from DOI registries (DataCite,
Crossref, and other agencies), from code forges (GitHub, GitLab, Codeberg), and
from repository APIs (Zenodo, figshare, Dataverse, Dryad), and scores it against
the FAIRsFAIR metrics
(v0.8 by default) for Findability,
Accessibility, Interoperability, and Reusability.
rfair began as a fork of rfuji, an HTTP
client for an external F-UJI server; unlike that client it performs the entire
assessment in R: no Python, no server. It also scores research software
against the FRSM (FAIR for Research Software) metrics, which operationalize the
FAIR4RS Principles (Chue Hong et al. 2022).
It also goes beyond F-UJI with checks that automated FAIR tools usually miss (prompted by peer review of a COVID-19 FAIR-assessment study): whether a license actually permits reuse, whether data is controlled-access / sensitive, and whether identifiers follow best practices.
Installation
# From CRAN
install.packages("rfair")
# Development version from GitHub
# install.packages("remotes")
remotes::install_github("choxos/rfair")
Interactive app
No install required: a browser version (registry-only) is published at https://choxos.github.io/rfair/app/. Inside R, launch the bundled Shiny app:
launch_rfair() # bslib Shiny app: scores, per-metric report, reuse/access panels
Quick start
library(rfair)
a <- assess_fair("https://doi.org/10.5281/zenodo.8347772")
a
#> <fair_assessment> https://doi.org/10.5281/zenodo.8347772
#> resolved: https://zenodo.org/records/8347772
#> metrics: v0.8 (17 metrics)
#> FAIR earned percent maturity
#> F 7/7 100.0% 3
#> A 7/7 100.0% 3
#> I 4/6 66.7% 2
#> R 5/6 83.3% 2
#> FAIR 23/26 88.5% 2
# (illustrative; exact scores depend on the object's live metadata)
summary(a) # F/A/I/R score table
as.data.frame(a) # one row per metric
plot(a, type = "sunburst") # concentric FAIR sunburst (also "category" / "metric")
as_fuji_json(a) # F-UJI-compatible JSON
as_rdf(a) # DQV + schema.org Rating + FAIR Test Results (JSON-LD)
fair_recommendations(a) # what to fix, largest score gain first
fair_compare(a, a2) # a2: the same record after a metadata fix
# Research software, scored against the FRSM metrics (GitHub, GitLab,
# Codeberg, or a software DOI that links its repository):
sw <- assess_fair("https://github.com/pangaea-data-publisher/fuji",
metric_version = "0.7_software")
sw$software # the repository signals the FRSM tests use
fair4rs_principles() # the FAIR4RS principles the software metrics map to
fair4rs_principles("R") # filter to one foundational principle
Metric versions and F-UJI options
rfair bundles the current F-UJI website choices plus release-specific legacy
metric files from upstream F-UJI:
rfair_metric_versions()
#> 0.8 0.5 0.5ssv2 0.5ss 0.5env 0.7_software ...
assess_fair(
"https://doi.org/10.5281/zenodo.8347772",
metric_version = "0.5ssv2",
use_datacite = TRUE,
metadata_service_endpoint = "https://example.org/oai",
metadata_service_type = "oai_pmh"
)
Supported metadata service type labels include OAI-PMH, OGC CSW, SPARQL, DCAT, schema.org JSON-LD, DataCite, Crossref, Signposting, typed links, RO-Crate, CKAN, and a generic other metadata document option.
Beyond F-UJI
# A license can be present yet NOT open for reuse
license_reuse("https://creativecommons.org/licenses/by-nc-nd/4.0/")$is_open
#> [1] FALSE
# Controlled-access / sensitive data is not a FAIR failure
classify_access(access_level = "closedAccess",
urls = "https://www.ncbi.nlm.nih.gov/gap/...")$controlled_access
#> [1] TRUE
# Identifier hygiene (layered / non-persistent PIDs)
identifier_hygiene("RRID:MGI:5577054")$issues
# Canonical FAIR principle definitions (GO FAIR Foundation / FAIR-nanopubs)
fair_principles("R")
These results are attached to every assessment (a$reuse, a$access,
a$identifier_hygiene) and shown in the app.
Batch assessment and rtransparent
assess_fair_batch() scores a vector of identifiers and returns one tidy row
per identifier. assess_data_code() bridges
rtransparent: it takes the data and
code identifiers rtransparent extracts from articles (its open_data_links and
open_code_links columns; DOIs, repository URLs, and identifiers.org
prefix:accession codes such as geo:GSE…) and scores each, using the FsF data
metrics for data and the FRSM software metrics for code.
rt <- rtransparent::rt_data_code_pmc(xml) # is_open_data, open_data_links, ...
scores <- assess_data_code(rt, id_col = "pmid") # one row per (article, data/code link)
split_identifiers() parses the " ; "-joined link strings on their own.
Long runs can go faster and survive interruptions:
res <- assess_fair_batch(ids, workers = 4, keep = TRUE) # parallel; keep full results
res2 <- assess_fair_batch(ids, previous = res) # resume: skip rows already scored
attr(res, "assessments") # the fair_assessment objects
The batch output has resolved and http_status columns, so dead links are
counted rather than scored. Set GITHUB_PAT for software assessments: without
a token GitHub allows 60 API requests an hour (about 15 repositories).
options(rfair.cache_dir = "path") caches HTTP responses between runs, and
assess_fair(max_time = 60) caps the time spent on one identifier.
HTTP API scaffold
rfair also ships a Plumber scaffold and OpenAPI contract for teams that want
to expose the same assessment engine over HTTP:
api <- system.file("plumber", "rfair-api.R", package = "rfair")
pr <- plumber::pr(api)
pr$run(port = 8000)
The machine-readable API contract is installed at:
system.file("openapi", "rfair-openapi.yaml", package = "rfair")
The API and the Shiny app fetch whatever URL a visitor sends, so both set
options(rfair.block_private_hosts = TRUE): URLs that are not http(s), and
hosts that resolve to loopback, private, link-local, or cloud metadata
addresses, are refused. Each request connects to the address that was checked,
so DNS rebinding cannot swap it, and every redirect is checked, with credentials
dropped when a redirect changes scheme, host, or port. Headless rendering is off
in the API unless the server sets RFAIR_API_ALLOW_HEADLESS=true, and it runs
outside this guard. Before exposing either publicly, also put it behind a proxy
with request limits.
How it works
id_parse() -> resolve -> harvest -> merge -> 17 metric evaluators
-> F/A/I/R score -> fair_assessment
harvest: landing page (schema.org JSON-LD, microdata, RDFa; Dublin Core,
OpenGraph, Highwire meta tags) · signposting typed links · DataCite JSON ·
CSL JSON (Crossref and other DOI agencies) · XML (DataCite, MODS, EML,
ISO 19139) · RDF · code forges (GitHub, GitLab, Codeberg) · repository file
APIs (Zenodo, figshare, Dataverse, Dryad) · data link probes
rfair is checked against the reference F-UJI service with
tests/conformance/run.R, monthly in CI: on 2026-09-22 it matched F-UJI 4.0.0
on 97.6% of 85 metric comparisons (see tests/conformance/README.md). The FRSM
software scores are heuristic and not yet validated against expert ratings;
frsm_agreement() supports that study.
Reference data (SPDX licenses, file formats, access rights, protocols, metadata
standards, FAIR principles, reusabledata.org curations) is baked in from the
F-UJI sources by the scripts in data-raw/.
Citation and metadata
The repository includes CITATION.cff and codemeta.json so software harvesters
can find rfair's authorship, license, version, dependencies, repository URL, and
upstream F-UJI provenance. Each release is archived on Zenodo with a citable DOI;
the concept DOI 10.5281/zenodo.20775127
always resolves to the latest version. Cite the version you used, or run
citation("rfair").
Acknowledgements
rfair began as a fork of the
rfuji F-UJI API client (Steffen Neumann)
and reimplements the assessment engine natively in R. It is a native R port of
F-UJI
(© PANGAEA, MIT), itself based on the FAIRsFAIR metrics. The software metrics
operationalize the FAIR Principles for Research Software (FAIR4RS): Chue Hong,
N. P., Katz, D. S., Barker, M., Lamprecht, A.-L., Martinez, C., Psomopoulos, F. E.,
Harrow, J., Castro, L. J., Gruenpeter, M., Martinez, P. A., Honeyman, T., et al.
(2022). FAIR Principles for Research Software (FAIR4RS Principles) (1.0).
Research Data Alliance. https://doi.org/10.15497/RDA00068 (CC BY 4.0). License
reusability uses the (Re)usable Data Project rubric;
data FAIR principle definitions come from the
FAIR-nanopubs
vocabulary referenced by the GO FAIR Foundation.
Use of AI
Parts of rfair were developed with the assistance of AI coding tools
(Anthropic's Claude, via Claude Code), including code drafting, documentation,
and test scaffolding. All AI-assisted output was reviewed, tested, and verified
by the author, who is solely responsible for the package and its correctness.
License
GPL-3. See https://www.gnu.org/licenses/gpl-3.0 for the full license text.
rfair bundles reference data from external projects under their own (MIT,
CC0-1.0, CC-BY-4.0) licenses; see LICENSE.note for the provenance and terms.