Python API Reference

This is the reference for classes (CamelCase names) and functions (underscore_case names) of MNE-Python, grouped thematically by analysis stage. Functions and classes that are not below a module heading are found in the mne namespace.

MNE-Python also provides multiple command-line scripts that can be called directly from a terminal, see Command line tools using Python.


MNE software for MEG and EEG data analysis.

Most-used classes

io.Raw(fname[, allow_maxshield, preload, …])

Raw data in FIF format.

Epochs(raw, events[, event_id, tmin, tmax, …])

Epochs extracted from a Raw instance.

Evoked(fname[, condition, proj, kind, …])

Evoked data.

Info(*args, **kwargs)

Measurement information.

Reading raw data

IO module for reading raw data.

anonymize_info(info[, daysback, keep_his, …])

Anonymize measurement information in place.

read_raw(fname, *[, preload, verbose])

Read raw file.

read_raw_artemis123(input_fname[, preload, …])

Read Artemis123 data as raw object.

read_raw_bti(pdf_fname[, config_fname, …])

Raw object from 4D Neuroimaging MagnesWH3600 data.

read_raw_cnt(input_fname[, eog, misc, ecg, …])

Read CNT data as raw object.

read_raw_ctf(directory[, system_clock, …])

Raw object from CTF directory.

read_raw_curry(fname[, preload, verbose])

Read raw data from Curry files.

read_raw_edf(input_fname[, eog, misc, …])

Reader function for EDF or EDF+ files.

read_raw_bdf(input_fname[, eog, misc, …])

Reader function for BDF files.

read_raw_gdf(input_fname[, eog, misc, …])

Reader function for GDF files.

read_raw_kit(input_fname[, mrk, elp, hsp, …])

Reader function for Ricoh/KIT conversion to FIF.

read_raw_nicolet(input_fname, ch_type[, …])

Read Nicolet data as raw object.

read_raw_nirx(fname[, preload, verbose])

Reader for a NIRX fNIRS recording.

read_raw_snirf(fname[, preload, verbose])

Reader for a continuous wave SNIRF data.

read_raw_eeglab(input_fname[, eog, preload, …])

Read an EEGLAB .set file.

read_raw_brainvision(vhdr_fname[, eog, …])

Reader for Brain Vision EEG file.

read_raw_egi(input_fname[, eog, misc, …])

Read EGI simple binary as raw object.

read_raw_fif(fname[, allow_maxshield, …])

Reader function for Raw FIF data.

read_raw_eximia(fname[, preload, verbose])

Reader for an eXimia EEG file.

read_raw_fieldtrip(fname, info[, data_name])

Load continuous (raw) data from a FieldTrip preprocessing structure.

read_raw_persyst(fname[, preload, verbose])

Reader for a Persyst (.lay/.dat) recording.

read_raw_nihon(fname[, preload, verbose])

Reader for an Nihon Kohden EEG file.

Base class:

BaseRaw(info[, preload, first_samps, …])

Base class for Raw data.

KIT module for reading raw data.


Marker Point Extraction in MEG space directly from sqd.

File I/O

channel_type(info, idx)

Get channel type.

channel_indices_by_type(info[, picks])

Get indices of channels by type.

get_head_surf(subject[, source, …])

Load the subject head surface.

get_meg_helmet_surf(info[, trans, verbose])

Load the MEG helmet associated with the MEG sensors.

get_volume_labels_from_aseg(mgz_fname[, …])

Return a list of names and colors of segmented volumes.

get_volume_labels_from_src(src, subject, …)

Return a list of Label of segmented volumes included in the src space.


Parse a config file (like .ave and .cov files).

read_labels_from_annot(subject[, parc, …])

Read labels from a FreeSurfer annotation file.

read_bem_solution(fname[, verbose])

Read the BEM solution from a file.

read_bem_surfaces(fname[, patch_stats, …])

Read the BEM surfaces from a FIF file.

read_cov(fname[, verbose])

Read a noise covariance from a FIF file.

read_dipole(fname[, verbose])

Read .dip file from Neuromag/xfit or MNE.

read_epochs(fname[, proj, preload, verbose])

Read epochs from a fif file.

read_epochs_kit(input_fname, events[, …])

Reader function for Ricoh/KIT epochs files.

read_epochs_eeglab(input_fname[, events, …])

Reader function for EEGLAB epochs files.

read_epochs_fieldtrip(fname, info[, …])

Load epoched data from a FieldTrip preprocessing structure.

read_events(filename[, include, exclude, …])

Read events from fif or text file.

read_evokeds(fname[, condition, baseline, …])

Read evoked dataset(s).

read_evoked_fieldtrip(fname, info[, …])

Load evoked data from a FieldTrip timelocked structure.


Read a Freesurfer-formatted LUT.

read_forward_solution(fname[, include, …])

Read a forward solution a.k.a.

read_label(filename[, subject, color])

Read FreeSurfer Label file.

read_morph_map(subject_from, subject_to[, …])

Read morph map.

read_proj(fname[, verbose])

Read projections from a FIF file.


Read rejection parameters from .cov or .ave config file.

read_selection(name[, fname, info, verbose])

Read channel selection from file.

read_source_estimate(fname[, subject])

Read a source estimate object.

read_source_spaces(fname[, patch_stats, verbose])

Read the source spaces from a FIF file.

read_surface(fname[, read_metadata, …])

Load a Freesurfer surface mesh in triangular format.

read_trans(fname[, return_all, verbose])

Read a -trans.fif file.

read_tri(fname_in[, swap, verbose])

Read triangle definitions from an ascii file.

write_labels_to_annot(labels[, subject, …])

Create a FreeSurfer annotation from a list of labels.

write_bem_solution(fname, bem[, overwrite, …])

Write a BEM model with solution.

write_bem_surfaces(fname, surfs[, …])

Write BEM surfaces to a fiff file.

write_cov(fname, cov)

Write a noise covariance matrix.

write_events(filename, event_list)

Write events to file.

write_evokeds(fname, evoked)

Write an evoked dataset to a file.

write_forward_solution(fname, fwd[, …])

Write forward solution to a file.

write_label(filename, label[, verbose])

Write a FreeSurfer label.

write_proj(fname, projs)

Write projections to a FIF file.

