diff --git a/defs.bzl b/defs.bzl
index b361b13c..387f0994 100644
--- a/defs.bzl
+++ b/defs.bzl
@@ -50,6 +50,12 @@ load(
     _platforms_transition = "platforms_transition",
 )
 
+# Store rule, for uploading results to a CodeChecker server
+load(
+    "//src:store.bzl",
+    _store = "store",
+)
+
 codechecker_test = _codechecker_test
 codechecker_suite = _codechecker_suite
 codechecker_config = _codechecker_config
@@ -57,6 +63,7 @@ codechecker_toolchain = _codechecker_toolchain
 compile_commands = _compile_commands
 clang_tidy_test = _clang_tidy_test
 clang_analyze_test = _clang_analyze_test
+codechecker_store = _store
 
 # Helper for the platform suffix codechecker_suite() adds to its test names
 get_platform_alias = _get_platform_alias
diff --git a/docs/codechecker.md b/docs/codechecker.md
index 7f4edaa4..57b8c566 100644
--- a/docs/codechecker.md
+++ b/docs/codechecker.md
@@ -78,17 +78,18 @@ bazel test ...
 ### Analysis results
 
 You can find the analysis results in the `bazel-bin/` folder, on which you
-can run [`CodeChecker store`](https://github.com/Ericsson/codechecker/blob/master/docs/web/user_guide.md#store)
-or [`CodeChecker parse`](https://github.com/Ericsson/codechecker/blob/master/docs/analyzer/user_guide.md#parse).
+can run [`CodeChecker parse`](https://github.com/Ericsson/codechecker/blob/master/docs/analyzer/user_guide.md#parse).
 The precise output path to the directory can vary,
 but you should look for `your_codechecker_rule_name/codechecker-files/data`.
-In simpler cases, something like the following:
 
 ```bash
 CodeChecker parse bazel-bin/your_codechecker_rule_name/codechecker-files/data
-CodeChecker store bazel-bin/your_codechecker_rule_name/codechecker-files/data -n "Run name"
 ```
 
+To upload results to a CodeChecker server, use the [`codechecker_store()`](store#store)
+rule instead of calling `CodeChecker store` manually. See [Store](store) for
+details.
+
 <!-- For now, we consider codechecker() to be an internal rule.
 
 ### Build-only CodeChecker analysis: `codechecker()`
diff --git a/docs/public-api.md b/docs/public-api.md
index cf112697..bd9b5f7e 100644
--- a/docs/public-api.md
+++ b/docs/public-api.md
@@ -20,6 +20,7 @@ load("@rules_codechecker//:defs.bzl", "codechecker_test")
 | [`clang_tidy_test()`](clang#clang_tidy_test) | run clang-tidy without CodeChecker |
 | [`clang_analyze_test()`](clang#clang_analyze_test) | run the Clang Static Analyzer without CodeChecker |
 | [`compile_commands()`](compile-commands#compile_commands) | generate `compile_commands.json` |
+| [`codechecker_store()`](store#store) | upload analysis results to a CodeChecker server |
 | [`codechecker_toolchain()`](toolchains#providing-your-own-tools) | provide your own tools |
 
 
diff --git a/docs/sidebar.md b/docs/sidebar.md
index 64b1c710..1a38b81e 100644
--- a/docs/sidebar.md
+++ b/docs/sidebar.md
@@ -9,5 +9,6 @@
 
 - **Rules**
   - [CodeChecker](codechecker)
+  - [Store](store)
   - [Clang](clang)
   - [Compilation Database](compile-commands)
diff --git a/docs/store.md b/docs/store.md
new file mode 100644
index 00000000..f1c5659f
--- /dev/null
+++ b/docs/store.md
@@ -0,0 +1,77 @@
+Store
+=====
+
+## store()
+
+The Bazel rule `store()` uploads CodeChecker analysis results to a remote
+[CodeChecker server](https://codechecker.readthedocs.io/en/latest/web/user_guide/).
+It collects the analysis output from one or more `codechecker_test()` targets
+and runs
+[`CodeChecker store`](https://github.com/Ericsson/codechecker/blob/master/docs/web/user_guide.md#store)
+under the hood.
+
+To use it, add the following to your BUILD file:
+
+```python
+load(
+    "@rules_codechecker//:defs.bzl",
+    "codechecker_test",
+    "codechecker_store",
+)
+```
+
+Create a `codechecker_test()` target and a `codechecker_store()` target that references it:
+
+```python
+codechecker_test(
+    name = "codechecker",
+    targets = [
+        "your_target",
+    ],
+)
+
+codechecker_store(
+    name = "store",
+    targets = [
+        ":codechecker",
+    ],
+)
+```
+
+Then run it, passing the server URL and a run name:
+
+```bash
+bazel run //:store -- --url=http://localhost:8001/Default --name=my_run
+```
+
+### Parameters
+
+| Parameter   | Description                                                                 |
+|-------------|-----------------------------------------------------------------------------|
+| `name`      | Name of the store target.                                                   |
+| `targets`   | List of `codechecker_test()` targets whose results should be stored. |
+| `toolchain` | Optional `codechecker_toolchain()` target. When set, tools from this target are used instead of Bazel's toolchain resolution. |
+| `tags`      | Bazel tags. The `"store"` tag is added automatically.                       |
+
+### Runtime arguments
+
+The `--url` and `--name` arguments are required and passed after `--` on the
+command line:
+
+| Argument | Description                                                        |
+|----------|--------------------------------------------------------------------|
+| `--url`  | URL of the CodeChecker server product, e.g. `http://localhost:8001/Default`. |
+| `--name` | Name of the analysis run on the server.                            |
+
+
+### How it works
+
+1. `codechecker_test()` exposes its analysis output via an output group.
+2. `codechecker_store()` collects those files from all its target dependencies.
+3. The report data is symlinked to a writable temporary directory (Bazel outputs
+   are read-only and `CodeChecker store` needs write access).
+4. `CodeChecker store` is executed against the specified server.
+
+> [!NOTE]
+> The `codechecker_store()` rule is an executable rule (`bazel run`), not a test rule.
+> It is meant to be run manually when you want to publish results.
diff --git a/src/BUILD b/src/BUILD
index a43a5b3f..cb914887 100644
--- a/src/BUILD
+++ b/src/BUILD
@@ -32,6 +32,12 @@ py_binary(
     visibility = ["//visibility:public"],
 )
 
+py_binary(
+    name = "store_script",
+    srcs = ["store_script.py"],
+    visibility = ["//visibility:public"],
+)
+
 # The following are flags and default values for clang_tidy_aspect
 filegroup(
     name = "clang_tidy_config_default",
diff --git a/src/codechecker.bzl b/src/codechecker.bzl
index 5c3e8c90..ab677a79 100644
--- a/src/codechecker.bzl
+++ b/src/codechecker.bzl
@@ -279,6 +279,9 @@ def _codechecker_test_impl(ctx):
             runfiles = all_runfiles,
             executable = launcher,
         ),
+        OutputGroupInfo(
+            codechecker_files = depset([codechecker_files]),
+        ),
     ]
 
 _codechecker_test = rule(
diff --git a/src/per_file.bzl b/src/per_file.bzl
index 57dd2efe..08f19ba4 100644
--- a/src/per_file.bzl
+++ b/src/per_file.bzl
@@ -254,6 +254,9 @@ def _per_file_impl(ctx):
             runfiles = ctx.runfiles(files = run_files),
             executable = ctx.outputs.test_script,
         ),
+        OutputGroupInfo(
+            codechecker_files = files,
+        ),
     ]
 
 per_file_test = rule(
diff --git a/src/store.bzl b/src/store.bzl
new file mode 100644
index 00000000..dba203db
--- /dev/null
+++ b/src/store.bzl
@@ -0,0 +1,149 @@
+# Copyright 2026 Ericsson AB
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Rule for storing CodeChecker analysis results on a remote server.
+
+Usage:
+    bazel run :my_store -- --url=http://localhost:8001/Default --name=my_run
+"""
+
+def _store_impl(ctx):
+    # Resolve CodeChecker from the toolchain
+    if ctx.attr.toolchain:
+        info = ctx.attr.toolchain[platform_common.ToolchainInfo].codecheckerinfo
+    else:
+        info = ctx.toolchains["//:toolchain_type"].codecheckerinfo
+
+    # Collect codechecker_files entries from targets.
+    #
+    # Each entry is passed to the store script via --files. Entries may
+    # be either:
+    #   * a directory (monolithic codechecker_test): report data lives
+    #     in a "data" subdirectory inside it, and
+    #   * individual report files (per_file_test): plists/logs that
+    #     already live directly under the target's "data" directory.
+    # The store script inspects each --files entry at runtime and
+    # handles directories and individual files accordingly.
+    codechecker_files_entries = []
+    for target in ctx.attr.targets:
+        if OutputGroupInfo in target:
+            files = target[OutputGroupInfo].codechecker_files.to_list()
+            codechecker_files_entries.extend(files)
+
+    if not codechecker_files_entries:
+        fail("No codechecker_files found in targets. " +
+             "Make sure targets are codechecker_test or " +
+             "per_file_test rules.")
+
+    store_script = ctx.attr._store_script[DefaultInfo].files_to_run
+
+    # Build --files arguments for each codechecker_files entry
+    files_args = " ".join([
+        "--files='{}'".format(d.short_path)
+        for d in codechecker_files_entries
+    ])
+
+    # Generate the launcher shell script
+    launcher = ctx.actions.declare_file(
+        ctx.label.name + "_launcher.sh",
+    )
+    ctx.actions.write(
+        output = launcher,
+        content = """#!/bin/bash
+exec {script} \
+    --codechecker_path '{codechecker}' \
+    {files_args} \
+    "$@"
+""".format(
+            script = store_script.executable.short_path,
+            codechecker = info.codechecker.short_path,
+            files_args = files_args,
+        ),
+        is_executable = True,
+    )
+
+    run_files = (
+        codechecker_files_entries +
+        [launcher] +
+        info.runfiles.to_list()
+    )
+    all_runfiles = ctx.runfiles(files = run_files)
+    all_runfiles = all_runfiles.merge(
+        ctx.attr._store_script[DefaultInfo].default_runfiles,
+    )
+
+    return [
+        DefaultInfo(
+            executable = launcher,
+            runfiles = all_runfiles,
+        ),
+    ]
+
+_store = rule(
+    implementation = _store_impl,
+    attrs = {
+        "targets": attr.label_list(
+            doc = "List of codechecker_test targets " +
+                  "whose results should be stored.",
+        ),
+        "toolchain": attr.label(
+            default = None,
+            doc = "Optional toolchain() target. " +
+                  "When set, tools from this target are used " +
+                  "instead of Bazel's toolchain resolution.",
+        ),
+        "_store_script": attr.label(
+            allow_files = True,
+            executable = True,
+            cfg = "target",
+            default = ":store_script",
+        ),
+    },
+    executable = True,
+    toolchains = ["//:toolchain_type"],
+)
+
+def store(
+        name,
+        targets,
+        toolchain = None,
+        tags = [],
+        **kwargs):
+    """
+    Macro to create a CodeChecker store target.
+
+    Run with:
+        bazel run :<name> -- --url=<server_url> --name=<run_name>
+
+    Args:
+        name: Name of the store target.
+        targets: List of codechecker_test targets whose
+                 results should be stored.
+        toolchain: Optional toolchain() target.
+        tags: Bazel tags.
+        **kwargs: Other miscellaneous arguments.
+    """
+    store_tags = [] + tags
+    if "store" not in tags:
+        store_tags.append("store")
+    _store(
+        name = name,
+        targets = targets,
+        toolchain = toolchain,
+        tags = store_tags,
+        # Needed to be able to depend on test targets.
+        testonly = True,
+        **kwargs
+    )
diff --git a/src/store_script.py b/src/store_script.py
new file mode 100644
index 00000000..bf1aa162
--- /dev/null
+++ b/src/store_script.py
@@ -0,0 +1,185 @@
+# Copyright 2026 Ericsson AB
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+"""
+CodeChecker store wrapper script.
+
+Uploads CodeChecker analysis results to a remote server.
+Symlinks report data to a writable temporary directory first,
+because we need all analysis data in the same place.
+Also Bazel output directories are read-only and
+CodeChecker store needs to create temporary files inside
+the report directory.
+"""
+
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+
+def parse_args(argv=None):
+    """Parse command-line arguments.
+
+    Returns a `(args, passthrough)` tuple where `args` holds the
+    arguments consumed by this wrapper (`--codechecker_path` and
+    `--files`) and `passthrough` is the list of arguments
+    provided by the user as "real" command line argument.
+    """
+    parser = argparse.ArgumentParser(
+        description="CodeChecker store wrapper"
+    )
+    parser.add_argument(
+        "--codechecker_path",
+        required=True,
+        help="Path to the CodeChecker executable",
+    )
+    parser.add_argument(
+        "--files",
+        required=True,
+        action="append",
+        help=(
+            "Path to a codechecker-files entry (may be repeated for "
+            "multiple targets). Each entry is either a directory "
+            "containing a 'data' subdirectory (monolithic "
+            "codechecker_test) or an individual report file such as a "
+            ".plist (per_file_test)."
+        ),
+    )
+    args, passthrough = parser.parse_known_args(argv)
+    return args, passthrough
+
+
+def _symlink_tree(src_dir, dst_dir):
+    """
+    Recreate the directory tree of `src_dir` under `dst_dir`,
+    creating real (writable) directories but symlinking each
+    leaf file back to its original location.
+
+    This gives CodeChecker store a writable top-level directory
+    while avoiding a byte-for-byte copy of the (potentially large)
+    report files, which live read-only in the Bazel output tree.
+    """
+    os.makedirs(dst_dir, exist_ok=True)
+    for entry in os.listdir(src_dir):
+        src = os.path.join(src_dir, entry)
+        dst = os.path.join(dst_dir, entry)
+        if os.path.isdir(src):
+            _symlink_tree(src, dst)
+        else:
+            # Symlink to the absolute source so it resolves
+            # regardless of the current working directory.
+            if os.path.lexists(dst):
+                os.remove(dst)
+            os.symlink(os.path.realpath(src), dst)
+
+
+def copy_data_to_tmpdir(codechecker_files_entries):
+    """
+    Build a single writable temporary directory that mirrors the
+    report data from each codechecker-files entry.
+
+    Directories are created as real, writable directories and the
+    report files are symlinked in.
+
+    Each entry is one of:
+      * A directory (monolithic codechecker_test): its "data"
+        subdirectory holds the report files, which are mirrored in.
+      * An individual report file (per_file_test): plists, logs and
+        metadata that already live directly under a "data" directory.
+        These are symlinked in directly.
+
+    Returns the path to the temporary directory containing
+    the merged report files.
+    """
+    tmpdir = tempfile.mkdtemp(prefix="cc_store_")
+    for entry in codechecker_files_entries:
+        if os.path.isdir(entry):
+            # Monolithic target: reports live in "<entry>/data".
+            data_dir = os.path.join(entry, "data")
+            if not os.path.isdir(data_dir):
+                print(
+                    f"WARNING: {data_dir} does not exist, "
+                    "skipping.",
+                    file=sys.stderr,
+                )
+                continue
+            _symlink_tree(data_dir, tmpdir)
+        elif os.path.isfile(entry):
+            # per_file target: an individual report file. Only .plist
+            # report files belong in the store directory.
+            if not entry.endswith(".plist"):
+                continue
+            dst = os.path.join(tmpdir, os.path.basename(entry))
+            if os.path.lexists(dst):
+                os.remove(dst)
+            os.symlink(os.path.realpath(entry), dst)
+        else:
+            print(
+                f"WARNING: {entry} does not exist, skipping.",
+                file=sys.stderr,
+            )
+    return tmpdir
+
+
+def run_store(codechecker_path, tmpdir, store_args):
+    """
+    Execute CodeChecker store on the temporary directory.
+
+    `store_args` is the list of extra arguments given by the user to
+    `CodeChecker store` (e.g. --url, --name/-n, --trim-path-prefix).
+    Returns the process exit code.
+    """
+    cmd = [
+        codechecker_path,
+        "store",
+        tmpdir,
+        *store_args,
+    ]
+    print(f"Running: {' '.join(cmd)}")
+    result = subprocess.run(
+        cmd,
+        capture_output=False,
+        check=False,
+    )
+    return result.returncode
+
+
+def main():
+    """Main entry point."""
+    args, passthrough = parse_args()
+
+    codechecker = os.path.realpath(args.codechecker_path)
+    if not os.path.isfile(codechecker):
+        print(
+            f"ERROR: CodeChecker not found: {codechecker}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # Copy report data to a writable location
+    tmpdir = copy_data_to_tmpdir(args.files)
+
+    try:
+        ret = run_store(codechecker, tmpdir, passthrough)
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+
+    sys.exit(ret)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/test/unit/parse/BUILD b/test/unit/parse/BUILD
index 2e963862..dd38c60e 100644
--- a/test/unit/parse/BUILD
+++ b/test/unit/parse/BUILD
@@ -19,6 +19,7 @@ load(
 )
 load(
     "//:defs.bzl",
+    "codechecker_store",
     "codechecker_test",
 )
 
@@ -35,3 +36,34 @@ codechecker_test(
         "c_target",
     ],
 )
+
+codechecker_test(
+    name = "per_file",
+    per_file = True,
+    tags = ["manual"],
+    targets = [
+        "c_target",
+    ],
+)
+
+codechecker_store(
+    name = "store_mono",
+    targets = [
+        ":codechecker",
+    ],
+)
+
+codechecker_store(
+    name = "store_per_file",
+    targets = [
+        ":per_file",
+    ],
+)
+
+codechecker_store(
+    name = "store_mixed",
+    targets = [
+        ":codechecker",
+        ":per_file",
+    ],
+)