Bids

Brain Imaging Data Structure (BIDS)

Overview

The Brain Imaging Data Structure (BIDS) is a community standard for organizing and describing neuroscience and biomedical research datasets. It defines a consistent file naming convention, directory hierarchy, and metadata schema so that datasets are immediately understandable by humans and software tools alike. BIDS is governed by the BIDS Specification (currently v1.11.x) and is maintained by the community via the BIDS-Standard GitHub organization.

While BIDS originated for MRI, it has grown well beyond neuroimaging. The specification now covers 11 modalities spanning imaging, electrophysiology, and behavioral data:

• Imaging: MRI (structural, functional, diffusion, fieldmaps, perfusion/ASL), PET, microscopy
• Electrophysiology: EEG, MEG, iEEG (intracranial EEG), EMG
• Other: NIRS (near-infrared spectroscopy), motion capture, behavioral data (without imaging), MR spectroscopy

Active BEPs are extending BIDS further — notably BEP032 (microelectrode electrophysiology) will add support for extracellular recordings including Neuropixels probes, bringing BIDS to a prevalent methodology in animal neuroscience research (see also the neuropixels-analysis skill).

Adoption is required or strongly encouraged by major data repositories (OpenNeuro, DANDI), leading journals (NeuroImage, Human Brain Mapping, Scientific Data), and funding agencies (NIH, ERC).

The Python ecosystem for BIDS centers on PyBIDS (pybids) for querying and indexing BIDS datasets, and the bids-validator (Deno-based, available as PyPI package bids-validator-deno or via Deno directly) for compliance checking. Conversion from DICOM is typically done with HeuDiConv, dcm2bids, or BIDScoin.

When to Use This Skill

Apply this skill when:

• Organizing raw neuroscience data (imaging, electrophysiology, behavioral) into BIDS-compliant directory structures
• Querying an existing BIDS dataset to find specific files by subject, session, task, run, or modality
• Validating a dataset against the BIDS specification before sharing or submission
• Converting DICOM data from scanners into BIDS format
• Writing or editing JSON sidecar metadata files
• Creating BIDS-compliant derivatives (preprocessed data, analysis outputs)
• Setting up a dataset_description.json for a new dataset
• Working with BIDS entities (subject, session, task, acquisition, run, etc.)
• Configuring .bidsignore to exclude files from validation
• Preparing data for upload to OpenNeuro, DANDI, or other BIDS-aware repositories

Installation

# Core BIDS querying library
uv pip install pybids

# BIDS validator (Deno-based, installed via PyPI wrapper)
uv pip install bids-validator-deno
# Alternative: install directly via Deno
# deno install -g -A npm:bids-validator

# DICOM-to-BIDS converters (install as needed)
uv pip install heudiconv       # HeuDiConv - heuristic-based DICOM conversion
uv pip install dcm2bids        # dcm2bids - config-file-based conversion
# BIDScoin: uv pip install bidscoin

# Useful companions
uv pip install nibabel          # NIfTI/other neuroimaging file I/O
uv pip install pydicom          # DICOM file reading (used by converters)

Core Workflows

1. BIDS Directory Structure

A minimal BIDS dataset follows this layout:

my_dataset/
  dataset_description.json      # Required: name, BIDSVersion, etc.
  participants.tsv              # Recommended: subject-level phenotypic data
  participants.json             # Recommended: column descriptions
  README                        # Recommended: dataset documentation
  CHANGES                       # Recommended: version history
  .bidsignore                   # Optional: patterns to exclude from validation
  sub-01/
    anat/
      sub-01_T1w.nii.gz
      sub-01_T1w.json           # Sidecar metadata
    func/
      sub-01_task-rest_bold.nii.gz
      sub-01_task-rest_bold.json
      sub-01_task-rest_events.tsv     # Event timing for task fMRI
      sub-01_task-rest_events.json
    dwi/
      sub-01_dwi.nii.gz
      sub-01_dwi.json
      sub-01_dwi.bvec
      sub-01_dwi.bval
    fmap/
      sub-01_phasediff.nii.gz
      sub-01_phasediff.json
      sub-01_magnitude1.nii.gz
    perf/
      sub-01_asl.nii.gz
      sub-01_asl.json
  sub-01/
    ses-pre/
      anat/
        sub-01_ses-pre_T1w.nii.gz
      func/
        sub-01_ses-pre_task-nback_bold.nii.gz
    ses-post/
      ...

Key points:

• Every NIfTI file should have a corresponding .json sidecar
• File names encode entities: sub-<label>[_ses-<label>][_task-<label>][_acq-<label>][_run-<index>]_<suffix>.<extension>
• Entity order in filenames is fixed by the specification
• Only dataset_description.json is strictly required at the root level

2. Creating dataset_description.json

import json

dataset_description = {
    "Name": "My Neuroimaging Study",
    "BIDSVersion": "1.10.0",
    "DatasetType": "raw",
    "License": "CC0",
    "Authors": ["First Author", "Second Author"],
    "Acknowledgements": "Funded by NIH R01-MH123456",
    "HowToAcknowledge": "Please cite: Author et al. (2025) Journal Name.",
    "Funding": ["NIH R01-MH123456", "NSF BCS-7654321"],
    "ReferencesAndLinks": ["https://doi.org/10.xxxx/xxxxx"],
    "DatasetDOI": "10.18112/openneuro.ds000001.v1.0.0",
    "GeneratedBy": [
        {
            "Name": "HeuDiConv",
            "Version": "1.3.1",
            "CodeURL": "https://github.com/nipy/heudiconv"
        }
    ]
}

with open("dataset_description.json", "w") as f:
    json.dump(dataset_description, f, indent=4)

For derivatives, set "DatasetType": "derivative" and add "GeneratedBy" listing the pipeline:

deriv_description = {
    "Name": "fMRIPrep - fMRI PREProcessing",
    "BIDSVersion": "1.10.0",
    "DatasetType": "derivative",
    "GeneratedBy": [
        {
            "Name": "fMRIPrep",
            "Version": "24.1.0",
            "CodeURL": "https://github.com/nipreps/fmriprep"
        }
    ]
}