write_source_spaces(fname, src[, overwrite, …])

Write source spaces to a file.

write_surface(fname, coords, faces[, …])

Write a triangular Freesurfer surface mesh.

write_trans(fname, trans)

Write a -trans.fif file.


Try to determine the type of the FIF file.

io.read_info(fname[, verbose])

Read measurement info from a file.

io.show_fiff(fname[, indent, read_limit, …])

Show FIFF information.

Base class:

BaseEpochs(info, data, events[, event_id, …])

Abstract base class for Epochs-type classes.

Creating data objects from arrays

EvokedArray(data, info[, tmin, comment, …])

Evoked object from numpy array.

EpochsArray(data, info[, events, tmin, …])

Epochs object from numpy array.

io.RawArray(data, info[, first_samp, copy, …])

Raw object from numpy array.

create_info(ch_names, sfreq[, ch_types, verbose])

Create a basic Info instance suitable for use with create_raw.



Functions for fetching remote datasets.

See Datasets Overview for more information.

brainstorm.bst_auditory.data_path([path, …])

Get path to local copy of brainstorm (bst_auditory) dataset.

brainstorm.bst_resting.data_path([path, …])

Get path to local copy of brainstorm (bst_resting) dataset.

brainstorm.bst_raw.data_path([path, …])

Get path to local copy of brainstorm (bst_raw) dataset.

eegbci.load_data(subject, runs[, path, …])

Get paths to local copies of EEGBCI dataset files.


Standardize channel positions and names.

fetch_aparc_sub_parcellation([subjects_dir, …])

Fetch the modified subdivided aparc parcellation.

fetch_fsaverage([subjects_dir, verbose])

Fetch and update fsaverage.

fetch_hcp_mmp_parcellation([subjects_dir, …])

Fetch the HCP-MMP parcellation.

fnirs_motor.data_path([path, force_update, …])

Get path to local copy of fnirs_motor dataset.

hf_sef.data_path([dataset, path, …])

Get path to local copy of the high frequency SEF dataset.

kiloword.data_path([path, force_update, …])

Get path to local copy of the kiloword dataset.

limo.load_data(subject[, path, …])

Fetch subjects epochs data for the LIMO data set.

misc.data_path([path, force_update, …])

Get path to local copy of misc dataset.

mtrf.data_path([path, force_update, …])

Get path to local copy of mtrf dataset.

multimodal.data_path([path, force_update, …])

Get path to local copy of multimodal dataset.

opm.data_path([path, force_update, …])

Get path to local copy of opm dataset.

sleep_physionet.age.fetch_data(subjects[, …])

Get paths to local copies of PhysioNet Polysomnography dataset files.


Get paths to local copies of PhysioNet Polysomnography dataset files.

sample.data_path([path, force_update, …])

Get path to local copy of sample dataset.

somato.data_path([path, force_update, …])

Get path to local copy of somato dataset.

spm_face.data_path([path, force_update, …])

Get path to local copy of spm dataset.

visual_92_categories.data_path([path, …])

Get path to local copy of visual_92_categories dataset.

phantom_4dbti.data_path([path, …])

Get path to local copy of phantom_4dbti dataset.

refmeg_noise.data_path([path, force_update, …])

Get path to local copy of refmeg_noise dataset.



Visualization routines.

Brain(subject_id, hemi, surf[, title, …])

Class for visualizing a brain.

ClickableImage(imdata, **kwargs)

Display an image so you can click on it and store x/y positions.

add_background_image(fig, im[, set_ratios])

Add a background image to a plot.


Convert center points to edges.

compare_fiff(fname_1, fname_2[, fname_out, …])

Compare the contents of two fiff files using diff and show_fiff.

circular_layout(node_names, node_order[, …])

Create layout arranging nodes on a circle.

iter_topography(info[, layout, on_pick, …])

Create iterator over channel positions.

mne_analyze_colormap([limits, format])

Return a colormap similar to that used by mne_analyze.

plot_bem([subject, subjects_dir, …])

Plot BEM contours on anatomical slices.

plot_brain_colorbar(ax, clim[, colormap, …])

Plot a colorbar that corresponds to a brain activation map.

plot_connectivity_circle(con, node_names[, …])

Visualize connectivity as a circular graph.

plot_cov(cov, info[, exclude, colorbar, …])

Plot Covariance data.

plot_csd(csd[, info, mode, colorbar, cmap, …])

Plot CSD matrices.

plot_dipole_amplitudes(dipoles[, colors, show])

Plot the amplitude traces of a set of dipoles.

plot_dipole_locations(dipoles[, trans, …])

Plot dipole locations.

plot_drop_log(drop_log[, threshold, …])

Show the channel stats based on a drop_log from Epochs.

plot_epochs(epochs[, picks, scalings, …])

Visualize epochs.

plot_epochs_psd_topomap(epochs[, bands, …])

Plot the topomap of the power spectral density across epochs.

plot_events(events[, sfreq, first_samp, …])

Plot events to get a visual display of the paradigm.

plot_evoked(evoked[, picks, exclude, unit, …])

Plot evoked data using butterfly plots.

plot_evoked_image(evoked[, picks, exclude, …])

Plot evoked data as images.

plot_evoked_topo(evoked[, layout, …])

Plot 2D topography of evoked responses.

plot_evoked_topomap(evoked[, times, …])

Plot topographic maps of specific time points of evoked data.

plot_evoked_joint(evoked[, times, title, …])

Plot evoked data as butterfly plot and add topomaps for time points.

plot_evoked_field(evoked, surf_maps[, time, …])

Plot MEG/EEG fields on head surface and helmet in 3D.

plot_evoked_white(evoked, noise_cov[, show, …])

Plot whitened evoked response.

plot_filter(h, sfreq[, freq, gain, title, …])

Plot properties of a filter.

plot_head_positions(pos[, mode, cmap, …])

Plot head positions.

plot_ideal_filter(freq, gain[, axes, title, …])

Plot an ideal filter response.

plot_compare_evokeds(evokeds[, picks, …])

Plot evoked time courses for one or more conditions and/or channels.

plot_ica_sources(ica, inst[, picks, start, …])

Plot estimated latent sources given the unmixing matrix.

plot_ica_components(ica[, picks, ch_type, …])

Project mixing matrix on interpolated sensor topography.

