diff --git a/src/qibocal/protocols/characterization/couplers/coupler_qubit_spectroscopy.py b/src/qibocal/protocols/characterization/couplers/coupler_qubit_spectroscopy.py
index c9b1e7c98..8b5cb1c15 100644
--- a/src/qibocal/protocols/characterization/couplers/coupler_qubit_spectroscopy.py
+++ b/src/qibocal/protocols/characterization/couplers/coupler_qubit_spectroscopy.py
@@ -9,7 +9,6 @@
 
 from qibocal.auto.operation import Routine
 
-from ..flux_dependence import resonator_flux_dependence
 from ..two_qubit_interaction.utils import order_pair
 from .coupler_resonator_spectroscopy import _fit, _plot, _update
 from .utils import CouplerSpectroscopyData, CouplerSpectroscopyParameters
@@ -83,31 +82,20 @@ def _acquisition(
         type=SweeperType.OFFSET,
     )
 
-    if params.flux_pulses:
-        (
-            delta_bias_flux_range,
-            sweepers,
-            sequences,
-        ) = resonator_flux_dependence.create_flux_pulse_sweepers(
-            params, platform, couplers, sequence
-        )
-        sequence = sequences[0]
-    else:
-        delta_bias_flux_range = np.arange(
-            -params.bias_width / 2, params.bias_width / 2, params.bias_step
+    delta_bias_range = np.arange(
+        -params.bias_width / 2, params.bias_width / 2, params.bias_step
+    )
+    sweepers = [
+        Sweeper(
+            Parameter.bias,
+            delta_bias_range,
+            qubits=couplers,
+            type=SweeperType.OFFSET,
         )
-        sweepers = [
-            Sweeper(
-                Parameter.bias,
-                delta_bias_flux_range,
-                qubits=couplers,
-                type=SweeperType.OFFSET,
-            )
-        ]
+    ]
 
     data = CouplerSpectroscopyData(
         resonator_type=platform.resonator_type,
-        flux_pulses=params.flux_pulses,
         offset=offset,
     )
 
@@ -135,7 +123,7 @@ def _acquisition(
             signal=result.magnitude,
             phase=result.phase,
             freq=delta_frequency_range + qd_pulses[qubit].frequency,
-            bias=delta_bias_flux_range,
+            bias=delta_bias_range,
         )
     return data
 
diff --git a/src/qibocal/protocols/characterization/couplers/coupler_resonator_spectroscopy.py b/src/qibocal/protocols/characterization/couplers/coupler_resonator_spectroscopy.py
index 470fc5434..9848a2a8c 100644
--- a/src/qibocal/protocols/characterization/couplers/coupler_resonator_spectroscopy.py
+++ b/src/qibocal/protocols/characterization/couplers/coupler_resonator_spectroscopy.py
@@ -7,7 +7,6 @@
 
 from qibocal.auto.operation import Routine
 
-from ..flux_dependence import resonator_flux_dependence
 from ..flux_dependence.utils import flux_dependence_plot
 from ..two_qubit_interaction.utils import order_pair
 from .utils import (
@@ -72,30 +71,20 @@ def _acquisition(
         type=SweeperType.OFFSET,
     )
 
-    if params.flux_pulses:
-        # TODO: Add delay
-        (delta_bias_flux_range, sweepers, sequences) = (
-            resonator_flux_dependence.create_flux_pulse_sweepers(
-                params, platform, couplers, sequence
-            )
-        )
-        sequence = sequences[0]
-    else:
-        delta_bias_flux_range = np.arange(
-            -params.bias_width / 2, params.bias_width / 2, params.bias_step
+    delta_bias_range = np.arange(
+        -params.bias_width / 2, params.bias_width / 2, params.bias_step
+    )
+    sweepers = [
+        Sweeper(
+            Parameter.bias,
+            delta_bias_range,
+            qubits=couplers,
+            type=SweeperType.OFFSET,
         )
-        sweepers = [
-            Sweeper(
-                Parameter.bias,
-                delta_bias_flux_range,
-                qubits=couplers,
-                type=SweeperType.OFFSET,
-            )
-        ]
+    ]
 
     data = CouplerSpectroscopyData(
         resonator_type=platform.resonator_type,
-        flux_pulses=params.flux_pulses,
         offset=offset,
     )
 
@@ -123,7 +112,7 @@ def _acquisition(
             signal=result.magnitude,
             phase=result.phase,
             freq=delta_frequency_range + ro_pulses[qubit].frequency,
-            bias=delta_bias_flux_range,
+            bias=delta_bias_range,
         )
     return data
 
diff --git a/src/qibocal/protocols/characterization/couplers/utils.py b/src/qibocal/protocols/characterization/couplers/utils.py
index b2518a347..9e2648dce 100644
--- a/src/qibocal/protocols/characterization/couplers/utils.py
+++ b/src/qibocal/protocols/characterization/couplers/utils.py
@@ -51,8 +51,6 @@ class CouplerSpectroscopyData(Data):
 
     resonator_type: str
     """Resonator type."""
-    flux_pulses: bool
-    """True if sweeping flux pulses, False if sweeping bias."""
     offset: dict[QubitId, float] = field(default_factory=dict)
     """Qubit bias offset."""
     data: dict[QubitId, npt.NDArray[CouplerSpecType]] = field(default_factory=dict)
diff --git a/src/qibocal/protocols/characterization/flux_dependence/qubit_crosstalk.py b/src/qibocal/protocols/characterization/flux_dependence/qubit_crosstalk.py
index 1469c1a43..a51d47445 100644
--- a/src/qibocal/protocols/characterization/flux_dependence/qubit_crosstalk.py
+++ b/src/qibocal/protocols/characterization/flux_dependence/qubit_crosstalk.py
@@ -24,7 +24,6 @@
     QubitFluxType,
 )
 from .qubit_flux_dependence import _fit as diagonal_fit
-from .resonator_flux_dependence import create_flux_pulse_sweepers
 
 
 @dataclass
@@ -73,7 +72,6 @@ def register_qubit(self, qubit, flux_qubit, freq, bias, signal, phase):
     def diagonal(self) -> Optional[QubitFluxData]:
         instance = QubitFluxData(
             resonator_type=self.resonator_type,
-            flux_pulses=self.flux_pulses,
             qubit_frequency=self.qubit_frequency,
         )
         for qubit in self.qubits:
@@ -88,7 +86,6 @@ def diagonal(self) -> Optional[QubitFluxData]:
             return instance
         return QubitFluxData(
             resonator_type=self.resonator_type,
-            flux_pulses=self.flux_pulses,
             qubit_frequency=self.qubit_frequency,
         )
 
@@ -167,24 +164,21 @@ def _acquisition(
         flux_qubits = list(platform.qubits)
     else:
         flux_qubits = params.flux_qubits
-    if params.flux_pulses:
-        delta_bias_flux_range, sweepers, sequences = create_flux_pulse_sweepers(
-            params, platform, flux_qubits, sequence, crosstalk=True
-        )
-    else:
-        delta_bias_flux_range = np.arange(
-            -params.bias_width / 2, params.bias_width / 2, params.bias_step
+
+    delta_bias_range = np.arange(
+        -params.bias_width / 2, params.bias_width / 2, params.bias_step
+    )
+    sequences = [sequence] * len(flux_qubits)
+    sweepers = [
+        Sweeper(
+            Parameter.bias,
+            delta_bias_range,
+            qubits=[platform.qubits[flux_qubit]],
+            type=SweeperType.OFFSET,
         )
-        sequences = [sequence] * len(flux_qubits)
-        sweepers = [
-            Sweeper(
-                Parameter.bias,
-                delta_bias_flux_range,
-                qubits=[platform.qubits[flux_qubit]],
-                type=SweeperType.OFFSET,
-            )
-            for flux_qubit in flux_qubits
-        ]
+        for flux_qubit in flux_qubits
+    ]
+
     data = QubitCrosstalkData(
         resonator_type=platform.resonator_type,
         sweetspot=sweetspots,
@@ -192,7 +186,6 @@ def _acquisition(
         matrix_element=matrix_element,
         d=d,
         qubit_frequency=qubit_frequency,
-        flux_pulses=params.flux_pulses,
     )
 
     options = ExecutionParameters(
@@ -216,7 +209,7 @@ def _acquisition(
                 signal=result.magnitude,
                 phase=result.phase,
                 freq=delta_frequency_range + qd_pulses[qubit].frequency,
-                bias=delta_bias_flux_range + sweetspot,
+                bias=delta_bias_range + sweetspot,
             )
 
     return data
diff --git a/src/qibocal/protocols/characterization/flux_dependence/qubit_flux_dependence.py b/src/qibocal/protocols/characterization/flux_dependence/qubit_flux_dependence.py
index 878d62d33..34e15705b 100644
--- a/src/qibocal/protocols/characterization/flux_dependence/qubit_flux_dependence.py
+++ b/src/qibocal/protocols/characterization/flux_dependence/qubit_flux_dependence.py
@@ -18,7 +18,7 @@
 )
 
 from ..utils import GHZ_TO_HZ, HZ_TO_GHZ, extract_feature, table_dict, table_html
-from . import resonator_flux_dependence, utils
+from . import utils
 from .resonator_flux_dependence import ResonatorFluxParameters
 
 
@@ -67,9 +67,6 @@ class QubitFluxData(Data):
     resonator_type: str
     """Resonator type."""
 
-    flux_pulses: bool
-    """True if sweeping flux pulses, False if sweeping bias."""
-
     qubit_frequency: dict[QubitId, float] = field(default_factory=dict)
     """Qubit frequencies."""
 
@@ -134,32 +131,24 @@ def _acquisition(
         pulses=[qd_pulses[qubit] for qubit in targets],
         type=SweeperType.OFFSET,
     )
-    if params.flux_pulses:
-        (delta_bias_flux_range, sweepers, sequences) = (
-            resonator_flux_dependence.create_flux_pulse_sweepers(
-                params, platform, targets, sequence
-            )
-        )
-        sequence = sequences[0]
-    else:
-        delta_bias_flux_range = np.arange(
-            -params.bias_width, params.bias_width, params.bias_step
+
+    delta_bias_range = np.arange(
+        -params.bias_width / 2, params.bias_width / 2, params.bias_step
+    )
+    sweepers = [
+        Sweeper(
+            Parameter.bias,
+            delta_bias_range,
+            qubits=[platform.qubits[qubit] for qubit in targets],
+            type=SweeperType.OFFSET,
         )
-        sweepers = [
-            Sweeper(
-                Parameter.bias,
-                delta_bias_flux_range,
-                qubits=[platform.qubits[qubit] for qubit in targets],
-                type=SweeperType.OFFSET,
-            )
-        ]
+    ]
+
     data = QubitFluxData(
         resonator_type=platform.resonator_type,
         charging_energy={
             qubit: -platform.qubits[qubit].anharmonicity for qubit in targets
         },
-        flux_pulses=params.flux_pulses,
-        qubit_frequency=qubit_frequency,
         offset=offset,
     )
     options = ExecutionParameters(
@@ -179,7 +168,7 @@ def _acquisition(
                 signal=result.magnitude,
                 phase=result.phase,
                 freq=delta_frequency_range + qd_pulses[qubit].frequency,
-                bias=delta_bias_flux_range + sweetspot,
+                bias=delta_bias_range + sweetspot,
             )
     return data
 
@@ -266,16 +255,12 @@ def _plot(data: QubitFluxData, fit: QubitFluxResults, target: QubitId):
         target,
         fit_function=utils.transmon_frequency,
     )
-    if data.flux_pulses:
-        bias_flux_unit = "a.u."
-    else:
-        bias_flux_unit = "V"
     if fit is not None:
         fitting_report = table_html(
             table_dict(
                 target,
                 [
-                    f"Sweetspot [{bias_flux_unit}]",
+                    f"Sweetspot [V]",
                     "Qubit Frequency at Sweetspot [Hz]",
                     "Flux dependence",
                 ],
diff --git a/src/qibocal/protocols/characterization/flux_dependence/qubit_flux_tracking.py b/src/qibocal/protocols/characterization/flux_dependence/qubit_flux_tracking.py
index 1103bf88a..748013bca 100644
--- a/src/qibocal/protocols/characterization/flux_dependence/qubit_flux_tracking.py
+++ b/src/qibocal/protocols/characterization/flux_dependence/qubit_flux_tracking.py
@@ -95,7 +95,6 @@ def _acquisition(
 
     data = QubitFluxTrackData(
         resonator_type=platform.resonator_type,
-        flux_pulses=params.flux_pulses,
         qubit_frequency=qubit_frequency,
     )
 
diff --git a/src/qibocal/protocols/characterization/flux_dependence/resonator_crosstalk.py b/src/qibocal/protocols/characterization/flux_dependence/resonator_crosstalk.py
index 786609439..135781f91 100644
--- a/src/qibocal/protocols/characterization/flux_dependence/resonator_crosstalk.py
+++ b/src/qibocal/protocols/characterization/flux_dependence/resonator_crosstalk.py
@@ -23,7 +23,6 @@
     ResonatorFluxResults,
 )
 from .resonator_flux_dependence import _fit as diagonal_fit
-from .resonator_flux_dependence import create_flux_pulse_sweepers
 
 
 @dataclass
@@ -87,7 +86,6 @@ def register_qubit(self, qubit, flux_qubit, freq, bias, signal, phase):
     def diagonal(self) -> Optional[ResonatorFluxData]:
         instance = ResonatorFluxData(
             resonator_type=self.resonator_type,
-            flux_pulses=self.flux_pulses,
             qubit_frequency=self.qubit_frequency,
             bare_resonator_frequency=self.bare_resonator_frequency,
         )
@@ -103,7 +101,6 @@ def diagonal(self) -> Optional[ResonatorFluxData]:
             return instance
         return ResonatorFluxData(
             resonator_type=self.resonator_type,
-            flux_pulses=self.flux_pulses,
             qubit_frequency=self.qubit_frequency,
         )
 
@@ -160,28 +157,23 @@ def _acquisition(
 
     else:
         flux_qubits = params.flux_qubits
-    if params.flux_pulses:
-        delta_bias_flux_range, sweepers, sequences = create_flux_pulse_sweepers(
-            params, platform, flux_qubits, sequence, crosstalk=True
-        )
-    else:
-        delta_bias_flux_range = np.arange(
-            -params.bias_width / 2, params.bias_width / 2, params.bias_step
+
+    delta_bias_range = np.arange(
+        -params.bias_width / 2, params.bias_width / 2, params.bias_step
+    )
+    sequences = [sequence] * len(flux_qubits)
+    sweepers = [
+        Sweeper(
+            Parameter.bias,
+            delta_bias_range,
+            qubits=[platform.qubits[flux_qubit]],
+            type=SweeperType.OFFSET,
         )
-        sequences = [sequence] * len(flux_qubits)
-        sweepers = [
-            Sweeper(
-                Parameter.bias,
-                delta_bias_flux_range,
-                qubits=[platform.qubits[flux_qubit]],
-                type=SweeperType.OFFSET,
-            )
-            for flux_qubit in flux_qubits
-        ]
+        for flux_qubit in flux_qubits
+    ]
 
     data = ResCrosstalkData(
         resonator_type=platform.resonator_type,
-        flux_pulses=params.flux_pulses,
         qubit_frequency=qubit_frequency,
         resonator_frequency=resonator_frequency,
         sweetspot=sweetspots,
@@ -212,7 +204,7 @@ def _acquisition(
                 signal=result.magnitude,
                 phase=result.phase,
                 freq=delta_frequency_range + ro_pulses[qubit].frequency,
-                bias=delta_bias_flux_range + sweetspot,
+                bias=delta_bias_range + sweetspot,
             )
     return data
 
diff --git a/src/qibocal/protocols/characterization/flux_dependence/resonator_flux_dependence.py b/src/qibocal/protocols/characterization/flux_dependence/resonator_flux_dependence.py
index cac933326..a4ffdc718 100644
--- a/src/qibocal/protocols/characterization/flux_dependence/resonator_flux_dependence.py
+++ b/src/qibocal/protocols/characterization/flux_dependence/resonator_flux_dependence.py
@@ -1,6 +1,5 @@
-from copy import deepcopy
 from dataclasses import dataclass, field
-from typing import List, Optional, Union
+from typing import Optional
 
 import numpy as np
 import numpy.typing as npt
@@ -31,68 +30,6 @@ class ResonatorFluxParameters(Parameters):
     """Width for bias sweep [V]."""
     bias_step: Optional[float] = None
     """Bias step for sweep [a.u.]."""
-    flux_amplitude_start: Optional[Union[int, float, List[float]]] = None
-    """Amplitude start value(s) for flux pulses sweep relative to the qubit sweetspot [a.u.]."""
-    flux_amplitude_end: Optional[Union[int, float, List[float]]] = None
-    """Amplitude end value(s) for flux pulses sweep relative to the qubit sweetspot [a.u.]."""
-    flux_amplitude_step: Optional[Union[int, float, List[float]]] = None
-    """Amplitude step(s) for flux pulses sweep [a.u.]."""
-
-    def __post_init__(self):
-        if not self.has_bias_params:
-            if self.has_flux_params:
-                self.check_flux_params()
-                return
-        if not self.has_flux_params:
-            if self.has_bias_params:
-                return
-        raise ValueError(
-            "Too many arguments provided. Provide either bias_width "
-            "and bias_step or flux_amplitude_width and flux_amplitude_step."
-        )
-
-    def check_flux_params(self):
-        """All flux params must be either all float or all lists with the same length.
-
-        This function does not check if the lenght of the lists is equal to the number
-        of qubits in the experiment.
-        """
-        flux_params = (
-            self.flux_amplitude_start,
-            self.flux_amplitude_end,
-            self.flux_amplitude_step,
-        )
-        if all(isinstance(param, (int, float)) for param in flux_params):
-            return
-
-        if all(isinstance(param, list) for param in flux_params):
-            if all(len(param) == len(flux_params[0]) for param in flux_params):
-                return
-            raise ValueError("Flux lists do not have the same length.")
-        raise ValueError(
-            "flux parameters have the wrong type. Expected one of (int, float, list)."
-        )
-
-    @property
-    def has_bias_params(self):
-        """True if both bias_width and bias_step are set."""
-        return self.bias_width is not None and self.bias_step is not None
-
-    @property
-    def has_flux_params(self):
-        """True if both all flux amplitude parameters are set."""
-        return (
-            self.flux_amplitude_start is not None
-            and self.flux_amplitude_end is not None
-            and self.flux_amplitude_step is not None
-        )
-
-    @property
-    def flux_pulses(self):
-        """True if sweeping flux pulses, False if sweeping bias."""
-        if self.has_flux_params:
-            return True
-        return False
 
 
 @dataclass
@@ -123,8 +60,6 @@ class ResonatorFluxData(Data):
 
     resonator_type: str
     """Resonator type."""
-    flux_pulses: bool
-    """True if sweeping flux pulses, False if sweeping bias."""
     qubit_frequency: dict[QubitId, float] = field(default_factory=dict)
     """Qubit frequencies."""
     offset: dict[QubitId, float] = field(default_factory=dict)
@@ -144,80 +79,6 @@ def register_qubit(self, qubit, freq, bias, signal, phase):
         )
 
 
-def create_flux_pulse_sweepers(
-    params: ResonatorFluxParameters,
-    platform: Platform,
-    qubits: list[QubitId],
-    sequence: PulseSequence,
-    crosstalk: bool = False,
-) -> tuple[np.ndarray, list[Sweeper], list[PulseSequence]]:
-    """Create a list of sweepers containing flux pulses.
-
-    Args:
-        params (ResonatorFluxParameters): parameters of the experiment (here flux amplitude is used).
-        platform (Platform): platform on which to run the experiment.
-        qubits (Qubits): qubits on which to run the experiment.
-        sequence (PulseSequence): pulse sequence of the experiment (updated with flux pulses).
-        crosstalk (bool): if True it will split amplitude sweepers (necessary for crosstalk protocol)
-    """
-    qf_pulses = {}
-    sequences = [deepcopy(sequence) for _ in range(len(qubits))]
-    for i, qubit in enumerate(qubits):
-        if isinstance(params.flux_amplitude_start, list):
-            flux_amplitude_start = params.flux_amplitude_start[i]
-            flux_amplitude_end = params.flux_amplitude_end[i]
-            flux_amplitude_step = params.flux_amplitude_step[i]
-        else:
-            flux_amplitude_start = params.flux_amplitude_start
-            flux_amplitude_end = params.flux_amplitude_end
-            flux_amplitude_step = params.flux_amplitude_step
-        delta_bias_flux_range = np.arange(
-            flux_amplitude_start,
-            flux_amplitude_end,
-            flux_amplitude_step,
-        )
-
-        if qubit not in platform.qubits:
-            # FIXME: Missmatch with create_coupler_pulse and create_qubit_flux_pulse
-            pulse = platform.create_coupler_pulse(
-                qubit,
-                start=0,
-                duration=sequence.duration,
-                amplitude=1,
-            )
-        else:
-            pulse = platform.create_qubit_flux_pulse(
-                qubit, start=0, duration=sequence.duration
-            )
-        qf_pulses[qubit] = pulse
-        if crosstalk:
-            sequences[i].add(pulse)
-        else:
-            sequence.add(pulse)
-
-    if crosstalk:
-        sweepers = [
-            Sweeper(
-                Parameter.amplitude,
-                delta_bias_flux_range,
-                pulses=[qf_pulses[qubit]],
-                type=SweeperType.ABSOLUTE,
-            )
-            for qubit in qubits
-        ]
-        return delta_bias_flux_range, sweepers, sequences
-    else:
-        sweepers = [
-            Sweeper(
-                Parameter.amplitude,
-                delta_bias_flux_range,
-                pulses=[qf_pulses[qubit] for qubit in qubits],
-                type=SweeperType.ABSOLUTE,
-            )
-        ]
-        return delta_bias_flux_range, sweepers, [sequence]
-
-
 def _acquisition(
     params: ResonatorFluxParameters, platform: Platform, targets: list[QubitId]
 ) -> ResonatorFluxData:
@@ -254,27 +115,21 @@ def _acquisition(
         [ro_pulses[qubit] for qubit in targets],
         type=SweeperType.OFFSET,
     )
-    if params.flux_pulses:
-        delta_bias_flux_range, sweepers, sequences = create_flux_pulse_sweepers(
-            params, platform, targets, sequence
-        )
-        sequence = sequences[0]
-    else:
-        delta_bias_flux_range = np.arange(
-            -params.bias_width / 2, params.bias_width / 2, params.bias_step
+
+    delta_bias_range = np.arange(
+        -params.bias_width / 2, params.bias_width / 2, params.bias_step
+    )
+    sweepers = [
+        Sweeper(
+            Parameter.bias,
+            delta_bias_range,
+            qubits=[platform.qubits[qubit] for qubit in targets],
+            type=SweeperType.OFFSET,
         )
-        sweepers = [
-            Sweeper(
-                Parameter.bias,
-                delta_bias_flux_range,
-                qubits=[platform.qubits[qubit] for qubit in targets],
-                type=SweeperType.OFFSET,
-            )
-        ]
+    ]
 
     data = ResonatorFluxData(
         resonator_type=platform.resonator_type,
-        flux_pulses=params.flux_pulses,
         qubit_frequency=qubit_frequency,
         offset=offset,
         matrix_element=matrix_element,
@@ -299,7 +154,7 @@ def _acquisition(
                 signal=result.magnitude,
                 phase=result.phase,
                 freq=delta_frequency_range + ro_pulses[qubit].frequency,
-                bias=delta_bias_flux_range + sweetspot,
+                bias=delta_bias_range + sweetspot,
             )
     return data
 
@@ -386,10 +241,6 @@ def _plot(data: ResonatorFluxData, fit: ResonatorFluxResults, target: QubitId):
         data, fit, target, utils.transmon_readout_frequency
     )
 
-    if data.flux_pulses:
-        bias_flux_unit = "a.u."
-    else:
-        bias_flux_unit = "V"
     if fit is not None:
         fitting_report = table_html(
             table_dict(
diff --git a/src/qibocal/protocols/characterization/flux_dependence/utils.py b/src/qibocal/protocols/characterization/flux_dependence/utils.py
index 15dd06481..bed85cdc5 100644
--- a/src/qibocal/protocols/characterization/flux_dependence/utils.py
+++ b/src/qibocal/protocols/characterization/flux_dependence/utils.py
@@ -42,11 +42,7 @@ def flux_dependence_plot(data, fit, qubit, fit_function=None):
     fig.add_trace(
         go.Heatmap(
             x=qubit_data.freq * HZ_TO_GHZ,
-            y=(
-                qubit_data.bias - data.offset[qubit]
-                if data.flux_pulses
-                else qubit_data.bias
-            ),
+            y=qubit_data.bias,
             z=qubit_data.signal,
             colorbar_x=0.46,
         ),
@@ -65,7 +61,7 @@ def flux_dependence_plot(data, fit, qubit, fit_function=None):
         fig.add_trace(
             go.Scatter(
                 x=fit_function(bias, **params),
-                y=bias - data.offset[qubit] if data.flux_pulses else bias,
+                y=bias,
                 showlegend=True,
                 name="Fit",
                 marker=dict(color="green"),
@@ -80,10 +76,7 @@ def flux_dependence_plot(data, fit, qubit, fit_function=None):
         col=1,
     )
 
-    if data.flux_pulses:
-        fig.update_yaxes(title_text="Flux Amplitude [a.u.]", row=1, col=1)
-    else:
-        fig.update_yaxes(title_text="Bias [V]", row=1, col=1)
+    fig.update_yaxes(title_text="Bias [V]", row=1, col=1)
 
     fig.add_trace(
         go.Heatmap(
@@ -133,11 +126,7 @@ def flux_crosstalk_plot(data, qubit, fit, fit_function):
         fig.add_trace(
             go.Heatmap(
                 x=frequencies,
-                y=(
-                    qubit_data.bias - data.voltage[qubit]
-                    if data.flux_pulses
-                    else qubit_data.bias
-                ),
+                y=qubit_data.bias,
                 z=qubit_data.signal,
                 showscale=False,
             ),
@@ -153,11 +142,7 @@ def flux_crosstalk_plot(data, qubit, fit, fit_function):
                             xj=qubit_data.bias, **fit.fitted_parameters[flux_qubit]
                         )
                         * HZ_TO_GHZ,
-                        y=(
-                            qubit_data.bias - data.voltage[qubit]
-                            if data.flux_pulses
-                            else qubit_data.bias
-                        ),
+                        y=qubit_data.bias,
                         showlegend=not any(
                             isinstance(trace, go.Scatter) for trace in fig.data
                         ),
@@ -176,11 +161,7 @@ def flux_crosstalk_plot(data, qubit, fit, fit_function):
                             qubit_data.bias,
                             *diagonal_params,
                         ),
-                        y=(
-                            qubit_data.bias - data.voltage[flux_qubit[1]]
-                            if data.flux_pulses
-                            else qubit_data.bias
-                        ),
+                        y=qubit_data.bias,
                         showlegend=not any(
                             isinstance(trace, go.Scatter) for trace in fig.data
                         ),
@@ -198,16 +179,9 @@ def flux_crosstalk_plot(data, qubit, fit, fit_function):
             col=col + 1,
         )
 
-        if data.flux_pulses:
-            fig.update_yaxes(
-                title_text=f"Qubit {flux_qubit[1]}: Flux Amplitude [a.u.]",
-                row=1,
-                col=col + 1,
-            )
-        else:
-            fig.update_yaxes(
-                title_text=f"Qubit {flux_qubit[1]}: Bias [V]", row=1, col=col + 1
-            )
+        fig.update_yaxes(
+            title_text=f"Qubit {flux_qubit[1]}: Bias [V]", row=1, col=col + 1
+        )
 
     fig.update_layout(xaxis1=dict(range=[np.min(frequencies), np.max(frequencies)]))
     fig.update_layout(xaxis2=dict(range=[np.min(frequencies), np.max(frequencies)]))
diff --git a/tests/runcards/protocols.yml b/tests/runcards/protocols.yml
index a43ebe420..10778effb 100644
--- a/tests/runcards/protocols.yml
+++ b/tests/runcards/protocols.yml
@@ -102,42 +102,6 @@ actions:
       nshots: 10
 
 
-  - id: resonator flux dependence flux single value
-    priority: 0
-    operation: resonator_flux
-    parameters:
-      freq_width: 10_000_000
-      freq_step: 500_000
-      flux_amplitude_start: -0.4
-      flux_amplitude_end: 0.4
-      flux_amplitude_step:  0.1
-      nshots: 10
-
-  - id: resonator flux dependence flux single value int
-    priority: 0
-    operation: resonator_flux
-    parameters:
-      freq_width: 10_000_000
-      freq_step: 500_000
-      flux_amplitude_start: 0
-      flux_amplitude_end: 0.4
-      flux_amplitude_step:  0.1
-      nshots: 10
-
-
-  - id: resonator flux dependence flux several values
-    priority: 0
-    operation: resonator_flux
-    targets: [0, 1]
-    parameters:
-      freq_width: 10_000_000
-      freq_step: 500_000
-      flux_amplitude_start: [-0.4, 0]
-      flux_amplitude_end: [0.4, 0.4]
-      flux_amplitude_step:  [0.1, 0.1]
-      nshots: 10
-
-
   - id: resonator flux crosstalk # using ``flux_qubits``
     operation: resonator_crosstalk
     parameters:
@@ -150,20 +114,6 @@ actions:
       relaxation_time: 100
 
 
-  - id: resonator flux crosstalk # using ``flux_qubits``
-    priority: 0
-    operation: resonator_crosstalk
-    parameters:
-      freq_width: 10_000_000
-      freq_step: 500_000
-      flux_amplitude_start: -0.4
-      flux_amplitude_end: 0.4
-      flux_amplitude_step:  0.1
-      flux_qubits: [0, 1, 2, 3]
-      nshots: 10
-      relaxation_time: 100
-
-
   - id: qubit flux dependence #"01" transition
     operation: qubit_flux
     parameters:
@@ -177,21 +127,6 @@ actions:
       transition: "01"
 
 
-  - id: qubit flux dependence #"01" transition
-    priority: 0
-    operation: qubit_flux
-    parameters:
-      freq_width: 150_000_000
-      freq_step: 500_000
-      flux_amplitude_start: -0.1
-      flux_amplitude_end: 0.1
-      flux_amplitude_step:  0.005
-      drive_amplitude: 0.5
-      nshots: 1024
-      relaxation_time: 2000
-      transition: "01"
-
-
   - id: qubit flux dependence 02 #"02" transition
     operation: qubit_flux
     parameters:
@@ -231,22 +166,6 @@ actions:
       relaxation_time: 2000
 
 
-  - id: qubit flux crosstalk # using ``flux_qubits``
-    priority: 0
-    operation: qubit_crosstalk
-    parameters:
-      freq_width: 150_000_000
-      freq_step: 500_000
-      flux_amplitude_start: -0.1
-      flux_amplitude_end: 0.1
-      flux_amplitude_step:  0.005
-      drive_amplitude: 0.5
-      flux_qubits: [1, 2]
-      nshots: 1024
-      relaxation_time: 2000
-
-
-
   - id: rabi
     operation: rabi_amplitude
     parameters:
diff --git a/tests/runcards/protocols_couplers.yml b/tests/runcards/protocols_couplers.yml
index 0dfa30bcb..0c8dd1644 100644
--- a/tests/runcards/protocols_couplers.yml
+++ b/tests/runcards/protocols_couplers.yml
@@ -17,20 +17,6 @@ actions:
       nshots: 10
       relaxation_time: 3_000
 
-  - id: coupler_resonator_spectroscopy
-    operation: coupler_resonator_spectroscopy
-    targets: [[1, 2], [0, 2]]
-    parameters:
-      flux_amplitude_start: 0.0
-      flux_amplitude_end: 0.5
-      flux_amplitude_step:  0.05
-      freq_width: 10_000_000
-      freq_step: 1_000_000
-      measured_qubits: [1, 0]
-      amplitude: .3
-      nshots: 10
-      relaxation_time: 3_000
-
   - id: coupler_resonator_spectroscopy
     operation: coupler_resonator_spectroscopy
     targets: [[1, 2], [0, 2]]
@@ -56,20 +42,6 @@ actions:
       nshots: 10
       relaxation_time: 3_000
 
-  - id: coupler qubit spectroscopy
-    operation: coupler_qubit_spectroscopy
-    targets: [[1, 2], [0, 2]]
-    parameters:
-      flux_amplitude_start: 0.0
-      flux_amplitude_end: 0.5
-      flux_amplitude_step:  0.05
-      freq_width: 10_000_000
-      freq_step: 1_000_000
-      measured_qubits: [1, 0]
-      amplitude: .1
-      nshots: 10
-      relaxation_time: 3_000
-
   - id: coupler qubit spectroscopy
     operation: coupler_qubit_spectroscopy
     targets: [[1, 2], [0, 2]]
diff --git a/tests/test_protocols.py b/tests/test_protocols.py
index 6f8262985..ddd73957e 100644
--- a/tests/test_protocols.py
+++ b/tests/test_protocols.py
@@ -10,9 +10,6 @@
 from qibocal.auto.task import PLATFORM_DIR
 from qibocal.cli import utils
 from qibocal.cli._base import command
-from qibocal.protocols.characterization.flux_dependence.resonator_flux_dependence import (
-    ResonatorFluxParameters,
-)
 from qibocal.protocols.characterization.rabi.amplitude import RabiAmplitudeData
 from qibocal.protocols.characterization.rabi.ef import RabiAmplitudeEFData
 from qibocal.protocols.characterization.rabi.length import RabiLengthData
@@ -164,26 +161,4 @@ def test_extract_rabi():
         extract_rabi(RabiAmplitudeEFData)
 
 
-def test_resonator_flux_bias():
-    freq_width = 100_000
-    freq_step = 10_000
-    bias_width = 1
-    bias_step = 0.2
-    flux_start = -0.5
-    flux_end = 0.4
-    flux_step = 0.1
-    ResonatorFluxParameters(freq_width, freq_step, bias_width, bias_step)
-    ResonatorFluxParameters(freq_width, freq_step, flux_start, flux_end, flux_step)
-    with pytest.raises(ValueError):
-        ResonatorFluxParameters(
-            freq_width,
-            freq_step,
-            bias_width,
-            bias_step,
-            flux_start,
-            flux_end,
-            flux_step,
-        )
-
-
 # TODO: compare report by calling qq report