3. Querying BIDS Datasets with PyBIDS

from bids import BIDSLayout

# Index a BIDS dataset (validates structure on load)
layout = BIDSLayout("/path/to/bids_dataset")

# Basic queries
subjects = layout.get_subjects()          # ['01', '02', '03', ...]
sessions = layout.get_sessions()          # ['pre', 'post'] or []
tasks = layout.get_tasks()                # ['rest', 'nback']
runs = layout.get_runs()                  # [1, 2] or []

# Find specific files
bold_files = layout.get(
    suffix="bold",
    extension=".nii.gz",
    return_type="filename"
)

# Filter by subject, task, session
nback_sub01 = layout.get(
    subject="01",
    task="nback",
    suffix="bold",
    extension=".nii.gz",
    return_type="filename"
)

# Get metadata from JSON sidecars (automatic inheritance)
metadata = layout.get_metadata("/path/to/sub-01/func/sub-01_task-rest_bold.nii.gz")
tr = metadata["RepetitionTime"]

# Get all entities for a file
entities = layout.get_entities()

# Build a path from entities using BIDSLayout
bids_file = layout.get(subject="01", suffix="T1w", extension=".nii.gz")[0]
print(bids_file.path)
print(bids_file.get_entities())

Key points:

• BIDSLayout indexes the entire dataset on initialization; for large datasets use database_path to cache the index
• Metadata inheritance: a JSON sidecar at a higher level (e.g., root or subject) is inherited by all files below unless overridden
• Use return_type="filename" for paths, return_type="object" (default) for BIDSFile objects

4. Validating BIDS Datasets

Using bids-validator via PyPI (recommended)

The bids-validator-deno PyPI package bundles the Deno-based validator as a standalone CLI:

# Install
uv pip install bids-validator-deno

# Validate a dataset
bids-validator /path/to/bids_dataset

# Ignore specific warnings/errors
bids-validator /path/to/bids_dataset --ignoreNiftiHeaders --ignoreSubjectConsistency

Using bids-validator via Deno directly

If Deno is already available, you can install or run the validator without PyPI:

# Install globally via Deno
deno install -g -A npm:bids-validator

# Or run without installing
deno run -A npm:bids-validator /path/to/bids_dataset

Legacy Node.js validator

The older Node.js-based validator (npm install -g bids-validator) is deprecated in favor of the Deno-based version. The Deno version is the reference implementation for BIDS Specification v1.9+.

Using .bidsignore

Create .bidsignore at the dataset root to exclude files from validation (gitignore syntax):

# Exclude sourcedata and extra files
sourcedata/
extra_data/
*.log
*_sbref.nii.gz
**/.DS_Store

5. BIDS Entities and File Naming

The authoritative, machine-readable source of truth for entities, their ordering, allowed suffixes, and all filename rules is the BIDS Schema — a structured YAML/JSON representation of the specification. A JSON export is shipped with this skill at references/bids_schema.json. The schema is defined in the bids-specification `src/schema/` directory and published at https://bids-specification.readthedocs.io/en/stable/schema.json. BEP-specific schema previews are available at https://github.com/bids-standard/bids-schema/tree/main/BEPs.

Run scripts/update_schema.py to refresh the schema and BEPs list from upstream (no dependencies beyond stdlib).

The tables below are a convenient summary; when in doubt, consult the schema.

BIDS filenames are built from ordered key-value entity pairs:

Entity ordering in filenames is fixed by the spec (defined in rules.entities in bids_schema.json). See references/bids_specification.md for the complete numbered ordering table. A common subset: sub-<label>[_ses-<label>][_task-<label>][_acq-<label>][_ce-<label>][_rec-<label>][_dir-<label>][_run-<index>][_echo-<index>][_part-<label>][_space-<label>][_desc-<label>]_<suffix>.<extension>

Common suffixes by datatype:

6. DICOM to BIDS Conversion

HeuDiConv

HeuDiConv is the most flexible DICOM-to-BIDS converter. It supports three usage modes — from fully automatic to fully custom — and handles duplicates, provenance tracking, and sourcedata archiving out of the box.

Mode 1: ReproIn (turnkey, recommended for new studies)

If scanner protocol names follow the ReproIn naming convention, conversion is fully automatic — no heuristic file to write:

# Turnkey conversion: HeuDiConv maps ReproIn protocol names to BIDS automatically
heudiconv --files dicom/001 -o /path/to/bids -f reproin --bids --minmeta

ReproIn protocol names encode BIDS entities directly:

• anat-T1w → sub-XX/anat/sub-XX_T1w.nii.gz
• func-bold_task-rest → sub-XX/func/sub-XX_task-rest_bold.nii.gz
• dwi_dir-AP → sub-XX/dwi/sub-XX_dir-AP_dwi.nii.gz
• fmap_dir-PA → sub-XX/fmap/sub-XX_dir-PA_epi.nii.gz

Session can be set once on the localizer (e.g., anat-scout_ses-pre) and ReproIn propagates it to all sequences in that Program. Subject ID is extracted from DICOM metadata. Duplicate runs are numbered automatically.

Mode 2: Custom heuristic mapping into ReproIn (for existing data)

If you already have data with non-ReproIn protocol names, you can write a thin heuristic that maps your names into ReproIn conventions, gaining all ReproIn benefits (automatic entity handling, duplicate management, etc.). See https://github.com/repronim/reproin/issues/18 for a HOWTO.

Mode 3: Custom heuristic (full flexibility)

For complex mappings, write a Python heuristic file:

# Step 1: Reconnaissance — discover DICOM series
heudiconv --files dicom/219/itbs/*/*.dcm -o Nifti/ -f convertall -s 219 -c none

# This creates .heudiconv/219/info/dicominfo.tsv — inspect it to understand
# what was acquired and map series to BIDS names.

# Step 2: Write a heuristic file (see references/conversion_tools.md)

# Step 3: Convert
heudiconv --files dicom/219/itbs/*/*.dcm -s 219 -ss itbs \
  -f Nifti/code/heuristic.py -c dcm2niix --bids --minmeta -o Nifti/

See references/conversion_tools.md for complete heuristic file examples.