plot_ica_properties(ica, inst[, picks, …])

Display component properties.

plot_ica_scores(ica, scores[, exclude, …])

Plot scores related to detected components.

plot_ica_overlay(ica, inst[, exclude, …])

Overlay of raw and cleaned signals given the unmixing matrix.

plot_epochs_image(epochs[, picks, sigma, …])

Plot Event Related Potential / Fields image.

plot_layout(layout[, picks, show])

Plot the sensor positions.

plot_montage(montage[, scale_factor, …])

Plot a montage.

plot_projs_topomap(projs, info[, cmap, …])

Plot topographic maps of SSP projections.

plot_raw(raw[, events, duration, start, …])

Plot raw data.

plot_raw_psd(raw[, fmin, fmax, tmin, tmax, …])

Plot the power spectral density across channels.

plot_sensors(info[, kind, ch_type, title, …])

Plot sensors positions.

plot_sensors_connectivity(info, con[, picks])

Visualize the sensor connectivity in 3D.

plot_snr_estimate(evoked, inv[, show, axes, …])

Plot a data SNR estimate.

plot_source_estimates(stc[, subject, …])

Plot SourceEstimate.

link_brains(brains[, time, camera, …])

Plot multiple SourceEstimate objects with PyVista.

plot_volume_source_estimates(stc, src[, …])

Plot Nutmeg style volumetric source estimates using nilearn.

plot_vector_source_estimates(stc[, subject, …])

Plot VectorSourceEstimate with PySurfer.

plot_sparse_source_estimates(src, stcs[, …])

Plot source estimates obtained with sparse solver.

plot_tfr_topomap(tfr[, tmin, tmax, fmin, …])

Plot topographic maps of specific time-frequency intervals of TFR data.

plot_topo_image_epochs(epochs[, layout, …])

Plot Event Related Potential / Fields image on topographies.

plot_topomap(data, pos[, vmin, vmax, cmap, …])

Plot a topographic map as image.

plot_alignment([info, trans, subject, …])

Plot head, sensor, and source space alignment in 3D.

snapshot_brain_montage(fig, montage[, …])

Take a snapshot of a Mayavi Scene and project channels onto 2d coords.

plot_arrowmap(data, info_from[, info_to, …])

Plot arrow map.

set_3d_backend(backend_name[, verbose])

Set the backend for MNE.


Return the backend currently used.


Create a viz context.


Set 3D rendering options.

set_3d_view(figure[, azimuth, elevation, …])

Configure the view of the given scene.

set_3d_title(figure, title[, size])

Configure the title of the given scene.

create_3d_figure(size[, bgcolor, …])

Return an empty figure based on the current 3d backend.


Return the proper Brain class based on the current 3d backend.




Projection vector.

compute_proj_epochs(epochs[, n_grad, n_mag, …])

Compute SSP (spatial space projection) vectors on Epochs.

compute_proj_evoked(evoked[, n_grad, n_mag, …])

Compute SSP (spatial space projection) vectors on Evoked.

compute_proj_raw(raw[, start, stop, …])

Compute SSP (spatial space projection) vectors on Raw.

read_proj(fname[, verbose])

Read projections from a FIF file.

write_proj(fname, projs)

Write projections to a FIF file.


Module dedicated to manipulation of channels.

Can be used for setting of sensor locations used for processing and plotting.

Layout(box, pos, names, ids, kind)

Sensor layouts.

DigMontage([dev_head_t, dig, ch_names])

Montage for digitized electrode and headshape position data.


Compute the native-to-head transformation for a montage.

fix_mag_coil_types(info[, use_cal])

Fix magnetometer coil types.

read_polhemus_fastscan(fname[, unit])

Read Polhemus FastSCAN digitizer data from a .txt file.


Get a list of all builtin montages.

make_dig_montage([ch_pos, nasion, lpa, rpa, …])

Make montage from arrays.

read_dig_polhemus_isotrak(fname[, ch_names, …])

Read Polhemus digitizer data from a file.


Read electrode locations from CapTrak Brain Products system.


Read electrode positions from a *.dat file.


Read electrode locations from EGI system.


Read digitized points from a .fif file.

read_dig_hpts(fname[, unit])

Read historical .hpts mne-c files.

make_standard_montage(kind[, head_size])

Read a generic (built-in) montage.

read_custom_montage(fname[, head_size, …])

Read a montage from a file.


Compute device to head transform from a DigMontage.

read_layout(kind[, path, scale])

Read layout from a file.

find_layout(info[, ch_type, exclude])

Choose a layout based on the channels in the info ‘chs’ field.

make_eeg_layout(info[, radius, width, …])

Create .lout file from EEG electrode digitization.

make_grid_layout(info[, picks, n_col])

Generate .lout file for custom data, i.e., ICA sources.

find_ch_adjacency(info, ch_type)

Find the adjacency matrix for the given channels.

read_ch_adjacency(fname[, picks])

Parse FieldTrip neighbors .mat file.

equalize_channels(instances[, copy, verbose])

Equalize channel picks and ordering across multiple MNE-Python objects.

rename_channels(info, mapping)

Rename channels.

generate_2d_layout(xy[, w, h, pad, …])

Generate a custom 2D layout from xy points.

make_1020_channel_selections(info[, midline])

Return dict mapping from ROI names to lists of picks for 10/20 setups.

combine_channels(inst, groups[, method, …])

Combine channels based on specified channel grouping.


Preprocessing with artifact detection, SSP, and ICA.

ICA([n_components, max_pca_components, …])

M/EEG signal decomposition using Independent Component Analysis (ICA).

Xdawn([n_components, signal_cov, …])

Implementation of the Xdawn Algorithm.

annotate_flat(raw[, bad_percent, …])

Annotate flat segments of raw data (or add to a bad channel list).

annotate_movement(raw, pos[, …])

Detect segments with movement.

annotate_muscle_zscore(raw[, threshold, …])

Create annotations for segments that likely contain muscle artifacts.

compute_average_dev_head_t(raw, pos)

Get new device to head transform based on good segments.

compute_current_source_density(inst[, …])

Get the current source density (CSD) transformation.

compute_fine_calibration(raw[, n_imbalance, …])

Compute fine calibration from empty-room data.

compute_proj_ecg(raw[, raw_event, tmin, …])

