Do I need an input or IgG control to call CUT&RUN peaks?

Not necessarily, and if you use one you should watch for MACS2 over-penalizing real signal because IgG in CUT&RUN carries almost no reads. Many pipelines call peaks without a control, using a stringent q-value plus blacklist filtering, or use SEACR, which calibrates its threshold from the global background distribution instead of a matched control library. Keep an IgG sample in the batch anyway for QC and blacklist-building purposes.

Why do my strongest CUT&RUN peaks sit in centromeres or repeat regions?

Without a control to flag them, copy-number gains, highly accessible chromatin, and low-mappability repeats produce read pileups a caller can't distinguish from real enrichment. These artifacts recur at the same loci across unrelated experiments, which is exactly why CUT&RUN-specific blacklists, built from negative-control datasets and separate from the ENCODE ChIP-seq blacklist, exist. Intersect your peaks against both before trusting the top of the list.

What FRiP score should I expect from CUT&RUN or CUT&Tag?

The ENCODE ChIP-seq floor of roughly 1% is a reasonable starting reference, but CUT&RUN's much lower background means healthy experiments often clear that easily, sometimes by several fold. A FRiP under 1% on a well-studied target is a red flag for antibody or pulldown failure, not just a caller quirk.

Should I use narrow or broad peak settings for CUT&RUN?

Match the setting to the biology of the mark, not to the assay. Point-source factors and transcription factors are narrow; histone marks that form broad domains, like H3K27me3 or H3K9me3, need broad-peak calling or they fragment into thousands of disconnected small intervals that misrepresent the underlying domain.

MACS2, SEACR, or GoPeaks: which caller should I trust for CUT&RUN?

None of them wins outright; benchmarks comparing MACS2, SEACR, GoPeaks, and LanceOtron on CUT&RUN data show each has different failure modes. Run at least two callers, check where they agree, and validate the disagreements against known positive-control loci before deciding which output to use downstream.

Sanity check · CUT&RUN and CUT&Tag

How to Call Peaks You Can Trust in CUT&RUN and CUT&Tag

MACS2 and an IgG control were built for ChIP-seq's noise floor; point them at CUT&RUN's much cleaner background and you'll either call nothing or call the centromere.

By Ming "Tommy" Tang, Director of Bioinformatics in Big Pharma · Reviewed September 2026 · 5 min read

You ran CUT&RUN because ChIP-seq needed too many cells, and you carried the same MACS2 command over: call peaks against your IgG control, q < 0.05, done. Now you're staring at either a peak file with a dozen regions when the browser track clearly shows enrichment at your gene of interest, or the opposite: tens of thousands of peaks, and the top-scoring ones sit in a centromere you never had to think about with ChIP-seq.

Either failure mode costs you real time. Under-calling gets a working experiment written off as a failed pulldown. Over-calling lets centromeric repeats and copy-number artifacts flow straight into a differential binding analysis, and three weeks later someone asks why your list of transcription factor targets includes a satellite repeat array.

This page gives you the checks to tell which failure mode you're in, when to drop the input control entirely, how CUT&RUN-specific blacklists differ from the ENCODE ones you already know, and what a passing FRiP score and a clean browser look actually look like for this assay. Budget an hour: most of it is rerunning peak calling under a couple of control configurations and comparing outputs, not writing new code.

What it looks like when it's happening

MACS2 called with -c IgG returns very few peaks, or none, even though IGV shows a visible pileup at your target's known binding sites
MACS2 called without any control produces tens of thousands of peaks, and the top 20 by score sit in centromeric or satellite repeat annotations
FRiP is under 1% for a transcription factor with a well-documented, widely-replicated binding profile
Peak count changes by an order of magnitude between two replicates run with identical parameters
A broad histone mark like H3K27me3 called with narrow-peak settings comes back as thousands of small disconnected intervals instead of broad domains
MACS2 fails to build a fragment-size model, or warns it can't detect enrichment, when run without --nomodel
Aggregate QC looks fine but individual loci fall apart once you inspect fragment size, because the library was sequenced single-end

Why it happens

CUT&RUN and CUT&Tag work because the protein A-fusion enzyme is tethered directly to the antibody and only cuts DNA near the true binding site. Background comes almost entirely from a low rate of nonspecific cutting, not from sonication shearing the whole genome the way ChIP-seq does. That gives you a signal-to-noise ratio ChIP-seq callers were never built to see: MACS2's local Poisson background model assumes a noise floor from broadly distributed fragmentation, and when that floor collapses toward zero, the local background estimate becomes unstable region to region.