Key points:

• HeuDiConv wraps dcm2niix for the actual DICOM-to-NIfTI conversion
• `--minmeta`: always use this flag to prevent excess DICOM metadata from overflowing JSON sidecars (can crash fMRIPrep/MRIQC)
• Duplicate handling: use {item:03d} in templates for auto-numbering when the same protocol is run multiple times; without it, later runs overwrite earlier ones
• `.heudiconv/` directory: created alongside output, stores provenance (heuristic used, dicominfo.tsv, conversion records). Keep it with your data for reproducibility
• `sourcedata/`: HeuDiConv archives original DICOMs as .tgz files under sourcedata/ for reproducibility
• `is_motion_corrected` filter: use in heuristics to exclude scanner-generated MOCO series (e.g., if not s.is_motion_corrected)
• Both --files (explicit paths) and -d (template with {subject}, {session} placeholders) are supported for specifying DICOM input

dcm2bids (Configuration-file-based)

# Step 1: Generate helper output to inspect series
dcm2bids_helper -d /path/to/dicom

# Step 2: Create config file (dcm2bids_config.json)
# Step 3: Convert
dcm2bids -d /path/to/dicom -p 01 -c dcm2bids_config.json -o /path/to/bids_output

See references/conversion_tools.md for detailed configuration examples.

7. Metadata Sidecars

Every BIDS data file should have a JSON sidecar with acquisition parameters. Metadata fields follow the inheritance principle: a sidecar at a higher directory level applies to all matching files below.

Inheritance example:

my_dataset/
  task-rest_bold.json           # Applies to ALL rest BOLD files
  sub-01/
    func/
      sub-01_task-rest_bold.json  # Overrides/extends for sub-01 only

Critical metadata fields by modality:

For func (BOLD):

{
    "RepetitionTime": 2.0,
    "TaskName": "rest",
    "PhaseEncodingDirection": "j-",
    "TotalReadoutTime": 0.05,
    "SliceTiming": [0, 0.5, 1.0, 1.5],
    "EffectiveEchoSpacing": 0.00058,
    "EchoTime": 0.03
}

For anat:

{
    "MagneticFieldStrength": 3,
    "Manufacturer": "Siemens",
    "ManufacturersModelName": "Prisma",
    "RepetitionTime": 2.3,
    "EchoTime": 0.00293,
    "FlipAngle": 8
}

For DWI:

{
    "PhaseEncodingDirection": "j-",
    "TotalReadoutTime": 0.05,
    "EchoTime": 0.089,
    "RepetitionTime": 3.4,
    "MultipartID": "dwi_1"
}

Key points:

• dcm2niix auto-generates most sidecar fields from DICOM headers
• RepetitionTime and TaskName are required for BOLD
• SliceTiming is essential for slice-timing correction in fMRI preprocessing
• PhaseEncodingDirection and TotalReadoutTime (or EffectiveEchoSpacing) are needed for distortion correction
• See references/metadata_fields.md for comprehensive field reference

8. Events Files for Task fMRI

Task-based fMRI requires _events.tsv files:

onset	duration	trial_type	response_time
0.0	0.5	face	0.435
2.5	0.5	house	0.367
5.0	0.5	face	0.512
7.5	0.5	scrambled	0.298

Required columns:

• onset - onset time in seconds relative to the start of the acquisition
• duration - duration in seconds (use n/a for instantaneous events)

Recommended columns:

• trial_type - categorical label for condition
• response_time - RT in seconds
• Custom columns as needed (with descriptions in corresponding .json sidecar)

9. Participants File

participant_id	age	sex	group	handedness
sub-01	25	M	control	right
sub-02	30	F	patient	left
sub-03	28	M	control	right

The participants.json sidecar describes columns:

{
    "age": {
        "Description": "Age of the participant at time of scanning",
        "Units": "years"
    },
    "sex": {
        "Description": "Biological sex",
        "Levels": {
            "M": "male",
            "F": "female"
        }
    },
    "group": {
        "Description": "Experimental group",
        "Levels": {
            "control": "Healthy control",
            "patient": "Patient group"
        }
    },
    "handedness": {
        "Description": "Dominant hand",
        "Levels": {
            "right": "Right-handed",
            "left": "Left-handed",
            "ambidextrous": "Ambidextrous"
        }
    }
}

10. BIDS Derivatives

Processed outputs go under a derivatives/ directory:

my_dataset/
  derivatives/
    fmriprep-24.1.0/
      dataset_description.json      # DatasetType: "derivative"
      sub-01/
        anat/
          sub-01_space-MNI152NLin2009cAsym_desc-preproc_T1w.nii.gz
          sub-01_space-MNI152NLin2009cAsym_desc-brain_mask.nii.gz
        func/
          sub-01_task-rest_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz
          sub-01_task-rest_desc-confounds_timeseries.tsv
    mriqc-24.0.0/
      dataset_description.json
      sub-01/
        anat/
          sub-01_T1w.html
        func/
          sub-01_task-rest_bold.html
      group_T1w.tsv
      group_bold.tsv

Derivative conventions:

• space-<label> - template/reference space (e.g., MNI152NLin2009cAsym, T1w)
• desc-<label> - description of processing (e.g., preproc, brain, smoothed)
• res-<label> - resolution (e.g., 2 for 2mm isotropic)
• Each pipeline gets its own directory under derivatives/
• Must have its own dataset_description.json with GeneratedBy

11. PyBIDS: Advanced Usage

from bids import BIDSLayout
from bids.layout import BIDSLayoutIndexer

# Cache the layout index for faster repeated access
layout = BIDSLayout("/path/to/dataset", database_path="/path/to/cache.db")

# Include derivatives
layout = BIDSLayout(
    "/path/to/dataset",
    derivatives=["/path/to/dataset/derivatives/fmriprep-24.1.0"]
)

# Get derivative files
preproc = layout.get(
    subject="01",
    task="rest",
    desc="preproc",
    suffix="bold",
    space="MNI152NLin2009cAsym",
    extension=".nii.gz",
    return_type="filename"
)