Compute SSP/PCA projections for ECG artifacts.

compute_proj_eog(raw[, raw_event, tmin, …])

Compute SSP/PCA projections for EOG artifacts.

create_ecg_epochs(raw[, ch_name, event_id, …])

Conveniently generate epochs around ECG artifact events.

create_eog_epochs(raw[, ch_name, event_id, …])

Conveniently generate epochs around EOG artifact events.

find_bad_channels_maxwell(raw[, limit, …])

Find bad channels using Maxwell filtering.

find_ecg_events(raw[, event_id, ch_name, …])

Find ECG peaks.

find_eog_events(raw[, event_id, l_freq, …])

Locate EOG artifacts.

fix_stim_artifact(inst[, events, event_id, …])

Eliminate stimulation’s artifacts from instance.

ica_find_ecg_events(raw, ecg_source[, …])

Find ECG peaks from one selected ICA source.

ica_find_eog_events(raw[, eog_source, …])

Locate EOG artifacts from one selected ICA source.

infomax(data[, weights, l_rate, block, …])

Run (extended) Infomax ICA decomposition on raw data.

maxwell_filter(raw[, origin, int_order, …])

Maxwell filter data using multipole moments.

oversampled_temporal_projection(raw[, …])

Denoise MEG channels using leave-one-out temporal projection.

peak_finder(x0[, thresh, extrema, verbose])

Noise-tolerant fast peak-finding algorithm.

read_ica(fname[, verbose])

Restore ICA solution from fif file.

regress_artifact(inst[, picks, …])

Regress artifacts using reference channels.

corrmap(icas, template[, threshold, label, …])

Find similar Independent Components across subjects by map similarity.


Load ICA information saved in an EEGLAB .set file.


Read fine calibration information from a .dat file.

write_fine_calibration(fname, calibration)

Write fine calibration information to a .dat file.


NIRS specific preprocessing functions.


Convert NIRS raw data to optical density.

beer_lambert_law(raw[, ppf])

Convert NIRS optical density data to haemoglobin concentration.

source_detector_distances(info[, picks])

Determine the distance between NIRS source and detectors.

short_channels(info[, threshold])

Determine which NIRS channels are short.

scalp_coupling_index(raw[, l_freq, h_freq, …])

Calculate scalp coupling index.


Apply temporal derivative distribution repair to data.

EEG referencing:

add_reference_channels(inst, ref_channels[, …])

Add reference channels to data that consists of all zeros.

set_bipolar_reference(inst, anode, cathode)

Re-reference selected channels using a bipolar referencing scheme.

set_eeg_reference(inst[, ref_channels, …])

Specify which reference to use for EEG data.


IIR and FIR filtering and resampling functions.

construct_iir_filter(iir_params[, f_pass, …])

Use IIR parameters to get filtering coefficients.

create_filter(data, sfreq, l_freq, h_freq[, …])

Create a FIR or IIR filter.

estimate_ringing_samples(system[, max_try])

Estimate filter ringing.

filter_data(data, sfreq, l_freq, h_freq[, …])

Filter a subset of channels.

notch_filter(x, Fs, freqs[, filter_length, …])

Notch filter for the signal x.

resample(x[, up, down, npad, axis, window, …])

Resample an array.


Functions for fitting head positions with (c)HPI coils.

compute_chpi_amplitudes(raw[, t_step_min, …])

Compute time-varying cHPI amplitudes.

compute_chpi_locs(info, chpi_amplitudes[, …])

Compute locations of each cHPI coils over time.

compute_head_pos(info, chpi_locs[, …])

Compute time-varying head positions.

extract_chpi_locs_ctf(raw[, verbose])

Extract cHPI locations from CTF data.

filter_chpi(raw[, include_line, t_step, …])

Remove cHPI and line noise from data.


Convert Maxfilter-formatted head position quaternions.


Read MaxFilter-formatted head position parameters.

write_head_pos(fname, pos)

Write MaxFilter-formatted head position parameters.


Helpers for various transformations.

Transform(fro, to[, trans])

A transform.


Convert a set of quaternions to rotations.


Convert a set of rotations to quaternions.

read_ras_mni_t(subject[, subjects_dir])

Read a subject’s RAS to MNI transform.


Annotations(onset, duration, description[, …])

Annotation object for annotating segments of raw data.


Parser for Elekta data acquisition settings.

concatenate_events(events, first_samps, …)

Concatenate event lists to be compatible with concatenate_raws.

find_events(raw[, stim_channel, output, …])

Find events from raw file.

find_stim_steps(raw[, pad_start, pad_stop, …])

Find all steps in data from a stim channel.

make_fixed_length_events(raw[, id, start, …])

Make a set of events separated by a fixed duration.

make_fixed_length_epochs(raw[, duration, …])

Divide continuous raw data into equal-sized consecutive epochs.

merge_events(events, ids, new_id[, …])

Merge a set of events.


Parse a config file (like .ave and .cov files).

pick_events(events[, include, exclude, step])

Select some events.

read_annotations(fname[, sfreq, uint16_codec])

Read annotations from a file.

read_events(filename[, include, exclude, …])

Read events from fif or text file.

write_events(filename, event_list)

Write events to file.

concatenate_epochs(epochs_list[, add_offset])

Concatenate a list of epochs into one epochs object.

events_from_annotations(raw[, event_id, …])

Get events and event_id from an Annotations object.

annotations_from_events(events, sfreq[, …])

Convert an event array to an Annotations object.


IO with fif files containing events.

define_target_events(events, reference_id, …)

Define new events by co-occurrence of existing events.

shift_time_events(events, ids, tshift, sfreq)

Shift an event.


Tools for working with epoched data.

add_channels_epochs(epochs_list[, verbose])

Concatenate channels, info and data from two Epochs objects.

average_movements(epochs[, head_pos, …])

Average data using Maxwell filtering, transforming using head positions.

combine_event_ids(epochs, old_event_ids, …)

Collapse event_ids from an epochs instance into a new event_id.

equalize_epoch_counts(epochs_list[, method])

Equalize the number of trials in multiple Epoch instances.

Sensor Space Data

combine_evoked(all_evoked, weights)

Merge evoked data by weighted addition or subtraction.

concatenate_raws(raws[, preload, …])