The instinct to reuse an IgG control from ChIP-seq for this makes things worse. IgG in CUT&RUN captures almost no signal, since there's no antibody-specific tethering happening at all. Feed that into MACS2 as the control and the local lambda estimate at real binding sites can drop so low that even modest enrichment gets swallowed as background, or MACS2 refuses to call anything near threshold. This is why standard practice diverged from ChIP-seq: either drop the control and lean on a stringent q-value plus blacklist filtering, or use a caller like SEACR that calibrates its threshold from the global background distribution rather than a local model tuned against a matched control library.

Drop the control, though, and you lose the one thing that used to flag non-biological enrichment automatically. Copy-number gains, ultra-accessible open chromatin, and low-mappability repeats produce read pileups a caller working off library-wide statistics alone can't distinguish from real signal. Those artifacts cluster at the same handful of genomic locations across unrelated experiments, which is exactly what CUT&RUN-specific blacklists were built from: negative-control datasets run through SEACR at a stringent threshold to catalog where noise reproducibly looks like signal.

Fragment size carries information here that it didn't in ChIP-seq. Because the enzyme cuts at the binding site rather than by random shearing, fragment length distinguishes a transcription-factor footprint from mono-nucleosome-sized debris. Single-end sequencing throws that away, and MACS2's own fragment-size model depends on having enough signal to fit a shift, which sparse CUT&RUN libraries often don't have. That's why paired-end sequencing plus --nomodel with a manually set extsize, or fragment-level analysis straight from paired-end reads, isn't an optional refinement. It's the baseline for the assay.

The checks

Run them in order. Each one tells you what healthy looks like and what the problem looks like.

0/7 checked · saved in this browser

