diff --git a/CHANGELOG.md b/CHANGELOG.md
index 08982eb374..f938db63a2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -64,7 +64,9 @@ See also our [versioning policy](https://amici.readthedocs.io/en/latest/versioni
     See the `compile_` argument.
 * Removals without deprecation:
   * `amici.sbml_import.species_to_parameters` has been removed.
-
+* Model output directory keyword arguments have been harmonized:
+  What was previously `model_output_dir`, `output_dir`, `outdir` is now
+  consistently called `output_dir` across the API.
 
 **Features**
 
diff --git a/python/sdist/amici/exporters/sundials/de_export.py b/python/sdist/amici/exporters/sundials/de_export.py
index 32e4e2df5c..c4a1e5807b 100644
--- a/python/sdist/amici/exporters/sundials/de_export.py
+++ b/python/sdist/amici/exporters/sundials/de_export.py
@@ -145,7 +145,7 @@ class DEExporter:
     def __init__(
         self,
         de_model: DEModel,
-        outdir: Path | str | None = None,
+        output_dir: Path | str | None = None,
         verbose: bool | int | None = False,
         assume_pow_positivity: bool | None = False,
         compiler: str | None = None,
@@ -160,7 +160,7 @@ def __init__(
         :param de_model:
             DE model definition
 
-        :param outdir:
+        :param output_dir:
             see :meth:`amici.de_export.DEExporter.set_paths`
 
         :param verbose:
@@ -208,7 +208,7 @@ def __init__(
             )
 
         self.set_name(model_name)
-        self.set_paths(outdir)
+        self.set_paths(output_dir)
 
         self._code_printer = AmiciCxxCodePrinter()
         for fun in CUSTOM_FUNCTIONS:
diff --git a/python/sdist/amici/importers/petab/_cli/import_petab.py b/python/sdist/amici/importers/petab/_cli/import_petab.py
index 622f51836e..5cd91591c5 100644
--- a/python/sdist/amici/importers/petab/_cli/import_petab.py
+++ b/python/sdist/amici/importers/petab/_cli/import_petab.py
@@ -26,7 +26,7 @@ def _parse_cli_args():
     parser.add_argument(
         "-o",
         "--output-dir",
-        dest="model_output_dir",
+        dest="output_dir",
         help="Name of the model directory to create",
     )
     parser.add_argument(
@@ -96,7 +96,7 @@ def _main():
     import_model_sbml(
         model_name=args.model_name,
         petab_problem=pp,
-        model_output_dir=args.model_output_dir,
+        output_dir=args.output_dir,
         compile=args.compile,
         generate_sensitivity_code=args.generate_sensitivity_code,
         verbose=args.verbose,
diff --git a/python/sdist/amici/importers/petab/_petab_importer.py b/python/sdist/amici/importers/petab/_petab_importer.py
index 760dc93154..89b4c6981d 100644
--- a/python/sdist/amici/importers/petab/_petab_importer.py
+++ b/python/sdist/amici/importers/petab/_petab_importer.py
@@ -94,7 +94,7 @@ def __init__(
         module_name: str = None,
         # TODO: model_id for selecting the model in multi-model problems
         # model_id: str = None,
-        outdir: str | Path = None,
+        output_dir: str | Path = None,
         jax: bool = False,
         output_parameter_defaults: dict[str, float] | None = None,
         verbose: int | bool = logging.INFO,
@@ -107,7 +107,7 @@ def __init__(
         :param compile_: Whether to compile the model extension after import.
         :param validate: Whether to validate the PEtab problem before import.
         :param module_name: The name of model module to generate.
-        :param outdir:
+        :param output_dir:
             The output directory where the model files are written to.
         :param jax: Whether to generate a JAX model instead of a
             SUNDIALS model. Currently, only ``False`` is supported.
@@ -178,8 +178,8 @@ def __init__(
                 "was specified in the PEtab problem."
             )
 
-        self._outdir: Path | None = (
-            None if outdir is None else Path(outdir).absolute()
+        self._output_dir: Path | None = (
+            None if output_dir is None else Path(output_dir).absolute()
         )
         self._jax = jax
         self._non_estimated_parameters_as_constants: bool = (
@@ -281,11 +281,11 @@ def model_id(self) -> str:
         return self._model_id
 
     @property
-    def outdir(self) -> Path:
+    def output_dir(self) -> Path:
         """The output directory where the model files are written to."""
-        if self._outdir is None:
-            self._outdir = get_model_dir(self._module_name, jax=self._jax)
-        return self._outdir
+        if self._output_dir is None:
+            self._output_dir = get_model_dir(self._module_name, jax=self._jax)
+        return self._output_dir
 
     def _do_import_sbml(self):
         """Import the model.
@@ -309,7 +309,7 @@ def _do_import_sbml(self):
 
         logger.info(
             f"Module name is '{self._module_name}'.\n"
-            f"Writing model code to '{self.outdir}'."
+            f"Writing model code to '{self.output_dir}'."
         )
 
         observation_model = self._get_observation_model()
@@ -354,7 +354,7 @@ def _do_import_sbml(self):
         if self._jax:
             sbml_importer.sbml2jax(
                 model_name=self._module_name,
-                output_dir=self.outdir,
+                output_dir=self.output_dir,
                 observation_model=observation_model,
                 verbose=self._verbose,
                 # **kwargs,
@@ -365,7 +365,7 @@ def _do_import_sbml(self):
             allow_reinit_fixpar_initcond = True
             sbml_importer.sbml2amici(
                 model_name=self._module_name,
-                output_dir=self.outdir,
+                output_dir=self.output_dir,
                 observation_model=observation_model,
                 fixed_parameters=fixed_parameters,
                 allow_reinit_fixpar_initcond=allow_reinit_fixpar_initcond,
@@ -398,7 +398,7 @@ def _do_import_pysb(
 
         logger.info(
             f"Module name is '{self._module_name}'.\n"
-            f"Writing model code to '{self.outdir}'."
+            f"Writing model code to '{self.output_dir}'."
         )
 
         observation_model = self._get_observation_model()
@@ -433,7 +433,7 @@ def _do_import_pysb(
             pysb2jax(
                 model=pysb_model,
                 model_name=self._module_name,
-                output_dir=self.outdir,
+                output_dir=self.output_dir,
                 observation_model=observation_model,
                 verbose=self._verbose,
                 pysb_model_has_obs_and_noise=True,
@@ -445,7 +445,7 @@ def _do_import_pysb(
             pysb2amici(
                 model=pysb_model,
                 model_name=self._module_name,
-                output_dir=self.outdir,
+                output_dir=self.output_dir,
                 verbose=True,
                 fixed_parameters=fixed_parameters,
                 observation_model=observation_model,
@@ -571,7 +571,7 @@ def import_module(self, force_import: bool = False) -> amici.ModelModule:
             Whether to force re-import even if the model module already exists.
         :return: The imported model module.
         """
-        if not self.outdir.is_dir() or force_import:
+        if not self.output_dir.is_dir() or force_import:
             if self.petab_problem.model.type_id == MODEL_TYPE_SBML:
                 self._do_import_sbml()
             else:
@@ -579,7 +579,7 @@ def import_module(self, force_import: bool = False) -> amici.ModelModule:
 
         return amici.import_model_module(
             self._module_name,
-            self.outdir,
+            self.output_dir,
         )
 
     def create_model(self) -> amici.sim.sundials.Model:
diff --git a/python/sdist/amici/importers/petab/v1/import_helpers.py b/python/sdist/amici/importers/petab/v1/import_helpers.py
index b191c61476..e32c91299b 100644
--- a/python/sdist/amici/importers/petab/v1/import_helpers.py
+++ b/python/sdist/amici/importers/petab/v1/import_helpers.py
@@ -136,7 +136,7 @@ def _create_model_name(folder: str | Path) -> str:
 
 
 def _can_import_model(
-    model_name: str, model_output_dir: str | Path, jax: bool = False
+    model_name: str, output_dir: str | Path, jax: bool = False
 ) -> bool:
     """
     Check whether a module of that name can already be imported.
@@ -144,7 +144,7 @@ def _can_import_model(
     # try to import (in particular checks version)
     try:
         model_module = amici.import_model_module(
-            *_get_package_name_and_path(model_name, model_output_dir, jax)
+            *_get_package_name_and_path(model_name, output_dir, jax)
         )
     except ModuleNotFoundError:
         return False
@@ -277,21 +277,21 @@ def check_model(
 
 
 def _get_package_name_and_path(
-    model_name: str, model_output_dir: str | Path, jax: bool = False
+    model_name: str, output_dir: str | Path, jax: bool = False
 ) -> tuple[str, Path]:
     """
     Get the package name and path for the generated model module.
 
     :param model_name:
         Name of the model
-    :param model_output_dir:
+    :param output_dir:
         Target directory for the generated model module
     :param jax:
         Whether to generate the paths for a JAX or CPP model
     :return:
     """
     if jax:
-        outdir = Path(model_output_dir)
+        outdir = Path(output_dir)
         return outdir.stem, outdir.parent
     else:
-        return model_name, Path(model_output_dir)
+        return model_name, Path(output_dir)
diff --git a/python/sdist/amici/importers/petab/v1/petab_import.py b/python/sdist/amici/importers/petab/v1/petab_import.py
index d63d272d2f..137b1b456d 100644
--- a/python/sdist/amici/importers/petab/v1/petab_import.py
+++ b/python/sdist/amici/importers/petab/v1/petab_import.py
@@ -40,21 +40,21 @@
 
 def import_petab_problem(
     petab_problem: petab.Problem,
-    model_output_dir: str | Path | None = None,
+    output_dir: str | Path | None = None,
     *,
     model_name: str = None,
     compile_: bool = None,
     non_estimated_parameters_as_constants=True,
     jax=False,
     **kwargs,
-) -> "amici.Model | amici.jax.JAXProblem":
+) -> "amici.sim.sundials.Model | amici.jax.JAXProblem":
     """
     Create an AMICI model for a PEtab problem.
 
     :param petab_problem:
         A petab problem containing all relevant information on the model.
 
-    :param model_output_dir:
+    :param output_dir:
         Directory to write the model code to. It will be created if it doesn't
         exist. Defaults to :func:`amici.get_model_dir`.
 
@@ -95,34 +95,33 @@ def import_petab_problem(
 
     if petab_problem.model.type_id == MODEL_TYPE_PYSB and model_name is None:
         model_name = petab_problem.pysb_model.name
-    elif model_name is None and model_output_dir:
-        model_name = _create_model_name(model_output_dir)
+    elif model_name is None and output_dir:
+        model_name = _create_model_name(output_dir)
 
     # generate folder and model name if necessary
-    if model_output_dir is None:
-        model_output_dir = amici.get_model_dir(model_name, jax=jax).absolute()
+    if output_dir is None:
+        output_dir = amici.get_model_dir(model_name, jax=jax).absolute()
     else:
-        model_output_dir = Path(model_output_dir).absolute()
+        output_dir = Path(output_dir).absolute()
 
-    model_output_dir.mkdir(parents=True, exist_ok=True)
+    output_dir.mkdir(parents=True, exist_ok=True)
 
     # check if compilation necessary
     if compile_ or (
-        compile_ is None
-        and not _can_import_model(model_name, model_output_dir, jax)
+        compile_ is None and not _can_import_model(model_name, output_dir, jax)
     ):
         # check if folder exists
-        if os.listdir(model_output_dir) and not compile_:
+        if os.listdir(output_dir) and not compile_:
             raise ValueError(
-                f"Cannot compile to {model_output_dir}: not empty. "
+                f"Cannot compile to {output_dir}: not empty. "
                 "Please assign a different target or set `compile_` to `True`."
             )
 
         # remove folder if exists
-        if not jax and os.path.exists(model_output_dir):
-            shutil.rmtree(model_output_dir)
+        if not jax and os.path.exists(output_dir):
+            shutil.rmtree(output_dir)
 
-        logger.info(f"Compiling model {model_name} to {model_output_dir}.")
+        logger.info(f"Compiling model {model_name} to {output_dir}.")
 
         if "sciml" in petab_problem.extensions_config:
             from petab_sciml.standard import NNModelStandard
@@ -235,7 +234,7 @@ def import_petab_problem(
             import_model_pysb(
                 petab_problem,
                 model_name=model_name,
-                model_output_dir=model_output_dir,
+                output_dir=output_dir,
                 jax=jax,
                 **kwargs,
             )
@@ -243,7 +242,7 @@ def import_petab_problem(
             import_model_sbml(
                 petab_problem=petab_problem,
                 model_name=model_name,
-                model_output_dir=model_output_dir,
+                output_dir=output_dir,
                 non_estimated_parameters_as_constants=non_estimated_parameters_as_constants,
                 hybridization=hybridization,
                 jax=jax,
@@ -252,7 +251,7 @@ def import_petab_problem(
 
     # import model
     model_module = amici.import_model_module(
-        *_get_package_name_and_path(model_name, model_output_dir, jax=jax)
+        *_get_package_name_and_path(model_name, output_dir, jax=jax)
     )
 
     if jax:
@@ -261,8 +260,7 @@ def import_petab_problem(
         model = model_module.Model()
 
         logger.info(
-            f"Successfully loaded jax model {model_name} "
-            f"from {model_output_dir}."
+            f"Successfully loaded jax model {model_name} from {output_dir}."
         )
 
         # Create and return JAXProblem
@@ -272,9 +270,7 @@ def import_petab_problem(
     model = model_module.get_model()
     check_model(amici_model=model, petab_problem=petab_problem)
 
-    logger.info(
-        f"Successfully loaded model {model_name} from {model_output_dir}."
-    )
+    logger.info(f"Successfully loaded model {model_name} from {output_dir}.")
 
     return model
 
diff --git a/python/sdist/amici/importers/petab/v1/pysb_import.py b/python/sdist/amici/importers/petab/v1/pysb_import.py
index 8a43f8c371..1ec213eec9 100644
--- a/python/sdist/amici/importers/petab/v1/pysb_import.py
+++ b/python/sdist/amici/importers/petab/v1/pysb_import.py
@@ -195,7 +195,7 @@ def _add_initialization_variables(
 @log_execution_time("Importing PEtab model", logger)
 def import_model_pysb(
     petab_problem: petab.Problem,
-    model_output_dir: str | Path | None = None,
+    output_dir: str | Path | None = None,
     verbose: bool | int | None = True,
     model_name: str | None = None,
     jax: bool = False,
@@ -207,7 +207,7 @@ def import_model_pysb(
     :param petab_problem:
         PySB PEtab problem
 
-    :param model_output_dir:
+    :param output_dir:
         Directory to write the model code to. Will be created if doesn't
         exist. Defaults to current directory.
 
@@ -293,7 +293,7 @@ def import_model_pysb(
 
         pysb2jax(
             model=pysb_model,
-            output_dir=model_output_dir,
+            output_dir=output_dir,
             model_name=model_name,
             verbose=True,
             observation_model=observation_model,
@@ -306,7 +306,7 @@ def import_model_pysb(
 
         pysb2amici(
             model=pysb_model,
-            output_dir=model_output_dir,
+            output_dir=output_dir,
             model_name=model_name,
             verbose=True,
             fixed_parameters=fixed_parameters,
diff --git a/python/sdist/amici/importers/petab/v1/sbml_import.py b/python/sdist/amici/importers/petab/v1/sbml_import.py
index 8143e4c078..d49593c05d 100644
--- a/python/sdist/amici/importers/petab/v1/sbml_import.py
+++ b/python/sdist/amici/importers/petab/v1/sbml_import.py
@@ -226,7 +226,7 @@ def _workaround_observable_parameters(
 def import_model_sbml(
     petab_problem: petab.Problem = None,
     model_name: str | None = None,
-    model_output_dir: str | Path | None = None,
+    output_dir: str | Path | None = None,
     verbose: bool | int | None = True,
     allow_reinit_fixpar_initcond: bool = True,
     validate: bool = True,
@@ -248,7 +248,7 @@ def import_model_sbml(
         this defaults to the file name without extension, otherwise
         the SBML model ID will be used.
 
-    :param model_output_dir:
+    :param output_dir:
         Directory to write the model code to. Will be created if doesn't
         exist. Defaults to current directory.
 
@@ -314,14 +314,13 @@ def import_model_sbml(
                 "ID was specified in the SBML model."
             )
 
-    if model_output_dir is None:
-        model_output_dir = os.path.join(
+    if output_dir is None:
+        output_dir = os.path.join(
             os.getcwd(), f"{model_name}-amici{amici.__version__}"
         )
 
     logger.info(
-        f"Model name is '{model_name}'.\n"
-        f"Writing model code to '{model_output_dir}'."
+        f"Model name is '{model_name}'.\nWriting model code to '{output_dir}'."
     )
 
     # Create a copy, because it will be modified by SbmlImporter
@@ -390,7 +389,7 @@ def import_model_sbml(
     if jax:
         sbml_importer.sbml2jax(
             model_name=model_name,
-            output_dir=model_output_dir,
+            output_dir=output_dir,
             observation_model=observation_model,
             verbose=verbose,
             hybridization=hybridization,
@@ -404,7 +403,7 @@ def import_model_sbml(
             )
         sbml_importer.sbml2amici(
             model_name=model_name,
-            output_dir=model_output_dir,
+            output_dir=output_dir,
             observation_model=observation_model,
             fixed_parameters=fixed_parameters,
             allow_reinit_fixpar_initcond=allow_reinit_fixpar_initcond,
@@ -417,7 +416,7 @@ def import_model_sbml(
         amici._get_default_argument(sbml_importer.sbml2amici, "compile"),
     ):
         # check that the model extension was compiled successfully
-        model_module = amici.import_model_module(model_name, model_output_dir)
+        model_module = amici.import_model_module(model_name, output_dir)
         model = model_module.get_model()
         check_model(amici_model=model, petab_problem=petab_problem)
 
diff --git a/python/sdist/amici/importers/pysb/__init__.py b/python/sdist/amici/importers/pysb/__init__.py
index 2d195297f8..fa90163b11 100644
--- a/python/sdist/amici/importers/pysb/__init__.py
+++ b/python/sdist/amici/importers/pysb/__init__.py
@@ -154,7 +154,7 @@ def pysb2jax(
 
     exporter = ODEExporter(
         ode_model,
-        outdir=output_dir,
+        output_dir=output_dir,
         model_name=model_name,
         verbose=verbose,
     )
@@ -292,7 +292,7 @@ def pysb2amici(
 
     exporter = DEExporter(
         ode_model,
-        outdir=output_dir,
+        output_dir=output_dir,
         model_name=model_name,
         verbose=verbose,
         assume_pow_positivity=assume_pow_positivity,
diff --git a/python/sdist/amici/importers/sbml/__init__.py b/python/sdist/amici/importers/sbml/__init__.py
index 554529d2ed..68e77bc017 100644
--- a/python/sdist/amici/importers/sbml/__init__.py
+++ b/python/sdist/amici/importers/sbml/__init__.py
@@ -399,7 +399,7 @@ def sbml2amici(
             exporter = DEExporter(
                 ode_model,
                 model_name=model_name,
-                outdir=output_dir,
+                output_dir=output_dir,
                 verbose=verbose,
                 assume_pow_positivity=assume_pow_positivity,
                 compiler=compiler,
@@ -524,7 +524,7 @@ def sbml2jax(
         exporter = ODEExporter(
             ode_model,
             model_name=model_name,
-            outdir=output_dir,
+            output_dir=output_dir,
             verbose=verbose,
             hybridization=hybridization,
         )
diff --git a/python/sdist/amici/jax/ode_export.py b/python/sdist/amici/jax/ode_export.py
index f1c6d60a95..f6225c7df4 100644
--- a/python/sdist/amici/jax/ode_export.py
+++ b/python/sdist/amici/jax/ode_export.py
@@ -117,7 +117,7 @@ class ODEExporter:
     def __init__(
         self,
         ode_model: DEModel,
-        outdir: Path | str | None = None,
+        output_dir: Path | str | None = None,
         verbose: bool | int | None = False,
         model_name: str | None = "model",
         hybridization: dict[str, dict] = None,
@@ -128,7 +128,7 @@ def __init__(
         :param ode_model:
             DE model definition
 
-        :param outdir:
+        :param output_dir:
             see :meth:`amici.de_export.DEExporter.set_paths`
 
         :param verbose:
@@ -159,7 +159,7 @@ def __init__(
         self.model_path: Path = Path()
 
         self.set_name(model_name)
-        self.set_paths(outdir)
+        self.set_paths(output_dir)
 
         self.model: DEModel = ode_model
 
diff --git a/python/sdist/amici/sim/sundials/petab/v1/_simulator.py b/python/sdist/amici/sim/sundials/petab/v1/_simulator.py
index 7249789c17..bc606f4095 100644
--- a/python/sdist/amici/sim/sundials/petab/v1/_simulator.py
+++ b/python/sdist/amici/sim/sundials/petab/v1/_simulator.py
@@ -26,7 +26,7 @@
 AMICI_MODEL = "amici_model"
 AMICI_SOLVER = "solver"
 MODEL_NAME = "model_name"
-MODEL_OUTPUT_DIR = "model_output_dir"
+OUTPUT_DIR = "output_dir"
 
 PETAB_PROBLEM = "petab_problem"
 
@@ -77,8 +77,8 @@ def simulate_without_noise(self, **kwargs) -> pd.DataFrame:
                     # cached, it can cause issues during import.
                     while kwargs[MODEL_NAME] in sys.modules:
                         kwargs[MODEL_NAME] += str(self.rng.integers(10))
-                if MODEL_OUTPUT_DIR not in kwargs:
-                    kwargs[MODEL_OUTPUT_DIR] = self.working_dir
+                if OUTPUT_DIR not in kwargs:
+                    kwargs[OUTPUT_DIR] = self.working_dir
                 self.amici_model = _subset_call(import_petab_problem, kwargs)
             kwargs[AMICI_MODEL] = self.amici_model
         self.amici_model = kwargs[AMICI_MODEL]
diff --git a/python/sdist/amici/testing/models.py b/python/sdist/amici/testing/models.py
index 49d2a8a2be..6aca290947 100644
--- a/python/sdist/amici/testing/models.py
+++ b/python/sdist/amici/testing/models.py
@@ -110,12 +110,12 @@
 """
 
 
-def import_model_robertson(outdir: Path = None) -> Model:
+def import_model_robertson(output_dir: Path = None) -> Model:
     """Import the Robertson model."""
     model_name = "model_robertson_py"
 
-    if outdir is None:
-        outdir = model_name
+    if output_dir is None:
+        output_dir = model_name
 
     antimony2amici(
         robertson_ant,
@@ -126,19 +126,19 @@ def import_model_robertson(outdir: Path = None) -> Model:
             MeasurementChannel(id_="obs_x3", formula="x3"),
         ],
         model_name=model_name,
-        output_dir=outdir,
+        output_dir=output_dir,
     )
-    model_module = import_model_module(model_name, outdir)
+    model_module = import_model_module(model_name, output_dir)
     model = model_module.get_model()
 
     return model
 
 
-def import_model_calvetti(outdir: Path = None) -> Model:
+def import_model_calvetti(output_dir: Path = None) -> Model:
     model_name = "model_calvetti_py"
 
-    if outdir is None:
-        outdir = model_name
+    if output_dir is None:
+        output_dir = model_name
 
     antimony2amici(
         calvetti_ant,
@@ -152,10 +152,10 @@ def import_model_calvetti(outdir: Path = None) -> Model:
             MeasurementChannel(id_="obs_f2", formula="f2"),
         ],
         model_name=model_name,
-        output_dir=outdir,
+        output_dir=output_dir,
         hardcode_symbols=["p1"],
     )
-    model_module = import_model_module(model_name, outdir)
+    model_module = import_model_module(model_name, output_dir)
     model = model_module.get_model()
 
     assert model.get_fixed_parameter_ids() == (
@@ -170,26 +170,26 @@ def import_model_calvetti(outdir: Path = None) -> Model:
     return model
 
 
-def import_model_dirac(outdir: Path = None) -> Model:
+def import_model_dirac(output_dir: Path = None) -> Model:
     """Import the Dirac model."""
     model_name = "model_dirac_py"
 
-    if outdir is None:
-        outdir = model_name
+    if output_dir is None:
+        output_dir = model_name
 
     antimony2amici(
         model_dirac_ant,
         observation_model=[MeasurementChannel(id_="obs_x2", formula="x2")],
         model_name=model_name,
-        output_dir=outdir,
+        output_dir=output_dir,
     )
-    model_module = import_model_module(model_name, outdir)
+    model_module = import_model_module(model_name, output_dir)
     model = model_module.get_model()
 
     return model
 
 
-def import_model_neuron(outdir: Path = None) -> AmiciModel:
+def import_model_neuron(output_dir: Path = None) -> AmiciModel:
     """Python implementation of the neuron model (Hodgkin-Huxley).
 
     ODEs
@@ -253,12 +253,12 @@ def import_model_neuron(outdir: Path = None) -> AmiciModel:
             MeasurementChannel(id_="z1", event_id="event_1", formula="time"),
         ],
         fixed_parameters=constants,
-        output_dir=outdir,
+        output_dir=output_dir,
     )
     return model
 
 
-def import_model_events(outdir: Path = None) -> AmiciModel:
+def import_model_events(output_dir: Path = None) -> AmiciModel:
     """Python implementation of the events model.
 
     ODEs
@@ -330,15 +330,15 @@ def import_model_events(outdir: Path = None) -> AmiciModel:
             MeasurementChannel(id_="z2", event_id="event_2", formula="time"),
         ],
         fixed_parameters=constants,
-        output_dir=outdir,
+        output_dir=output_dir,
     )
     return model
 
 
-def import_model_jakstat(outdir: Path = None) -> AmiciModel:
+def import_model_jakstat(output_dir: Path = None) -> AmiciModel:
     model_name = "model_jakstat_adjoint_py"
-    if outdir is None:
-        outdir = model_name
+    if output_dir is None:
+        output_dir = model_name
 
     # Create basic SBML model without spline
     ant_str = r"""
@@ -436,17 +436,17 @@ def import_model_jakstat(outdir: Path = None) -> AmiciModel:
             ),
         ],
         model_name=model_name,
-        output_dir=outdir,
+        output_dir=output_dir,
     )
-    model_module = import_model_module(model_name, outdir)
+    model_module = import_model_module(model_name, output_dir)
     model = model_module.get_model()
     return model
 
 
-def import_model_nested_events(outdir: Path = None) -> AmiciModel:
+def import_model_nested_events(output_dir: Path = None) -> AmiciModel:
     model_name = "model_nested_events_py"
-    if outdir is None:
-        outdir = model_name
+    if output_dir is None:
+        output_dir = model_name
 
     ant_str = r"""
     model nested_events
@@ -473,17 +473,17 @@ def import_model_nested_events(outdir: Path = None) -> AmiciModel:
             MeasurementChannel(id_="obs_Virus", formula="Virus"),
         ],
         model_name=model_name,
-        output_dir=outdir,
+        output_dir=output_dir,
     )
-    model_module = import_model_module(model_name, outdir)
+    model_module = import_model_module(model_name, output_dir)
     model = model_module.get_model()
     return model
 
 
-def import_model_steadystate(outdir: Path = None) -> AmiciModel:
+def import_model_steadystate(output_dir: Path = None) -> AmiciModel:
     model_name = "model_steadystate_py"
-    if outdir is None:
-        outdir = model_name
+    if output_dir is None:
+        output_dir = model_name
 
     ant_str = r"""
     model model_steadystate
@@ -518,9 +518,9 @@ def import_model_steadystate(outdir: Path = None) -> AmiciModel:
             MeasurementChannel(id_="obs_x3", formula="x3"),
         ],
         model_name=model_name,
-        output_dir=outdir,
+        output_dir=output_dir,
     )
-    model_module = import_model_module(model_name, outdir)
+    model_module = import_model_module(model_name, output_dir)
     model = model_module.get_model()
     return model
 
@@ -533,21 +533,21 @@ def import_test_models():
 
     print(f"Generating test models in {out_root}...")
     print("Importing model_dirac_py...")
-    import_model_dirac(outdir=out_root / "model_dirac_py")
+    import_model_dirac(output_dir=out_root / "model_dirac_py")
     print("Importing model_events_py...")
-    import_model_events(outdir=out_root / "model_events_py")
+    import_model_events(output_dir=out_root / "model_events_py")
     print("Importing model_neuron_py...")
-    import_model_neuron(outdir=out_root / "model_neuron_py")
+    import_model_neuron(output_dir=out_root / "model_neuron_py")
     print("Importing model_calvetti_py...")
-    import_model_calvetti(outdir=out_root / "model_calvetti_py")
+    import_model_calvetti(output_dir=out_root / "model_calvetti_py")
     print("Importing model_robertson_py...")
-    import_model_robertson(outdir=out_root / "model_robertson_py")
+    import_model_robertson(output_dir=out_root / "model_robertson_py")
     print("Importing model_jakstat_adjoint_py...")
-    import_model_jakstat(outdir=out_root / "model_jakstat_adjoint_py")
+    import_model_jakstat(output_dir=out_root / "model_jakstat_adjoint_py")
     print("Importing model_nested_events_py...")
-    import_model_nested_events(outdir=out_root / "model_nested_events_py")
+    import_model_nested_events(output_dir=out_root / "model_nested_events_py")
     print("Importing model_steadystate_py...")
-    import_model_steadystate(outdir=out_root / "model_steadystate_py")
+    import_model_steadystate(output_dir=out_root / "model_steadystate_py")
 
 
 def create_sbml_model(
diff --git a/python/tests/petab_/test_petab_problem.py b/python/tests/petab_/test_petab_problem.py
index 4aa7650042..f7558f9437 100644
--- a/python/tests/petab_/test_petab_problem.py
+++ b/python/tests/petab_/test_petab_problem.py
@@ -76,7 +76,7 @@ def test_amici_petab_problem_pregenerate_equals_on_demand(tempdir):
     independent of the `store_edatas` parameter."""
     # any example is fine
     petab_problem = get_problem("Boehm_JProteomeRes2014")
-    amici_model = import_petab_problem(petab_problem, model_output_dir=tempdir)
+    amici_model = import_petab_problem(petab_problem, output_dir=tempdir)
 
     app_store_true = PetabProblem(
         petab_problem, store_edatas=True, amici_model=amici_model
diff --git a/python/tests/splines_utils.py b/python/tests/splines_utils.py
index a38592036a..0135333c82 100644
--- a/python/tests/splines_utils.py
+++ b/python/tests/splines_utils.py
@@ -416,7 +416,7 @@ def simulate_splines(
         amici_model = import_petab_problem(
             petab_problem,
             discard_sbml_annotations=discard_annotations,
-            model_output_dir=os.path.join(folder, f"amici_models_{model_id}"),
+            output_dir=os.path.join(folder, f"amici_models_{model_id}"),
             model_name=f"splinetest_{model_id}",
         )
 
diff --git a/python/tests/test_compare_conservation_laws_sbml.py b/python/tests/test_compare_conservation_laws_sbml.py
index 5f32caeda1..a062d9ffa5 100644
--- a/python/tests/test_compare_conservation_laws_sbml.py
+++ b/python/tests/test_compare_conservation_laws_sbml.py
@@ -92,8 +92,8 @@ def models():
     )
 
     # Name of the model that will also be the name of the python module
-    model_name = model_output_dir = "model_constant_species"
-    model_name_cl = model_output_dir_cl = "model_constant_species_cl"
+    model_name = output_dir = "model_constant_species"
+    model_name_cl = output_dir_cl = "model_constant_species_cl"
 
     # Define constants, observables, sigmas
     fixed_parameters = ["synthesis_substrate", "init_enzyme"]
@@ -105,13 +105,13 @@ def models():
     # wrap models with and without conservations laws
     sbml_importer.sbml2amici(
         model_name_cl,
-        model_output_dir_cl,
+        output_dir_cl,
         fixed_parameters=fixed_parameters,
         observation_model=observation_model,
     )
     sbml_importer.sbml2amici(
         model_name,
-        model_output_dir,
+        output_dir,
         fixed_parameters=fixed_parameters,
         observation_model=observation_model,
         compute_conservation_laws=False,
diff --git a/python/tests/test_jax.py b/python/tests/test_jax.py
index ae12bcfe9c..2d6e111b2c 100644
--- a/python/tests/test_jax.py
+++ b/python/tests/test_jax.py
@@ -286,7 +286,7 @@ def test_preequilibration_failure(lotka_volterra):  # noqa: F811
     # oscillating system, preequilibation should fail when interaction is active
     with TemporaryDirectoryWinSafe(prefix="normal") as model_dir:
         jax_problem = import_petab_problem(
-            petab_problem, jax=True, model_output_dir=model_dir
+            petab_problem, jax=True, output_dir=model_dir
         )
         r = run_simulations(jax_problem)
         assert not np.isinf(r[0].item())
@@ -295,7 +295,7 @@ def test_preequilibration_failure(lotka_volterra):  # noqa: F811
     )
     with TemporaryDirectoryWinSafe(prefix="failure") as model_dir:
         jax_problem = import_petab_problem(
-            petab_problem, jax=True, model_output_dir=model_dir
+            petab_problem, jax=True, output_dir=model_dir
         )
         r = run_simulations(jax_problem)
         assert np.isinf(r[0].item())
@@ -308,7 +308,7 @@ def test_serialisation(lotka_volterra):  # noqa: F811
         prefix=petab_problem.model.model_id
     ) as model_dir:
         jax_problem = import_petab_problem(
-            petab_problem, jax=True, model_output_dir=model_dir
+            petab_problem, jax=True, output_dir=model_dir
         )
         # change parameters to random values to test serialisation
         jax_problem.update_parameters(
diff --git a/python/tests/test_petab_import.py b/python/tests/test_petab_import.py
index dbd2499263..80add649e9 100644
--- a/python/tests/test_petab_import.py
+++ b/python/tests/test_petab_import.py
@@ -150,7 +150,7 @@ def test_default_output_parameters(simple_sbml_model, tempdir):
         petab_problem=petab_problem,
         output_parameter_defaults={"observableParameter1_obs1": 1.0},
         compile=False,
-        model_output_dir=tempdir,
+        output_dir=tempdir,
     )
     assert (
         1.0
@@ -164,5 +164,5 @@ def test_default_output_parameters(simple_sbml_model, tempdir):
             petab_problem=petab_problem,
             output_parameter_defaults={"nonExistentParameter": 1.0},
             compile=False,
-            model_output_dir=tempdir,
+            output_dir=tempdir,
         )
diff --git a/python/tests/test_petab_simulate.py b/python/tests/test_petab_simulate.py
index 3c352677d9..1597d55a4f 100644
--- a/python/tests/test_petab_simulate.py
+++ b/python/tests/test_petab_simulate.py
@@ -46,22 +46,20 @@ def test_subset_call(petab_problem):
     """
     Test the ability to customize AMICI methods, specifically:
     :py:func:`amici.petab_import.import_petab_problem` (`model_name`,
-    `model_output_dir`, import is skipped if `amici_model` is specified), and
+    `output_dir`, import is skipped if `amici_model` is specified), and
     :py:func:`amici.petab_objective.simulate_petab` (`amici_model`, `solver`).
     """
     model_name = "model_name_dummy"
-    model_output_dir = tempfile.mkdtemp()
+    output_dir = tempfile.mkdtemp()
 
     simulator0 = PetabSimulator(petab_problem)
-    assert not (Path(model_output_dir) / model_name).is_dir()
-    simulator0.simulate(
-        model_name=model_name, model_output_dir=model_output_dir
-    )
+    assert not (Path(output_dir) / model_name).is_dir()
+    simulator0.simulate(model_name=model_name, output_dir=output_dir)
     # Model name is handled correctly
     assert simulator0.amici_model.get_name() == model_name
     # Check model output directory is created, by
     # :py:func:`amici.petab_import.import_petab_problem`
-    assert (Path(model_output_dir) / model_name).is_dir()
+    assert (Path(output_dir) / model_name).is_dir()
 
     simulator = PetabSimulator(petab_problem)
     simulator.simulate(amici_model=simulator0.amici_model)
diff --git a/tests/benchmark_models/conftest.py b/tests/benchmark_models/conftest.py
index f49590622d..f63d989175 100644
--- a/tests/benchmark_models/conftest.py
+++ b/tests/benchmark_models/conftest.py
@@ -31,6 +31,6 @@ def benchmark_problem(request):
 
     amici_model = import_petab_problem(
         flat_petab_problem,
-        model_output_dir=benchmark_outdir / problem_id,
+        output_dir=benchmark_outdir / problem_id,
     )
     return problem_id, flat_petab_problem, petab_problem, amici_model
diff --git a/tests/benchmark_models/test_petab_benchmark.py b/tests/benchmark_models/test_petab_benchmark.py
index a3428ebd93..efcace3e27 100644
--- a/tests/benchmark_models/test_petab_benchmark.py
+++ b/tests/benchmark_models/test_petab_benchmark.py
@@ -431,7 +431,7 @@ def test_benchmark_gradient(
     # Setup AMICI objects.
     amici_model = import_petab_problem(
         petab_problem,
-        model_output_dir=benchmark_outdir / problem_id,
+        output_dir=benchmark_outdir / problem_id,
     )
     amici_solver = amici_model.create_solver()
     amici_solver.set_absolute_tolerance(cur_settings.atol_sim)
@@ -643,7 +643,7 @@ def test_nominal_parameters_llh_v2(problem_id):
         pytest.skip("Excluded from log-likelihood check.")
 
     benchmark_outdir = get_model_root_dir() / "test_bmc_v2"
-    model_output_dir = benchmark_outdir / problem_id
+    output_dir = benchmark_outdir / problem_id
 
     try:
         # Load PEtab v1 problem. This will be upgraded to v2 automatically.
@@ -664,7 +664,7 @@ def test_nominal_parameters_llh_v2(problem_id):
     pi = PetabImporter(
         petab_problem=problem,
         module_name=f"{problem_id}_v2",
-        outdir=model_output_dir,
+        output_dir=output_dir,
         compile_=True,
         jax=jax,
     )
diff --git a/tests/benchmark_models/test_petab_benchmark_jax.py b/tests/benchmark_models/test_petab_benchmark_jax.py
index 61fc26dd2d..2511e65122 100644
--- a/tests/benchmark_models/test_petab_benchmark_jax.py
+++ b/tests/benchmark_models/test_petab_benchmark_jax.py
@@ -89,7 +89,7 @@ def test_jax_llh(benchmark_problem):
 
     jax_problem = import_petab_problem(
         petab_problem,
-        model_output_dir=benchmark_outdir / (problem_id + "_jax"),
+        output_dir=benchmark_outdir / (problem_id + "_jax"),
         jax=True,
     )
     if problem_parameters:
diff --git a/tests/performance/test.py b/tests/performance/test.py
index fb52444c1e..da5b2bd741 100755
--- a/tests/performance/test.py
+++ b/tests/performance/test.py
@@ -86,7 +86,7 @@ def run_import(model_name, model_dir: Path):
     amici.importers.sbml.logger.setLevel(logging.DEBUG)
     import_model_sbml(
         model_name=model_name,
-        model_output_dir=model_dir,
+        output_dir=model_dir,
         petab_problem=pp,
         compile=False,
         verbose=True,
diff --git a/tests/sciml/test_sciml.py b/tests/sciml/test_sciml.py
index d502fd897e..cdeccd630f 100644
--- a/tests/sciml/test_sciml.py
+++ b/tests/sciml/test_sciml.py
@@ -198,7 +198,7 @@ def test_ude(test):
         petab_problem = Problem.from_yaml(petab_yaml)
         jax_problem = import_petab_problem(
             petab_problem,
-            model_output_dir=Path(__file__).parent / "models" / test,
+            output_dir=Path(__file__).parent / "models" / test,
             compile_=True,
             jax=True,
         )