Concatenate raw instances as if they were continuous.

equalize_channels(instances[, copy, verbose])

Equalize channel picks and ordering across multiple MNE-Python objects.

grand_average(all_inst[, interpolate_bads, …])

Make grand average of a list of Evoked or AverageTFR data.

pick_channels(ch_names, include[, exclude, …])

Pick channels by names.

pick_channels_cov(orig[, include, exclude, …])

Pick channels from covariance matrix.

pick_channels_forward(orig[, include, …])

Pick channels from forward operator.

pick_channels_regexp(ch_names, regexp)

Pick channels using regular expression.

pick_types(info[, meg, eeg, stim, eog, ecg, …])

Pick channels by type and names.

pick_types_forward(orig[, meg, eeg, …])

Pick by channel type and names from a forward operator.

pick_info(info[, sel, copy, verbose])

Restrict an info structure to a selection of channels.

read_epochs(fname[, proj, preload, verbose])

Read epochs from a fif file.


Read rejection parameters from .cov or .ave config file.

read_selection(name[, fname, info, verbose])

Read channel selection from file.

rename_channels(info, mapping)

Rename channels.


Utility functions to baseline-correct data.

rescale(data, times, baseline[, mode, copy, …])

Rescale (baseline correct) data.

Covariance computation

Covariance(data, names, bads, projs, nfree)

Noise covariance matrix.

compute_covariance(epochs[, …])

Estimate noise covariance matrix from epochs.

compute_raw_covariance(raw[, tmin, tmax, …])

Estimate noise covariance matrix from a continuous segment of raw data.

cov.compute_whitener(noise_cov[, info, …])

Compute whitening matrix.

cov.prepare_noise_cov(noise_cov, info[, …])

Prepare noise covariance matrix.

cov.regularize(cov, info[, mag, grad, eeg, …])

Regularize noise covariance matrix.

compute_rank(inst[, rank, scalings, info, …])

Compute the rank of data or noise covariance.

make_ad_hoc_cov(info[, std, verbose])

Create an ad hoc noise covariance.

read_cov(fname[, verbose])

Read a noise covariance from a FIF file.

write_cov(fname, cov)

Write a noise covariance matrix.

MRI Processing

Step by step instructions for using gui.coregistration():

coreg.get_mni_fiducials(subject[, …])

Estimate fiducials for a subject.

gui.coregistration([tabbed, split, width, …])

Coregister an MRI with a subject’s head shape.

gui.fiducials([subject, fid_file, subjects_dir])

Set the fiducials for an MRI subject.

create_default_subject([fs_home, update, …])

Create an average brain subject for subjects without structural MRI.

scale_mri(subject_from, subject_to, scale[, …])

Create a scaled copy of an MRI subject.

scale_bem(subject_to, bem_name[, …])

Scale a bem file.

scale_labels(subject_to[, pattern, …])

Scale labels to match a brain that was previously created by scaling.

scale_source_space(subject_to, src_name[, …])

Scale a source space for an mri created with scale_mri().

Forward Modeling


Forward class to represent info from forward solution.

SourceSpaces(source_spaces[, info])

Represent a list of source space.

add_source_space_distances(src[, …])

Compute inter-source distances along the cortical surface.

apply_forward(fwd, stc, info[, start, stop, …])

Project source space currents to sensor space using a forward operator.

apply_forward_raw(fwd, stc, info[, start, …])

Project source space currents to sensor space using a forward operator.

average_forward_solutions(fwds[, weights, …])

Average forward solutions.

convert_forward_solution(fwd[, surf_ori, …])

Convert forward solution between different source orientations.

decimate_surface(points, triangles, n_triangles)

Decimate surface data.

dig_mri_distances(info, trans, subject[, …])

Compute distances between head shape points and the scalp surface.

forward.compute_depth_prior(forward, info[, …])

Compute depth prior for depth weighting.

forward.compute_orient_prior(forward[, …])

Compute orientation prior.

forward.restrict_forward_to_label(fwd, labels)

Restrict forward operator to labels.

forward.restrict_forward_to_stc(fwd, stc[, …])

Restrict forward operator to active sources in a source estimate.

make_bem_model(subject[, ico, conductivity, …])

Create a BEM model for a subject.

make_bem_solution(surfs[, verbose])

Create a BEM solution using the linear collocation approach.

make_forward_dipole(dipole, bem, info[, …])

Convert dipole object to source estimate and calculate forward operator.

make_forward_solution(info, trans, src, bem)

Calculate a forward solution for a subject.

make_field_map(evoked[, trans, subject, …])

Compute surface maps used for field display in 3D.

make_sphere_model([r0, head_radius, info, …])

Create a spherical model for forward solution calculation.

morph_source_spaces(src_from, subject_to[, …])

Morph an existing source space to a different subject.

read_bem_surfaces(fname[, patch_stats, …])

Read the BEM surfaces from a FIF file.

read_forward_solution(fname[, include, …])

Read a forward solution a.k.a.

read_trans(fname[, return_all, verbose])

Read a -trans.fif file.

read_source_spaces(fname[, patch_stats, verbose])

Read the source spaces from a FIF file.

read_surface(fname[, read_metadata, …])

Load a Freesurfer surface mesh in triangular format.

sensitivity_map(fwd[, projs, ch_type, mode, …])

Compute sensitivity map.

setup_source_space(subject[, spacing, …])

Set up bilateral hemisphere surface-based source space with subsampling.

setup_volume_source_space([subject, pos, …])

Set up a volume source space with grid spacing or discrete source space.

surface.complete_surface_info(surf[, …])

Complete surface information.

surface.read_curvature(filepath[, binary])

Load in curvature values from the ?h.curv file.


Use a custom coil definition file.

write_bem_surfaces(fname, surfs[, …])

Write BEM surfaces to a fiff file.

write_trans(fname, trans)

Write a -trans.fif file.



BEM or sphere model.

fit_sphere_to_headshape(info[, dig_kinds, …])

Fit a sphere to the headshape points to determine head center.

get_fitting_dig(info[, dig_kinds, …])

Get digitization points suitable for sphere fitting.

make_watershed_bem(subject[, subjects_dir, …])

Create BEM surfaces using the FreeSurfer watershed algorithm.