# Get confound regressors
confounds = layout.get(
    subject="01",
    task="rest",
    desc="confounds",
    suffix="timeseries",
    extension=".tsv",
    return_type="filename"
)

# Build BIDS path from entities
from bids import BIDSLayout
layout = BIDSLayout("/path/to/dataset")
path = layout.build_path(
    {
        "subject": "01",
        "session": "pre",
        "task": "rest",
        "suffix": "bold",
        "extension": ".nii.gz",
        "datatype": "func"
    },
    validate=True
)

# Get all files for a subject as a DataFrame
import pandas as pd
files_df = layout.to_df()
sub01_df = files_df[files_df["subject"] == "01"]

12. BIDS-Apps

BIDS-Apps are containerized analysis pipelines that accept BIDS datasets as input:

# General BIDS-App invocation pattern
docker run -v /path/to/bids:/data:ro -v /path/to/output:/out \
    <bids-app-image> /data /out participant --participant_label 01

# Common BIDS-Apps:
# fMRIPrep - fMRI preprocessing
docker run nipreps/fmriprep /data /out participant \
    --participant-label 01 --fs-license-file /license.txt

# MRIQC - MRI quality control
docker run nipreps/mriqc /data /out participant \
    --participant-label 01

# QSIPrep - diffusion MRI preprocessing
docker run pennbbl/qsiprep /data /out participant \
    --participant-label 01

BIDS-App interface convention:

bids-app input_dataset output_dir {participant|group} [options]

• participant level: runs per-subject
• group level: runs across all subjects (aggregation/group stats)

Reference Materials

This skill includes detailed reference documentation:

• bids_schema.json: Machine-readable BIDS schema (from https://bids-specification.readthedocs.io/en/stable/schema.json). This is the authoritative source for entity definitions, ordering rules, filename templates, allowed suffixes per datatype, and metadata field requirements. BEP-specific schemas are at https://github.com/bids-standard/bids-schema/tree/main/BEPs.
• beps.yml: Current list of all BIDS Extension Proposals with titles, leads, status, and links (from bids-website)
• bids_specification.md: Human-readable summary of the entity table, datatype reference, directory structure rules, template spaces, and specification changelog
• metadata_fields.md: Required and recommended JSON sidecar fields for every BIDS modality (anat, func, dwi, fmap, eeg, meg, pet, etc.)
• conversion_tools.md: Detailed workflows for HeuDiConv, dcm2bids, and BIDScoin including heuristic/config examples and troubleshooting

Update schema and BEPs with: python scripts/update_schema.py

Common Issues and Solutions

1. Validator reports "Not a BIDS dataset"

Cause: Missing dataset_description.json at the root. Fix: Create the file with at minimum {"Name": "...", "BIDSVersion": "1.10.0"}.

2. Inconsistent subjects warning

Cause: Not all subjects have the same set of files (some missing sessions, runs, etc.). Fix: This is a warning, not an error. Use --ignoreSubjectConsistency if intentional. Document missing data in participants.tsv or a scans.tsv.

3. Missing SliceTiming

Cause: dcm2niix couldn't extract slice timing from DICOM headers. Fix: Determine slice order from the scan protocol and add manually to the JSON sidecar. Common patterns: ascending, descending, interleaved (odd-first or even-first).

4. Phase encoding direction confusion

Cause: Axis labels (i/j/k vs x/y/z vs LR/AP/SI) are confusing. Fix: In BIDS, use NIfTI image axes: i=first axis, j=second, k=third. - means negative direction. For standard axial acquisitions: j is typically anterior-posterior. Verify with the acquisition protocol.

5. PyBIDS is slow on large datasets

Cause: Full filesystem indexing on every BIDSLayout() call. Fix: Use database_path to cache the index to an SQLite file:

layout = BIDSLayout("/data", database_path="/data/.pybids_cache.db")

6. Derivatives not found by PyBIDS

Cause: Derivatives directory missing its own dataset_description.json. Fix: Every derivatives directory must have dataset_description.json with "DatasetType": "derivative".

7. Events file timing is off

Cause: onset times are relative to the wrong reference (e.g., trigger time vs first volume). Fix: Onsets must be in seconds relative to the first volume of that run's acquisition. Account for dummy scans if they were discarded.

8. TSV files fail validation

Cause: Encoding or delimiter issues (spaces instead of tabs, BOM characters, Windows line endings). Fix: Ensure tab-separated values with UTF-8 encoding and Unix line endings (\n). Use n/a (not NA, NaN, or empty) for missing values.

Best Practices

1. Validate early and often - Run the BIDS validator after every conversion or modification. Fix errors before they compound.

2. Use metadata inheritance - Place shared metadata (e.g., TaskName, scanner parameters) in top-level sidecar files rather than duplicating in every subject's directory.

3. Keep sourcedata - Store the original DICOM (or other raw) data under sourcedata/ so conversions are reproducible. Add sourcedata/ to .bidsignore.

4. Use consistent naming from the start - Define your BIDS naming scheme before data collection. Use the ReproIn naming convention for scan protocols to enable automatic conversion.

5. Document your dataset - Write a thorough README describing the study design, acquisition parameters, known issues, and any deviations from BIDS.

6. Use scans.tsv for run-level metadata - Record per-run acquisition times and quality notes:

   filename	acq_time	quality
   func/sub-01_task-rest_bold.nii.gz	2025-01-15T10:30:00	good

7. Version your dataset - Use CHANGES to document dataset modifications. Consider DataLad for full version control of large datasets.

8. Deface anatomical images - Remove facial features from T1w/T2w images before sharing (e.g., using pydeface, mri_deface, or afni_refacer). Store defaced versions as the primary data or use _defacemask files.

9. Use BIDS URIs for provenance - In derivatives, reference source files using BIDS URIs: bids::sub-01/anat/sub-01_T1w.nii.gz.

10. Prefer community tools - Use established BIDS-Apps (fMRIPrep, MRIQC, QSIPrep) rather than custom pipelines when possible. They handle BIDS I/O correctly and produce BIDS-compliant derivatives.

11. Study bids-examples - The bids-examples repository is the canonical collection of prototypical BIDS datasets covering different modalities and use cases (MRI, fMRI, DWI, EEG, MEG, iEEG, PET, ASL, genetics, derivatives, and more). Use it as a reference when structuring your own dataset, as test data for BIDS tools, or to understand how a specific modality should be organized. Each example passes the BIDS validator.

BIDS Extension Proposals (BEPs)

BEPs are community-driven proposals to extend BIDS to new modalities, derivatives, or metadata. The full list with status, leads, and links is in references/beps.yml (fetched from the bids-website). BEP-specific schema previews are rendered at https://github.com/bids-standard/bids-schema/tree/main/BEPs.

Current BEPs (as of schema update):

Related standards:

• BIDS-Stats Models: JSON specification for defining GLM-based neuroimaging analyses
• BIDS-Derivatives (BEP003): Standard for preprocessed/analysis outputs (partially merged into spec)

Related Tools Ecosystem

Documentation

• BIDS Specification: https://bids-specification.readthedocs.io/
• BIDS Website: https://bids.neuroimaging.io/
• PyBIDS Documentation: https://bids-standard.github.io/pybids/
• BIDS Validator: https://github.com/bids-standard/bids-validator
• BIDS Starter Kit: https://bids-standard.github.io/bids-starter-kit/
• BIDS Examples: https://github.com/bids-standard/bids-examples — canonical reference datasets for every BIDS modality; use as templates and test data
• HeuDiConv Docs: https://heudiconv.readthedocs.io/
• Original BIDS paper: Gorgolewski et al. (2016) Scientific Data, doi:10.1038/sdata.2016.44

BIDS Specification Reference

Note: The canonical, machine-readable source of truth is bids_schema.json (in this directory), exported from the BIDS Schema. The tables below are a human-readable summary. When the two disagree, trust the schema.

Entity Table

Complete list of BIDS entities, their keys, and where they apply. Rows are listed in the required filename ordering — entities must appear in this order in BIDS filenames. This order is defined in the schema at rules.entities (see bids_schema.json).

Datatypes (Top-Level Directories)

File Extensions

Required Files

Dataset-level (always required)

• dataset_description.json

Dataset-level (recommended)

• README or README.md
• CHANGES
• participants.tsv + participants.json
• LICENSE

Run-level (recommended)

• sub-<label>/[ses-<label>/]sub-<label>[_ses-<label>]_scans.tsv - per-run acquisition metadata

Modality-specific required files

• func/bold: corresponding _events.tsv for task data; TaskName in JSON sidecar
• dwi: .bvec and .bval files
• eeg/meg/ieeg: _channels.tsv, _events.tsv
• perf/asl: _aslcontext.tsv

Directory Structure Rules

1. Subject directories are named sub-<label> and sit at dataset root 2. Session directories ses-<label> are optional; if used, must be used for ALL subjects 3. Datatype directories (anat/, func/, etc.) sit inside subject (or session) directories 4. sourcedata/ stores raw unprocessed data (DICOM, etc.) - not validated 5. derivatives/ stores processed outputs - each pipeline in its own subdirectory 6. code/ stores analysis scripts 7. stimuli/ stores stimulus files used during acquisition 8. phenotype/ stores questionnaire/behavioral data not tied to specific imaging

Metadata Inheritance

JSON metadata cascades from higher to lower directories. If the same key appears at multiple levels, the most specific (closest to the data file) wins.

Resolution order (highest priority first): 1. File-level sidecar: sub-01/func/sub-01_task-rest_bold.json 2. Subject-level sidecar: sub-01/sub-01_task-rest_bold.json 3. Dataset-level sidecar: task-rest_bold.json

This avoids duplicating metadata that is constant across subjects (e.g., RepetitionTime, TaskName).

Standard Template Spaces

Common space- values used in derivatives:

Full list managed by TemplateFlow: https://www.templateflow.org/

Specification Changelog (Selected)

Entity Label Rules

• Labels (<label>): alphanumeric only, no special characters, no leading zeros (except run-)
• Indices (<index>): non-negative integers, zero-padded to equal width within a dataset (e.g., run-01, run-02)
• Subject labels: typically numeric (01, 02) but can be alphanumeric (CON01, PAT01)
• Session labels: descriptive (pre, post, baseline, followup) or numeric
• Task labels: brief, descriptive, no spaces (rest, nback, faces, gonogo)

BIDS Conversion Tools Reference

This reference covers detailed workflows for converting DICOM and other raw data formats to BIDS using the three main conversion tools.

HeuDiConv

HeuDiConv is the most flexible DICOM-to-BIDS converter. It supports three usage modes — from fully automatic turnkey conversion to fully custom heuristics — and handles duplicates, provenance tracking, and sourcedata archiving out of the box.

Repository: https://github.com/nipy/heudiconv Docs: https://heudiconv.readthedocs.io/ Tutorials: https://heudiconv.readthedocs.io/en/latest/tutorials.html

Installation

uv pip install heudiconv

# HeuDiConv wraps dcm2niix for the actual conversion
# dcm2niix is usually installed as a dependency, but can also be installed via:
# conda install -c conda-forge dcm2niix
# or: apt-get install dcm2niix

Mode 1: ReproIn (Turnkey Conversion — Recommended for New Studies)

If scanner protocol names follow the ReproIn naming convention, conversion is fully automatic with no heuristic file to write. ReproIn is a setup for automatic generation of sharable, version-controlled BIDS datasets directly from MR scanners.

# Turnkey conversion — just point at DICOMs, HeuDiConv does the rest
heudiconv --files dicom/001 -o data -f reproin --bids --minmeta

ReproIn Protocol Naming Rules

Protocol names encode BIDS entities directly. Format: <seqtype>[-<suffix>][_<entity>-<label>]...

Key features:

• Default suffixes: anat defaults to T1w, func to bold, fmap to epi — so they can be omitted
• Subject ID: extracted automatically from DICOM metadata (Patient ID)
• Session: set once on any sequence (e.g., anat-scout_ses-pre) and ReproIn propagates it to all sequences in that scanner Program/Patient
• Duplicate runs: automatically numbered (run-01, run-02, ...) when the same protocol is run multiple times
• Locator hierarchy: output is nested under Region/Exam from the scanner's Study Description (customizable with --locator)
• sourcedata: original DICOMs are archived as .tgz files under sourcedata/ for reproducibility
• Dashes in names: scanners may strip dashes from protocol names during DICOM export — ReproIn handles this gracefully

ReproIn Overview

See also:

• ReproIn Walkthrough for scanner setup
• ReproNim Webinar slides and recording on HeuDiConv + ReproIn

Mode 2: Custom Heuristic Mapping into ReproIn (For Existing Data)

If you already have collected data with non-ReproIn protocol names (or cannot control scanner naming), you can write a thin heuristic that maps your protocol names into ReproIn conventions. This gives you all ReproIn benefits (automatic entity handling, duplicate management, sourcedata archiving) while accommodating arbitrary scanner naming.

See https://github.com/repronim/reproin/issues/18 for a brief HOWTO on this approach.

The idea is to write a heuristic whose infotodict returns keys that follow ReproIn naming patterns, so the ReproIn machinery handles the rest.

Mode 3: Custom Heuristic (Full Flexibility)

For studies with complex mappings or non-standard requirements, write a full Python heuristic file. This is the most common workflow for retrospective conversion of existing datasets.

Step 1: Reconnaissance — Discover DICOM series

# -f convertall: built-in heuristic that lists all series without converting
# -c none: don't convert, just generate dicominfo.tsv
heudiconv \
    --files dicom/219/itbs/*/*.dcm \
    -s 219 \
    -f convertall \
    -c none \
    -o Nifti/

This creates .heudiconv/219/info/dicominfo.tsv containing one row per DICOM series with columns:

• series_id, sequence_name, protocol_name, series_description
• dim1-dim4 (image dimensions), TR, TE, image_type
• is_derived, is_motion_corrected — important for filtering

Review this TSV (open in a spreadsheet) to understand what was acquired and plan the mapping to BIDS names. Step 1 only needs to be done once per project.

Step 2: Write a heuristic file

"""HeuDiConv heuristic for a typical fMRI study.

Study design:
- T1w MPRAGE anatomical
- Resting-state BOLD
- Task BOLD (n-back working memory)
- DWI with two phase-encoding directions
- Fieldmap (phase-difference)
"""

def create_key(template, outtype=('nii.gz',), annotation_classes=None):
    if template is None or not template:
        raise ValueError('Template must be a valid format string')
    return template, outtype, annotation_classes


def infotodict(seqinfo):
    """Heuristic evaluator for determining which runs belong where.

    Parameters
    ----------
    seqinfo : list of namedtuples
        Each namedtuple has fields: .series_id, .sequence_name,
        .protocol_name, .series_description, .dim1, .dim2, .dim3, .dim4,
        .TR, .TE, .is_derived, .is_motion_corrected, .image_type, etc.

    Returns
    -------
    info : dict
        Keys are tuples from create_key(), values are lists of series_id
    """
    # Define BIDS output templates
    t1w = create_key(
        'sub-{subject}/{session}/anat/sub-{subject}_{session}_T1w'
    )
    rest_bold = create_key(
        'sub-{subject}/{session}/func/sub-{subject}_{session}_task-rest_bold'
    )
    # {item:02d} auto-numbers runs when the same protocol is run multiple times
    nback_bold = create_key(
        'sub-{subject}/{session}/func/sub-{subject}_{session}_task-nback_run-{item:02d}_bold'
    )
    dwi_AP = create_key(
        'sub-{subject}/{session}/dwi/sub-{subject}_{session}_dir-AP_dwi'
    )
    dwi_PA = create_key(
        'sub-{subject}/{session}/dwi/sub-{subject}_{session}_dir-PA_dwi'
    )
    fmap_phasediff = create_key(
        'sub-{subject}/{session}/fmap/sub-{subject}_{session}_phasediff'
    )
    fmap_mag1 = create_key(
        'sub-{subject}/{session}/fmap/sub-{subject}_{session}_magnitude1'
    )
    fmap_mag2 = create_key(
        'sub-{subject}/{session}/fmap/sub-{subject}_{session}_magnitude2'
    )

    info = {
        t1w: [], rest_bold: [], nback_bold: [],
        dwi_AP: [], dwi_PA: [],
        fmap_phasediff: [], fmap_mag1: [], fmap_mag2: [],
    }

    for s in seqinfo:
        protocol = s.protocol_name.lower()
        series_desc = s.series_description.lower() if s.series_description else ''

        # Anatomical — filter by dim3 to exclude localizers
        if ('mprage' in protocol or 't1w' in protocol) and s.dim3 > 100:
            info[t1w].append(s.series_id)

        # Functional — filter by dim4 and exclude MOCO series
        elif 'rest' in protocol and s.dim4 > 10 and not s.is_motion_corrected:
            info[rest_bold].append(s.series_id)
        elif 'nback' in protocol and s.dim4 > 10 and not s.is_motion_corrected:
            info[nback_bold].append(s.series_id)

        # Diffusion
        elif ('dti' in protocol or 'dwi' in protocol) and s.dim4 > 1:
            if 'ap' in protocol or 'ap' in series_desc:
                info[dwi_AP].append(s.series_id)
            elif 'pa' in protocol or 'pa' in series_desc:
                info[dwi_PA].append(s.series_id)

        # Fieldmaps
        elif 'field' in protocol or 'fmap' in protocol:
            if 'ph' in s.image_type_text.lower():
                info[fmap_phasediff].append(s.series_id)
            elif s.series_description and 'e1' in s.series_description.lower():
                info[fmap_mag1].append(s.series_id)
            elif s.series_description and 'e2' in s.series_description.lower():
                info[fmap_mag2].append(s.series_id)

    return info

Step 3: Convert

# Convert with custom heuristic
heudiconv \
    --files dicom/219/itbs/*/*.dcm \
    -s 219 \
    -ss itbs \
    -f Nifti/code/heuristic.py \
    -c dcm2niix \
    --bids \
    --minmeta \
    -o Nifti/

# Or using -d template for batch conversion of multiple subjects
heudiconv \
    -d /path/to/dicoms/{subject}/*/*/*.dcm \
    -s 01 02 03 04 05 \
    -f my_heuristic.py \
    -c dcm2niix \
    --bids \
    --minmeta \
    -o /path/to/bids_output

# Key flags:
# --files : point to specific DICOM files/directories
# -d : DICOM path template ({subject}, {session} are replaced)
# -s : subject label(s)
# -ss : session label
# -f : heuristic file path, or built-in name (reproin, convertall)
# -c : converter (dcm2niix, none)
# --bids / -b : output BIDS structure (creates JSON sidecars, etc.)
# --minmeta : prevent excess DICOM metadata from overflowing JSON sidecars
# -o : output directory
# --overwrite : re-run conversion overwriting existing files

The .heudiconv Directory

Every conversion creates/updates a .heudiconv/ hidden directory alongside the output:

• .heudiconv/<subject>/info/dicominfo.tsv — DICOM series metadata
• .heudiconv/<subject>/info/<heuristic>.py — copy of the heuristic used
• Conversion records for each subject/session

Important: If you re-run conversion for a subject/session that was already processed, HeuDiConv silently reuses cached conversion info from .heudiconv/. If troubleshooting, delete the subject's entry from .heudiconv/ (or the whole directory) and re-run.

Keep .heudiconv/ with your data — together with code/ it provides valuable provenance information.

HeuDiConv Tips

1. Always use `--minmeta` to prevent excess DICOM metadata from overflowing JSON sidecars — fMRIPrep and MRIQC may crash on bloated JSON files 2. Use `{item:02d}` in templates for auto-numbering runs: if multiple series match, they get run-01, run-02, etc. Without this, later runs silently overwrite earlier ones 3. Filter by `dim3`/`dim4` to exclude localizers (small dim3) and single-volume scouts (dim4 == 1) 4. Check `s.is_motion_corrected` to exclude scanner-generated MOCO series (e.g., if not s.is_motion_corrected) 5. Check `s.is_derived` to skip other derived/processed series 6. Store heuristic with dataset under code/ for reproducibility 7. Use `--files` when DICOM organization doesn't follow a clean {subject} template pattern 8. For new studies: prefer ReproIn protocol naming from the start — it eliminates the need for custom heuristics entirely 9. For existing data with arbitrary names: consider the "map into reproin" approach rather than writing a fully custom heuristic — you get duplicate handling, session propagation, and other ReproIn features for free

dcm2bids (Configuration-File-Based)

dcm2bids uses JSON configuration files instead of Python heuristics. Simpler for straightforward datasets.

Repository: https://github.com/UNFmontreal/Dcm2Bids Docs: https://unfmontreal.github.io/Dcm2Bids/

Installation

uv pip install dcm2bids
# Also installs dcm2niix

Workflow

Step 1: Scaffold a BIDS directory

dcm2bids_scaffold -o /path/to/bids_output

Creates the basic BIDS structure with dataset_description.json, README, .bidsignore, etc.

Step 2: Run helper to inspect DICOM metadata

dcm2bids_helper -d /path/to/dicom_dir -o /path/to/bids_output

Creates tmp_dcm2bids/helper/ with converted NIfTI files and JSON sidecars. Review the JSON files to find distinguishing metadata fields.

Step 3: Write configuration file

{
    "descriptions": [
        {
            "id": "id_t1w",
            "datatype": "anat",
            "suffix": "T1w",
            "criteria": {
                "SeriesDescription": "*MPRAGE*",
                "ImageType": ["ORIGINAL", "PRIMARY", "M", "ND", "NORM"]
            }
        },
        {
            "id": "id_bold_rest",
            "datatype": "func",
            "suffix": "bold",
            "custom_entities": "task-rest",
            "criteria": {
                "SeriesDescription": "*REST*BOLD*",
                "ImageType": ["ORIGINAL", "PRIMARY", "M", "ND", "MOSAIC"]
            },
            "sidecar_changes": {
                "TaskName": "rest"
            }
        },
        {
            "id": "id_bold_nback",
            "datatype": "func",
            "suffix": "bold",
            "custom_entities": "task-nback",
            "criteria": {
                "SeriesDescription": "*NBACK*",
                "EchoTime": 0.03
            },
            "sidecar_changes": {
                "TaskName": "nback"
            }
        },
        {
            "id": "id_dwi",
            "datatype": "dwi",
            "suffix": "dwi",
            "custom_entities": "dir-AP",
            "criteria": {
                "SeriesDescription": "*DTI*AP*"
            }
        },
        {
            "id": "id_fmap_phasediff",
            "datatype": "fmap",
            "suffix": "phasediff",
            "criteria": {
                "SeriesDescription": "*field*map*",
                "EchoTime1": 0.00492,
                "EchoTime2": 0.00738
            },
            "sidecar_changes": {
                "IntendedFor": [
                    "bids::sub-{subject}/func/sub-{subject}_task-rest_bold.nii.gz",
                    "bids::sub-{subject}/func/sub-{subject}_task-nback_bold.nii.gz"
                ]
            }
        }
    ]
}

Configuration file fields:

• datatype: BIDS datatype (anat, func, dwi, fmap, etc.)
• suffix: BIDS suffix (T1w, bold, dwi, etc.)
• custom_entities: additional BIDS entities (task-rest, dir-AP, acq-highres, etc.)
• criteria: dictionary of DICOM/JSON metadata fields to match (supports wildcards *)
• sidecar_changes: fields to add/modify in the output JSON sidecar
• id: arbitrary identifier for the description (for logging)

Step 4: Convert

# Single subject
dcm2bids -d /path/to/dicom_dir -p 01 -c dcm2bids_config.json -o /path/to/bids_output

# With session
dcm2bids -d /path/to/dicom_dir -p 01 -s pre -c dcm2bids_config.json -o /path/to/bids_output

# Flags:
# -d : DICOM source directory
# -p : participant label
# -s : session label (optional)
# -c : configuration file
# -o : output BIDS directory
# --auto_extract_entities : auto-detect run numbers from DICOM
# --force_dcm2bids : overwrite existing conversions

dcm2bids Tips

1. Use `dcm2bids_helper` first to see exactly what metadata dcm2niix extracts 2. Criteria matching uses wildcards (*) and is case-sensitive 3. Multiple criteria are ANDed together; use the most specific combination 4. `sidecar_changes` can inject any BIDS metadata (useful for TaskName, IntendedFor) 5. Store config file under code/dcm2bids_config.json for reproducibility

BIDScoin (GUI + YAML Configuration)

BIDScoin provides a graphical interface and YAML-based configuration. Good for users who prefer visual mapping.

Repository: https://github.com/Donders-Institute/bidscoin Docs: https://bidscoin.readthedocs.io/

Installation

uv pip install bidscoin
# Optional: install with all plugin dependencies
uv pip install "bidscoin[all]"

Workflow

# Step 1: Create a bidsmap template by scanning DICOMs
bidsmapper /path/to/raw /path/to/bids

# Step 2: Edit the bidsmap (launches GUI)
bidseditor /path/to/bids

# Step 3: Convert using the finalized bidsmap
bidscoiner /path/to/raw /path/to/bids

BIDScoin Tips

1. GUI-based editing is BIDScoin's strength - the bidseditor shows DICOM metadata alongside BIDS mapping 2. YAML bidsmap can be edited manually if preferred 3. Plugin architecture supports custom conversion backends beyond dcm2niix 4. Good for multi-site studies where protocol names vary - visual mapping makes differences obvious

Comparison

Post-Conversion Checklist

After converting DICOM to BIDS with any tool:

1. Run the BIDS validator: bids-validator /path/to/bids_output 2. Check JSON sidecars for critical fields (RepetitionTime, TaskName, SliceTiming, PhaseEncodingDirection) 3. Verify NIfTI headers match expectations (dimensions, voxel sizes, orientation) 4. Add missing metadata that dcm2niix couldn't extract from DICOM 5. Create `participants.tsv` with demographic data 6. Write events files for task fMRI 7. Write `README` describing the dataset 8. Deface anatomical images if sharing data 9. Run `bids-validator` again after any manual modifications

Common DICOM-to-BIDS Pitfalls

Multiband/SMS sequences

• dcm2niix may split slices incorrectly for multiband data
• Check dim4 (number of volumes) matches expectations
• Verify SliceTiming is correct for the multiband factor

Dual-echo fieldmaps

• Siemens stores both echoes in one series; dcm2niix splits them
• GE/Philips may store them as separate series
• Verify EchoTime1 < EchoTime2 in the phasediff sidecar

Phase encoding direction

• DICOM InPlanePhaseEncodingDirection → BIDS PhaseEncodingDirection
• Mapping depends on acquisition orientation and NIfTI axis conventions
• Always verify by checking the actual distortion pattern in the images

Multi-run numbering

• Ensure runs are numbered sequentially (run-01, run-02)
• HeuDiConv: use {item:02d} placeholder
• dcm2bids: use --auto_extract_entities or manually specify runs

Derived/processed series

• Scanners may export inline-processed data (e.g., motion-corrected, distortion-corrected)
• These should NOT be converted to BIDS raw data
• Filter by ImageType containing DERIVED or is_derived flag in HeuDiConv

BIDS Metadata Fields Reference

This reference lists the required and recommended JSON sidecar fields for each BIDS modality.

Legend:

• R = Required
• REC = Recommended
• OPT = Optional

Common MRI Fields (All MRI Modalities)

Anatomical MRI (anat/)

T1w, T2w, FLAIR, T2star, PDw

Quantitative MRI (T1map, T2map, etc.)

Functional MRI (func/)

BOLD

Multi-echo BOLD

BOLD Timing Details

SliceTiming - Array of times (in seconds) at which each slice was acquired relative to the start of volume acquisition. Length must equal the number of slices.

Example for ascending sequential (3 slices, TR=2s):

{"SliceTiming": [0.0, 0.667, 1.333]}

Example for interleaved (odd-first, 6 slices, TR=2s):

{"SliceTiming": [0.0, 0.667, 1.333, 0.333, 1.0, 1.667]}

PhaseEncodingDirection values:

• i / i- : along first image axis (typically left-right)
• j / j- : along second image axis (typically anterior-posterior)
• k / k- : along third image axis (typically inferior-superior)
• The - suffix indicates the negative direction along that axis

Diffusion-Weighted Imaging (dwi/)

DWI Gradient Files

.bvec file (3 rows x N columns, N = number of volumes):

0 0.707 -0.707 0 0.577
0 0.707 0.707 0 0.577
0 0 0 1 0.577

.bval file (1 row x N columns):

0 1000 1000 1000 2000

• b=0 volumes have zero-vectors in .bvec
• Gradient directions are in the image coordinate system
• Values are space-separated (not tab-separated)
• Number of columns must match number of volumes in the NIfTI

Fieldmaps (fmap/)

Case 1: Phase-difference map (_phasediff)

Case 2: Two phase maps (_phase1, _phase2)

Case 3: Direct fieldmap (_fieldmap)

Case 4: "Pepolar" fieldmaps (_epi)

IntendedFor Syntax

BIDS URI format (recommended, v1.7+):

{
    "IntendedFor": [
        "bids::sub-01/func/sub-01_task-rest_bold.nii.gz",
        "bids::sub-01/dwi/sub-01_dwi.nii.gz"
    ]
}

Relative path format (legacy):

{
    "IntendedFor": [
        "func/sub-01_task-rest_bold.nii.gz",
        "dwi/sub-01_dwi.nii.gz"
    ]
}

B0FieldIdentifier/B0FieldSource (preferred in v1.9+):

// In the fieldmap sidecar
{"B0FieldIdentifier": "pepolar_fmap0"}

// In the BOLD sidecar
{"B0FieldSource": "pepolar_fmap0"}

Perfusion Imaging (perf/)

ASL

aslcontext.tsv

Required file listing the order of volumes (label/control/m0scan):

volume_type
control
label
control
label
m0scan

EEG (eeg/)

channels.tsv (EEG)

electrodes.tsv (EEG)

MEG (meg/)

PET (pet/)

Microscopy (micr/)

NIRS (nirs/)

Motion (motion/)