01Confirm paired-end reads and check the fragment-size distribution
Verify the library is paired-end, then plot the insert-size distribution from properly paired read pairs in the BAM. Do this before anything else; it tells you whether fragment-level analysis is even possible and roughly what class of protein you're dealing with.
Healthy
Transcription-factor-like proteins show a sharp peak under roughly 120 bp; nucleosome-associated marks show a periodic ladder around 150, 300, and 450 bp reflecting mono-, di-, and tri-nucleosome fragments.
Red flag
A single-end library with no insert-size information, or a flat/uniform fragment-size distribution, which usually means fragmentation was closer to random shearing than targeted cutting and the sample itself is suspect.
02Rerun MACS2 with and without the IgG control and compare peak counts
Call peaks twice on the same BAM, once with the IgG/input as control and once without, keeping --nomodel and a manually set extsize fixed across both runs.
bash
```
macs2 callpeak -t IP.bam -c control.bam -n with_control -q 0.01 --nomodel --extsize 150
macs2 callpeak -t IP.bam -n no_control -q 0.01 --nomodel --extsize 150
wc -l with_control_peaks.narrowPeak no_control_peaks.narrowPeak
```
Healthy
Peak counts land in the same order of magnitude, or the no-control run is somewhat more permissive but not off by 100x.
Red flag
The control run returns a handful of peaks or zero while the no-control run returns tens of thousands, a sign the IgG control is over-penalizing real signal rather than modeling background.
03Compute FRiP
Compute the fraction of read fragments falling inside called peaks, using extended fragments (not just raw mapped reads) over the total number of usable fragments, matching how nf-core/cutandrun calculates it.
Healthy
FRiP in the same range as the ENCODE ChIP-seq floor of roughly 1%, often clearing it comfortably for CUT&RUN because true background is genuinely lower.
Red flag
FRiP under 1% for a target with well-documented binding, pointing to a failed pulldown, a nonspecific antibody, or a caller pulling in the noise floor as peaks.
04Run SEACR alongside MACS2 and compare
Convert target and control BAMs to bedgraph, then run SEACR with the control in norm mode (use non only if the data is already spike-in normalized).
bash
```
bedtools genomecov -bg -ibam target.bam > target.bedgraph
bedtools genomecov -bg -ibam control.bam > control.bedgraph
SEACR target.bedgraph control.bedgraph norm output_prefix
```
Healthy
SEACR and MACS2-without-control largely agree on the strong loci; SEACR's peak count is usually smaller and each region wider, reflecting its sparse-background-calibrated threshold.
Red flag
The two callers disagree on which loci are enriched at all, not just on how many peaks are called; that's a data-quality problem, not a caller-choice problem.
05Intersect peaks against the ENCODE blacklist and the CUT&RUN suspect list
Run bedtools intersect with -v against the ENCODE blacklist for your genome build, then again against the CUT&RUN-specific suspect list built from negative-control datasets, and keep only what survives both.
bash
```
bedtools intersect -a peaks.bed -b encode_blacklist.bed -v > step1.bed
bedtools intersect -a step1.bed -b cutrun_suspect_list.bed -v > filtered_peaks.bed
```
Healthy
A small fraction of peaks, typically well under 5%, drop out after filtering against both lists.
Red flag
A large share of your peaks, especially the top-scoring ones, disappear once you subtract the CUT&RUN suspect list, meaning your caller is mostly detecting the same artifacts that list was built to catalog.
06Look at the top 20 peaks by score in a genome browser
Sort the peak file by score or signal, take the top 20, and load them in IGV alongside a gene and repeat annotation track.
Healthy
Top peaks sit in unique-mappability regions near genes or regulatory elements plausible for your target.
Red flag
Top peaks cluster in centromeric satellite arrays, segmental duplications, or rDNA repeats, a pattern invisible in the peak table but obvious in five minutes of browsing.
07Check known positive-control loci for your target
Look up two or three genes or loci with published, well-established binding for your target protein (for an estrogen receptor experiment, that's genes like TFF1 or GREB1) and confirm a peak is called there.
Healthy
A visible, called peak at the expected loci.
Red flag
No peak at a locus with strong prior evidence for binding, which points to antibody specificity, a failed pulldown, or an overly conservative caller, not genuine biological absence.

What to do about it

Drop the IgG/input control and call peaks with a stringent q-value

When: Your target is a well-characterized TF or chromatin regulator, the IgG library is thin, and MACS2-with-control returns implausibly few peaks.

Run MACS2 without -c, keep --nomodel with a manually set --extsize from your fragment-size distribution, and tighten -q to 0.01 or lower. Compensate for the missing control by leaning harder on blacklist filtering and the top-20-peaks browser check.

Caveat: You lose the one signal that used to catch copy-number and mappability artifacts automatically, so skipping the blacklist and visual check afterward is exactly how false peaks slip through.

Switch to SEACR (or another CUT&RUN-native caller) instead of MACS2

When: MACS2 output swings wildly between control and no-control runs, or you're calling peaks on genuinely sparse libraries where MACS2's model has little signal to fit.

Convert BAM to bedgraph with bedtools genomecov, run SEACR in norm mode with your IgG/input as the control bedgraph (or non mode only if already spike-in normalized), and start with the stringent threshold setting.

Caveat: SEACR peaks are wider and don't carry a directly comparable q-value across experiments, so cross-study or cross-lab comparisons of peak significance need extra care.

Filter with both the ENCODE blacklist and the CUT&RUN suspect list

When: Peaks persist in centromeric, satellite, or segmental-duplication regions regardless of which caller or control setup you use.

Run bedtools intersect -v against the ENCODE blacklist for your genome build, then again against the CUT&RUN-specific suspect list built from negative-control datasets, and only trust what survives both.

Caveat: Blacklists are genome-build specific (hg38 and mm10 lists exist; check before applying one blindly to another build or species), and they will remove real signal for targets that legitimately bind repetitive DNA.

Try a CUT&RUN/CUT&Tag-native caller (GoPeaks, LanceOtron) when MACS2 and SEACR disagree

When: MACS2 and SEACR give substantially different peak sets on the same data and you can't tell which is closer to the truth from browser inspection alone.

Run GoPeaks, built specifically for CUT&TAG/CUT&RUN, with default settings on the same BAM and compare its calls against your positive-control loci and the MACS2/SEACR overlap.

Caveat: These tools are newer and less battle-tested across labs than MACS2; validate against known biology every time rather than assuming a purpose-built tool is automatically right.

Normalize to spike-in DNA before comparing peak strength across samples

When: You're comparing binding intensity or peak counts between conditions or treatments, not just presence or absence in one sample.

Use the E. coli DNA carried over by the pA-MNase or pA-Tn5 enzyme as a spike-in, compute a per-sample normalization factor from spike-in read counts, and scale coverage tracks before calling peaks or running differential binding.

Caveat: Requires the spike-in genome in your alignment reference with its reads tracked separately; skip this step and 'more peaks' in one sample could just mean deeper sequencing or better tethering efficiency, not more binding.

When not to "fix" it

Don't blacklist your way to a clean-looking peak list when the target genuinely lives in repeat-rich or high-copy DNA. CENP-A and other centromeric or kinetochore proteins are supposed to peak in centromeric satellite arrays. H3K9me3 and other heterochromatin marks are supposed to enrich over pericentromeric and telomeric repeats. Factors that regulate ribosomal RNA transcription are supposed to show signal over the repetitive rDNA locus. If your target has a documented reason to sit in a masked region, a generic blacklist erases the actual finding along with the noise. In that case, skip the blanket filter and instead build a matched negative control (an untagged or IgG sample processed identically) and check the suspect loci by name rather than removing every repeat-annotated region wholesale.

Five things experienced analysts do here

Sequence CUT&RUN and CUT&Tag paired-end by default; the fragment-size distribution is diagnostic information you cannot recover from single-end data after the fact.
Keep an IgG or no-antibody control in every batch even when you plan to call peaks without it, since you still need it to build local blacklists and confirm the no-control assumption holds for your specific samples.
Never sign off on a peak list before checking two or three known positive-control loci for the target by name, not just an aggregate metric like FRiP.
Treat CUT&RUN suspect lists and ENCODE blacklists as complementary, not interchangeable; apply both and check what each one uniquely removes before trusting the survivors.
Budget for spike-in normalization from the start of the experiment, not as an afterthought, because you can't recover a missing spike-in once the library is made and you need it to make any 'more binding' claim across conditions.

Questions people ask

Do I need an input or IgG control to call CUT&RUN peaks?: Not necessarily, and if you use one you should watch for MACS2 over-penalizing real signal because IgG in CUT&RUN carries almost no reads. Many pipelines call peaks without a control, using a stringent q-value plus blacklist filtering, or use SEACR, which calibrates its threshold from the global background distribution instead of a matched control library. Keep an IgG sample in the batch anyway for QC and blacklist-building purposes.
Why do my strongest CUT&RUN peaks sit in centromeres or repeat regions?: Without a control to flag them, copy-number gains, highly accessible chromatin, and low-mappability repeats produce read pileups a caller can't distinguish from real enrichment. These artifacts recur at the same loci across unrelated experiments, which is exactly why CUT&RUN-specific blacklists, built from negative-control datasets and separate from the ENCODE ChIP-seq blacklist, exist. Intersect your peaks against both before trusting the top of the list.
What FRiP score should I expect from CUT&RUN or CUT&Tag?: The ENCODE ChIP-seq floor of roughly 1% is a reasonable starting reference, but CUT&RUN's much lower background means healthy experiments often clear that easily, sometimes by several fold. A FRiP under 1% on a well-studied target is a red flag for antibody or pulldown failure, not just a caller quirk.
Should I use narrow or broad peak settings for CUT&RUN?: Match the setting to the biology of the mark, not to the assay. Point-source factors and transcription factors are narrow; histone marks that form broad domains, like H3K27me3 or H3K9me3, need broad-peak calling or they fragment into thousands of disconnected small intervals that misrepresent the underlying domain.
MACS2, SEACR, or GoPeaks: which caller should I trust for CUT&RUN?: None of them wins outright; benchmarks comparing MACS2, SEACR, GoPeaks, and LanceOtron on CUT&RUN data show each has different failure modes. Run at least two callers, check where they agree, and validate the disagreements against known positive-control loci before deciding which output to use downstream.

Guide · How to Call Peaks You Can Trust in ATAC-seq
Guide · How to Call Peaks You Can Trust in ChIP-seq
Guide · How to Call Peaks You Can Trust in Single-Cell ATAC-seq
Glossary · Effect size
Glossary · Nextflow
Glossary · P-value

Sources

Peak calling by Sparse Enrichment Analysis for CUT&RUN chromatin profiling — SEACR algorithm and why it suits CUT&RUN's low background better than a local model calibrated against a control library
The CUT&RUN suspect list of problematic regions of the genome — CUT&RUN-specific blacklist construction and why it's needed alongside the ENCODE blacklist
Benchmarking Peak Calling Methods for CUT&RUN — Comparison of MACS2, SEACR, GoPeaks and LanceOtron performance on CUT&RUN data
nf-core/cutandrun Pipeline — Reference pipeline implementation of blacklist filtering and FRiP calculated on extended fragments

Part of the Peak calling controls and blacklists series.