make_flash_bem(subject[, overwrite, show, …])

Create 3-Layer BEM model from prepared flash MRI images.

convert_flash_mris(subject[, flash30, …])

Convert DICOM files for use with make_flash_bem.

Inverse Solutions


Linear inverse solvers based on L2 Minimum Norm Estimates (MNE).


InverseOperator class to represent info from inverse operator.

apply_inverse(evoked, inverse_operator[, …])

Apply inverse operator to evoked data.

apply_inverse_cov(cov, info, inverse_operator)

Apply inverse operator to covariance data.

apply_inverse_epochs(epochs, …[, method, …])

Apply inverse operator to Epochs.

apply_inverse_raw(raw, inverse_operator, lambda2)

Apply inverse operator to Raw data.

compute_source_psd(raw, inverse_operator[, …])

Compute source power spectral density (PSD).

compute_source_psd_epochs(epochs, …[, …])

Compute source power spectral density (PSD) from Epochs.


Compute the rank of a linear inverse operator (MNE, dSPM, etc.).

estimate_snr(evoked, inv[, verbose])

Estimate the SNR as a function of time for evoked data.

make_inverse_operator(info, forward, noise_cov)

Assemble inverse operator.

prepare_inverse_operator(orig, nave, lambda2)

Prepare an inverse operator for actually computing the inverse.

read_inverse_operator(fname[, verbose])

Read the inverse operator decomposition from a FIF file.

source_band_induced_power(epochs, …[, …])

Compute source space induced power in given frequency bands.

source_induced_power(epochs, …[, label, …])

Compute induced power and phase lock.

write_inverse_operator(fname, inv[, verbose])

Write an inverse operator to a FIF file.

make_inverse_resolution_matrix(forward, …)

Compute resolution matrix for linear inverse operator.

resolution_metrics(resmat, src[, function, …])

Compute spatial resolution metrics for linear solvers.

get_cross_talk(resmat, src, idx[, norm])

Get cross-talk (CTFs) function for vertices.

get_point_spread(resmat, src, idx[, norm])

Get point-spread (PSFs) functions for vertices.


Non-Linear sparse inverse solvers.

mixed_norm(evoked, forward, noise_cov, alpha)

Mixed-norm estimate (MxNE) and iterative reweighted MxNE (irMxNE).

tf_mixed_norm(evoked, forward, noise_cov[, …])

Time-Frequency Mixed-norm estimate (TF-MxNE).

gamma_map(evoked, forward, noise_cov, alpha)

Hierarchical Bayes (Gamma-MAP) sparse source localization method.

make_stc_from_dipoles(dipoles, src[, verbose])

Convert a list of spatio-temporal dipoles into a SourceEstimate.


Beamformers for source localization.


A computed beamformer.


Read a beamformer filter.

make_lcmv(info, forward, data_cov[, reg, …])

Compute LCMV spatial filter.

apply_lcmv(evoked, filters[, max_ori_out, …])

Apply Linearly Constrained Minimum Variance (LCMV) beamformer weights.

apply_lcmv_epochs(epochs, filters[, …])

Apply Linearly Constrained Minimum Variance (LCMV) beamformer weights.

apply_lcmv_raw(raw, filters[, start, stop, …])

Apply Linearly Constrained Minimum Variance (LCMV) beamformer weights.

apply_lcmv_cov(data_cov, filters[, verbose])

Apply Linearly Constrained Minimum Variance (LCMV) beamformer weights.

make_dics(info, forward, csd[, reg, …])

Compute a Dynamic Imaging of Coherent Sources (DICS) spatial filter.

apply_dics(evoked, filters[, verbose])

Apply Dynamic Imaging of Coherent Sources (DICS) beamformer weights.

apply_dics_csd(csd, filters[, verbose])

Apply Dynamic Imaging of Coherent Sources (DICS) beamformer weights.

apply_dics_epochs(epochs, filters[, …])

Apply Dynamic Imaging of Coherent Sources (DICS) beamformer weights.

rap_music(evoked, forward, noise_cov[, …])

RAP-MUSIC source localization method.

tf_dics(epochs, forward, noise_csds, tmin, …)

5D time-frequency beamforming based on DICS.

tf_lcmv(epochs, forward, noise_covs, tmin, …)


DEPRECATED: tf_lcmv is deprecated and will be removed in 0.22, use LCMV with a covariances computed on band-passed data or DICS instead

make_lcmv_resolution_matrix(filters, …)

Compute resolution matrix for LCMV beamformer.

Dipole(times, pos, amplitude, ori, gof[, …])

Dipole class for sequential dipole fits.

DipoleFixed(info, data, times, nave, aspect_kind)

Dipole class for fixed-position dipole fits.

fit_dipole(evoked, cov, bem[, trans, …])

Fit a dipole.


Single-dipole functions and classes.


Get standard phantom dipole locations and orientations.

Source Space Data

BiHemiLabel(lh, rh[, name, color])

A freesurfer/MNE label with vertices in both hemispheres.

Label([vertices, pos, values, hemi, …])

A FreeSurfer/MNE label with vertices restricted to one hemisphere.

MixedSourceEstimate(data[, vertices, tmin, …])

Container for mixed surface and volume source estimates.

MixedVectorSourceEstimate(data[, vertices, …])

Container for volume source estimates.

SourceEstimate(data, vertices, tmin, tstep)

Container for surface source estimates.

VectorSourceEstimate(data[, vertices, tmin, …])

Container for vector surface source estimates.

VolSourceEstimate(data, vertices, tmin, tstep)

Container for volume source estimates.

VolVectorSourceEstimate(data[, vertices, …])

Container for volume source estimates.

SourceMorph(subject_from, subject_to, kind, …)

Morph source space data from one subject to another.

compute_source_morph(src[, subject_from, …])

Create a SourceMorph from one subject to another.

head_to_mni(pos, subject, mri_head_t[, …])

Convert pos from head coordinate system to MNI ones.

head_to_mri(pos, subject, mri_head_t[, …])

Convert pos from head coordinate system to MRI ones.

extract_label_time_course(stcs, labels, src)

Extract label time course for lists of labels and source estimates.

grade_to_tris(grade[, verbose])

Get tris defined for a certain grade.

grade_to_vertices(subject, grade[, …])

Convert a grade to source space vertices for a given subject.

label.select_sources(subject, label[, …])

Select sources from a label.

grow_labels(subject, seeds, extents, hemis)

Generate circular labels in source space with region growing.

label_sign_flip(label, src)

Compute sign for label averaging.

labels_to_stc(labels, values[, tmin, tstep, …])

Convert a set of labels and values to a STC.

morph_labels(labels, subject_to[, …])

Morph a set of labels.

random_parcellation(subject, n_parcel, hemi)

Generate random cortex parcellation by growing labels.

read_labels_from_annot(subject[, parc, …])

Read labels from a FreeSurfer annotation file.

read_dipole(fname[, verbose])

Read .dip file from Neuromag/xfit or MNE.

read_label(filename[, subject, color])

Read FreeSurfer Label file.

read_source_estimate(fname[, subject])

Read a source estimate object.


Load the morph for source estimates from a file.

split_label(label[, parts, subject, …])

Split a Label into two or more parts.

stc_to_label(stc[, src, smooth, connected, …])

Compute a label from the non-zero sources in an stc object.

transform_surface_to(surf, dest, trans[, copy])

Transform surface to the desired coordinate system.

vertex_to_mni(vertices, hemis, subject[, …])

Convert the array of vertices for a hemisphere to MNI coordinates.

write_labels_to_annot(labels[, subject, …])

Create a FreeSurfer annotation from a list of labels.

write_label(filename, label[, verbose])

Write a FreeSurfer label.



Time frequency analysis tools.

AverageTFR(info, data, times, freqs, nave[, …])

Container for Time-Frequency data.

EpochsTFR(info, data, times, freqs[, …])

Container for Time-Frequency data on epochs.

CrossSpectralDensity(data, ch_names, …[, …])

Cross-spectral density.

Functions that operate on mne-python objects:

csd_fourier(epochs[, fmin, fmax, tmin, …])

Estimate cross-spectral density from an array using short-time fourier.

csd_multitaper(epochs[, fmin, fmax, tmin, …])

Estimate cross-spectral density from epochs using a multitaper method.

csd_morlet(epochs, frequencies[, tmin, …])

Estimate cross-spectral density from epochs using Morlet wavelets.

pick_channels_csd(csd[, include, exclude, …])

Pick channels from cross-spectral density matrix.


Read a CrossSpectralDensity object from an HDF5 file.

fit_iir_model_raw(raw[, order, picks, tmin, …])

Fit an AR model to raw data and creates the corresponding IIR filter.

psd_welch(inst[, fmin, fmax, tmin, tmax, …])

Compute the power spectral density (PSD) using Welch’s method.

psd_multitaper(inst[, fmin, fmax, tmin, …])

Compute the power spectral density (PSD) using multitapers.

tfr_morlet(inst, freqs, n_cycles[, use_fft, …])

Compute Time-Frequency Representation (TFR) using Morlet wavelets.

tfr_multitaper(inst, freqs, n_cycles[, …])

Compute Time-Frequency Representation (TFR) using DPSS tapers.

tfr_stockwell(inst[, fmin, fmax, n_fft, …])

Compute Time-Frequency Representation (TFR) using Stockwell Transform.

read_tfrs(fname[, condition])

Read TFR datasets from hdf5 file.

write_tfrs(fname, tfr[, overwrite])

Write a TFR dataset to hdf5.

Functions that operate on np.ndarray objects:

csd_array_fourier(X, sfreq[, t0, fmin, …])

Estimate cross-spectral density from an array using short-time fourier.

csd_array_multitaper(X, sfreq[, t0, fmin, …])

Estimate cross-spectral density from an array using a multitaper method.

csd_array_morlet(X, sfreq, frequencies[, …])

Estimate cross-spectral density from an array using Morlet wavelets.

dpss_windows(N, half_nbw, Kmax[, low_bias, …])

Compute Discrete Prolate Spheroidal Sequences.

morlet(sfreq, freqs[, n_cycles, sigma, …])

Compute Morlet wavelets for the given frequency range.

stft(x, wsize[, tstep, verbose])

STFT Short-Term Fourier Transform using a sine window.

istft(X[, tstep, Tx])

ISTFT Inverse Short-Term Fourier Transform using a sine window.

stftfreq(wsize[, sfreq])

Compute frequencies of stft transformation.

psd_array_multitaper(x, sfreq[, fmin, fmax, …])

Compute power spectral density (PSD) using a multi-taper method.

psd_array_welch(x, sfreq[, fmin, fmax, …])

Compute power spectral density (PSD) using Welch’s method.

tfr_array_morlet(epoch_data, sfreq, freqs[, …])

Compute Time-Frequency Representation (TFR) using Morlet wavelets.

tfr_array_multitaper(epoch_data, sfreq, freqs)

Compute Time-Frequency Representation (TFR) using DPSS tapers.

tfr_array_stockwell(data, sfreq[, fmin, …])

Compute power and intertrial coherence using Stockwell (S) transform.


A module which implements the time-frequency estimation.

Morlet code inspired by Matlab code from Sheraz Khan & Brainstorm & SPM

cwt(X, Ws[, use_fft, mode, decim])

Compute time freq decomposition with continuous wavelet transform.

morlet(sfreq, freqs[, n_cycles, sigma, …])

Compute Morlet wavelets for the given frequency range.

Connectivity Estimation


Spectral and effective connectivity measures.

degree(connectivity[, threshold_prop])

Compute the undirected degree of a connectivity matrix.

envelope_correlation(data[, combine, …])

Compute the envelope correlation.

phase_slope_index(data[, indices, sfreq, …])

Compute the Phase Slope Index (PSI) connectivity measure.

seed_target_indices(seeds, targets)

Generate indices parameter for seed based connectivity analysis.

spectral_connectivity(data[, method, …])

Compute frequency- and time-frequency-domain connectivity measures.



Functions for statistical analysis.

Parametric statistics (see scipy.stats and statsmodels for more options):

ttest_1samp_no_p(X[, sigma, method])

Perform one-sample t-test.

ttest_ind_no_p(a, b[, equal_var, sigma])

Independent samples t-test without p calculation.


Perform a 1-way ANOVA.

f_mway_rm(data, factor_levels[, effects, …])

Compute M-way repeated measures ANOVA for fully balanced designs.

f_threshold_mway_rm(n_subjects, factor_levels)

Compute F-value thresholds for a two-way ANOVA.

linear_regression(inst, design_matrix[, names])

Fit Ordinary Least Squares regression (OLS).

linear_regression_raw(raw, events[, …])

Estimate regression-based evoked potentials/fields by linear modeling.

Mass-univariate multiple comparison correction:

bonferroni_correction(pval[, alpha])

P-value correction with Bonferroni method.

fdr_correction(pvals[, alpha, method])

P-value correction with False Discovery Rate (FDR).

Non-parametric (clustering) resampling methods:


Create a sparse binary adjacency/neighbors matrix.

permutation_cluster_test(X[, threshold, …])

Cluster-level statistical permutation test.

permutation_cluster_1samp_test(X[, …])

Non-parametric cluster-level paired t-test.

permutation_t_test(X[, n_permutations, …])

One sample/paired sample permutation test based on a t-statistic.

spatio_temporal_cluster_test(X[, threshold, …])

Non-parametric cluster-level test for spatio-temporal data.

spatio_temporal_cluster_1samp_test(X[, …])

Non-parametric cluster-level paired t-test for spatio-temporal data.

summarize_clusters_stc(clu[, p_thresh, …])

Assemble summary SourceEstimate from spatiotemporal cluster results.

bootstrap_confidence_interval(arr[, ci, …])

Get confidence intervals from non-parametric bootstrap.

Compute adjacency matrices for cluster-level statistics:

channels.find_ch_adjacency(info, ch_type)

Find the adjacency matrix for the given channels.

channels.read_ch_adjacency(fname[, picks])

Parse FieldTrip neighbors .mat file.

spatial_dist_adjacency(src, dist[, verbose])

Compute adjacency from distances in a source space.

spatial_src_adjacency(src[, dist, verbose])

Compute adjacency for a source space activation.

spatial_tris_adjacency(tris[, …])

Compute adjacency from triangles.

spatial_inter_hemi_adjacency(src, dist[, …])

Get vertices on each hemisphere that are close to the other hemisphere.

spatio_temporal_src_adjacency(src, n_times)

Compute adjacency for a source space activation over time.

spatio_temporal_tris_adjacency(tris, n_times)

Compute adjacency from triangles and time instants.

spatio_temporal_dist_adjacency(src, n_times, …)

Compute adjacency from distances in a source space and time instants.



Data simulation code.

add_chpi(raw[, head_pos, interp, n_jobs, …])

Add cHPI activations to raw data.

add_ecg(raw[, head_pos, interp, n_jobs, …])

Add ECG noise to raw data.

add_eog(raw[, head_pos, interp, n_jobs, …])

Add blink noise to raw data.

add_noise(inst, cov[, iir_filter, …])

Create noise as a multivariate Gaussian.

simulate_evoked(fwd, stc, info, cov[, nave, …])

Generate noisy evoked data.

simulate_raw(info[, stc, trans, src, bem, …])

Simulate raw data.

simulate_stc(src, labels, stc_data, tmin, tstep)

Simulate sources time courses from waveforms and labels.

simulate_sparse_stc(src, n_dipoles, times[, …])

Generate sparse (n_dipoles) sources time courses from data_fun.

select_source_in_label(src, label[, …])

Select source positions using a label.

SourceSimulator(src[, tstep, duration])

Class to generate simulated Source Estimates.



Decoding and encoding, including machine learning and receptive fields.

CSP([n_components, reg, log, cov_est, …])

M/EEG signal decomposition using the Common Spatial Patterns (CSP).


Transformer to compute event-matched spatial filters.

FilterEstimator(info, l_freq, h_freq[, …])

Estimator to filter RtEpochs.


Compute and store patterns from linear models.

PSDEstimator([sfreq, fmin, fmax, bandwidth, …])

Compute power spectral density (PSD) using a multi-taper method.

Scaler([info, scalings, with_mean, with_std])

Standardize channel data.

TemporalFilter([l_freq, h_freq, sfreq, …])

Estimator to filter data array along the last dimension.

TimeFrequency(freqs[, sfreq, method, …])

Time frequency transformer.

UnsupervisedSpatialFilter(estimator[, average])

Use unsupervised spatial filtering across time and samples.


Transform n-dimensional array into 2D array of n_samples by n_features.

ReceptiveField(tmin, tmax, sfreq[, …])

Fit a receptive field model.

TimeDelayingRidge(tmin, tmax, sfreq[, …])

Ridge regression of data with time delays.

SlidingEstimator(base_estimator[, scoring, …])

Search Light.

GeneralizingEstimator(base_estimator[, …])

Generalization Light.

SPoC([n_components, reg, log, …])

Implementation of the SPoC spatial filtering.

Functions that assist with decoding and model fitting:

compute_ems(epochs[, conditions, picks, …])

Compute event-matched spatial filter on epochs.

cross_val_multiscore(estimator, X[, y, …])

Evaluate a score by cross-validation.

get_coef(estimator[, attr, inverse_transform])

Retrieve the coefficients of an estimator ending with a Linear Model.


Realtime functionality has moved to the standalone module mne_realtime.



Report([info_fname, subjects_dir, subject, …])

Object for rendering HTML.

open_report(fname, **params)

Read a saved report or, if it doesn’t exist yet, create a new one.

Logging and Configuration


Get path to standard mne-python config file.

get_config([key, default, raise_error, …])

Read MNE-Python preferences from environment or config file.

open_docs([kind, version])

Launch a new web browser tab with the MNE documentation.

set_log_level([verbose, return_old_level, …])

Set the logging level.

set_log_file([fname, output_format, overwrite])

Set the log to print to a file.

set_config(key, value[, home_dir, set_env])

Set a MNE-Python preference key in the config file and environment.


Set the directory to be used for temporary file storage.

sys_info([fid, show_paths])

Print the system information for debugging.


Verbose decorator to allow functions to override log-level.



Mark a function or class as deprecated (decorator).

warn(message[, category, module])

Emit a warning with trace outside the mne namespace.



Get the amount of free memory for CUDA operations.

init_cuda([ignore_config, verbose])

Initialize CUDA functionality.

set_cuda_device(device_id[, verbose])

Set the CUDA device temporarily for the current session.