diff --git a/cirq-ionq/cirq_ionq/job.py b/cirq-ionq/cirq_ionq/job.py
index cad0cc9987e..38fabff5661 100644
--- a/cirq-ionq/cirq_ionq/job.py
+++ b/cirq-ionq/cirq_ionq/job.py
@@ -197,7 +197,12 @@ def results(
         polling_seconds: int = 1,
         sharpen: bool | None = None,
         extra_query_params: dict | None = None,
-    ) -> list[results.QPUResult] | list[results.SimulatorResult]:
+    ) -> (
+        results.QPUResult
+        | results.SimulatorResult
+        | list[results.QPUResult]
+        | list[results.SimulatorResult]
+    ):
         """Polls the IonQ api for results.
 
         Args:
@@ -208,9 +213,10 @@ def results(
             extra_query_params: Specify any parameters to include in the request.
 
         Returns:
-            Either a list of `cirq_ionq.QPUResult` or a list of `cirq_ionq.SimulatorResult`
-            depending on whether the job was running on an actual quantum processor or a
-            simulator.
+            Either a single `cirq_ionq.QPUResult` / `cirq_ionq.SimulatorResult`
+            (for a single-circuit job) or a `list` of such results (for a
+            batch job). The list order for batch jobs corresponds to the
+            order of the input circuits.
 
         Raises:
             IonQUnsuccessfulJob: If the job has failed, been canceled, or deleted.
@@ -218,6 +224,16 @@ def results(
             RuntimeError: If the job reported that it had failed on the server, or
                 the job had an unknown status.
             TimeoutError: If the job timed out at the server.
+
+        Notes:
+            * IonQ returns results in little endian; Cirq presents them in
+            big endian.
+            * If your code previously assumed a list, use:
+                r = job.results()
+                results_list = r if isinstance(r, list) else [r]
+            If your code previously assumed a single result, use:
+                r = job.results()
+                r0 = r[0] if isinstance(r, list) else r
         """
         time_waited_seconds = 0
         while time_waited_seconds < timeout_seconds:
@@ -244,11 +260,10 @@ def results(
             job_id=self.job_id(), sharpen=sharpen, extra_query_params=extra_query_params
         )
 
+        # is this a batch run (dict-of-dicts) or a single circuit?
         some_inner_value = next(iter(backend_results.values()))
-        if isinstance(some_inner_value, dict):
-            histograms = backend_results.values()
-        else:
-            histograms = [backend_results]
+        is_batch = isinstance(some_inner_value, dict)
+        histograms = list(backend_results.values()) if is_batch else [backend_results]
 
         # IonQ returns results in little endian, but
         # Cirq prefers to use big endian, so we convert.
@@ -269,7 +284,11 @@ def results(
                         measurement_dict=self.measurement_dict(circuit_index=circuit_index),
                     )
                 )
-            return big_endian_results_qpu
+            return (
+                big_endian_results_qpu
+                if len(big_endian_results_qpu) > 1
+                else big_endian_results_qpu[0]
+            )
         else:
             big_endian_results_sim: list[results.SimulatorResult] = []
             for circuit_index, histogram in enumerate(histograms):
@@ -285,7 +304,11 @@ def results(
                         repetitions=self.repetitions(),
                     )
                 )
-            return big_endian_results_sim
+            return (
+                big_endian_results_sim
+                if len(big_endian_results_sim) > 1
+                else big_endian_results_sim[0]
+            )
 
     def cancel(self):
         """Cancel the given job.
diff --git a/cirq-ionq/cirq_ionq/job_test.py b/cirq-ionq/cirq_ionq/job_test.py
index 8572769c3a0..ae502f42f5a 100644
--- a/cirq-ionq/cirq_ionq/job_test.py
+++ b/cirq-ionq/cirq_ionq/job_test.py
@@ -99,7 +99,7 @@ def test_job_results_qpu():
         assert "foo" in str(w[0].message)
         assert "bar" in str(w[1].message)
     expected = ionq.QPUResult({0: 600, 1: 400}, 2, {'a': [0, 1]})
-    assert results[0] == expected
+    assert results == expected
 
 
 def test_batch_job_results_qpu():
@@ -148,7 +148,7 @@ def test_job_results_rounding_qpu():
     job = ionq.Job(mock_client, job_dict)
     expected = ionq.QPUResult({0: 3, 1: 4997}, 2, {'a': [0, 1]})
     results = job.results()
-    assert results[0] == expected
+    assert results == expected
 
 
 def test_job_results_failed():
@@ -179,7 +179,7 @@ def test_job_results_qpu_endianness():
     }
     job = ionq.Job(mock_client, job_dict)
     results = job.results()
-    assert results[0] == ionq.QPUResult({0: 600, 2: 400}, 2, measurement_dict={})
+    assert results == ionq.QPUResult({0: 600, 2: 400}, 2, measurement_dict={})
 
 
 def test_batch_job_results_qpu_endianness():
@@ -200,7 +200,7 @@ def test_batch_job_results_qpu_endianness():
     }
     job = ionq.Job(mock_client, job_dict)
     results = job.results()
-    assert results[0] == ionq.QPUResult({0: 600, 2: 400}, 2, measurement_dict={'a': [0, 1]})
+    assert results == ionq.QPUResult({0: 600, 2: 400}, 2, measurement_dict={'a': [0, 1]})
 
 
 def test_job_results_qpu_target_endianness():
@@ -216,7 +216,7 @@ def test_job_results_qpu_target_endianness():
     }
     job = ionq.Job(mock_client, job_dict)
     results = job.results()
-    assert results[0] == ionq.QPUResult({0: 600, 2: 400}, 2, measurement_dict={})
+    assert results == ionq.QPUResult({0: 600, 2: 400}, 2, measurement_dict={})
 
 
 def test_batch_job_results_qpu_target_endianness():
@@ -238,7 +238,7 @@ def test_batch_job_results_qpu_target_endianness():
     }
     job = ionq.Job(mock_client, job_dict)
     results = job.results()
-    assert results[0] == ionq.QPUResult({0: 600, 2: 400}, 2, measurement_dict={'a': [0, 1]})
+    assert results == ionq.QPUResult({0: 600, 2: 400}, 2, measurement_dict={'a': [0, 1]})
 
 
 @mock.patch('time.sleep', return_value=None)
@@ -256,7 +256,7 @@ def test_job_results_poll(mock_sleep):
     mock_client.get_results.return_value = {'0': '0.6', '1': '0.4'}
     job = ionq.Job(mock_client, ready_job)
     results = job.results(polling_seconds=0)
-    assert results[0] == ionq.QPUResult({0: 600, 1: 400}, 1, measurement_dict={})
+    assert results == ionq.QPUResult({0: 600, 1: 400}, 1, measurement_dict={})
     mock_sleep.assert_called_once()
 
 
@@ -294,7 +294,7 @@ def test_job_results_simulator():
     }
     job = ionq.Job(mock_client, job_dict)
     results = job.results()
-    assert results[0] == ionq.SimulatorResult({0: 0.6, 1: 0.4}, 1, {}, 100)
+    assert results == ionq.SimulatorResult({0: 0.6, 1: 0.4}, 1, {}, 100)
 
 
 def test_batch_job_results_simulator():
@@ -336,7 +336,7 @@ def test_job_results_simulator_endianness():
     }
     job = ionq.Job(mock_client, job_dict)
     results = job.results()
-    assert results[0] == ionq.SimulatorResult({0: 0.6, 2: 0.4}, 2, {}, 100)
+    assert results == ionq.SimulatorResult({0: 0.6, 2: 0.4}, 2, {}, 100)
 
 
 def test_batch_job_results_simulator_endianness():
@@ -357,7 +357,7 @@ def test_batch_job_results_simulator_endianness():
     }
     job = ionq.Job(mock_client, job_dict)
     results = job.results()
-    assert results[0] == ionq.SimulatorResult({0: 0.6, 2: 0.4}, 2, {'a': [0, 1]}, 1000)
+    assert results == ionq.SimulatorResult({0: 0.6, 2: 0.4}, 2, {'a': [0, 1]}, 1000)
 
 
 def test_job_sharpen_results():
@@ -372,7 +372,7 @@ def test_job_sharpen_results():
     }
     job = ionq.Job(mock_client, job_dict)
     results = job.results(sharpen=False)
-    assert results[0] == ionq.SimulatorResult({0: 60, 1: 40}, 1, {}, 100)
+    assert results == ionq.SimulatorResult({0: 60, 1: 40}, 1, {}, 100)
 
 
 def test_job_cancel():
diff --git a/cirq-ionq/cirq_ionq/sampler.py b/cirq-ionq/cirq_ionq/sampler.py
index 9799ce3ed30..58527af59dc 100644
--- a/cirq-ionq/cirq_ionq/sampler.py
+++ b/cirq-ionq/cirq_ionq/sampler.py
@@ -15,7 +15,6 @@
 
 from __future__ import annotations
 
-import itertools
 from typing import Sequence, TYPE_CHECKING
 
 import cirq
@@ -90,8 +89,11 @@ def run_sweep(
             repetitions: The number of times to sample.
 
         Returns:
-            Either a list of `cirq_ionq.QPUResult` or a list of `cirq_ionq.SimulatorResult`
-            depending on whether the job was running on an actual quantum processor or a simulator.
+            A list of `cirq.Result` objects, one per parameter resolver in
+            `params`, converted from IonQ results.
+
+        Notes:
+            This method blocks until all jobs in the sweep complete.
         """
         resolvers = [r for r in cirq.to_resolvers(params)]
         jobs = [
@@ -102,11 +104,16 @@ def run_sweep(
             )
             for resolver in resolvers
         ]
+        # collect results
         if self._timeout_seconds is not None:
-            job_results = [job.results(timeout_seconds=self._timeout_seconds) for job in jobs]
+            raw_results = [j.results(timeout_seconds=self._timeout_seconds) for j in jobs]
         else:
-            job_results = [job.results() for job in jobs]
-        flattened_job_results = list(itertools.chain.from_iterable(job_results))
+            raw_results = [j.results() for j in jobs]
+
+        # each element of `raw_results` might be a single result or a list
+        flattened_job_results: list[results.QPUResult | results.SimulatorResult] = []
+        for r in raw_results:
+            flattened_job_results.extend(r if isinstance(r, list) else [r])
         cirq_results = []
         for result, params in zip(flattened_job_results, resolvers):
             if isinstance(result, results.QPUResult):
diff --git a/cirq-ionq/cirq_ionq/service.py b/cirq-ionq/cirq_ionq/service.py
index ed88888e904..a8ba0579726 100644
--- a/cirq-ionq/cirq_ionq/service.py
+++ b/cirq-ionq/cirq_ionq/service.py
@@ -17,6 +17,7 @@
 
 import datetime
 import os
+from collections.abc import Iterable
 from typing import Sequence
 
 import cirq
@@ -142,10 +143,14 @@ def run(
             extra_query_params: Specify any parameters to include in the request.
 
         Returns:
-            A `cirq.Result` for running the circuit.
+            A `cirq.Result` for the circuit.
+
+        Notes:
+            The IonQ backend may return a list of length 1 for single-circuit
+            jobs. Cirq unwraps that to a single result for `Service.run(...)`.
         """
         resolved_circuit = cirq.resolve_parameters(circuit, param_resolver)
-        job_results = self.create_job(
+        job_out = self.create_job(
             circuit=resolved_circuit,
             repetitions=repetitions,
             name=name,
@@ -157,13 +162,19 @@ def run(
             dry_run=dry_run,
             extra_query_params=extra_query_params,
         ).results(sharpen=sharpen)
-        if isinstance(job_results[0], results.QPUResult):
-            return job_results[0].to_cirq_result(params=cirq.ParamResolver(param_resolver))
-        if isinstance(job_results[0], results.SimulatorResult):
-            return job_results[0].to_cirq_result(
-                params=cirq.ParamResolver(param_resolver), seed=seed
-            )
-        raise NotImplementedError(f"Unrecognized job result type '{type(job_results[0])}'.")
+
+        # `create_job()` always submits a single circuit, so the API either gives us:
+        #   - a QPUResult / SimulatorResult, or
+        #   - a list of length-1 (the batch logic in Job.results still wraps it in a list).
+        #   In the latter case we unwrap it here.
+        if isinstance(job_out, list):
+            job_out = job_out[0]
+
+        if isinstance(job_out, results.QPUResult):
+            return job_out.to_cirq_result(params=cirq.ParamResolver(param_resolver))
+        if isinstance(job_out, results.SimulatorResult):
+            return job_out.to_cirq_result(params=cirq.ParamResolver(param_resolver), seed=seed)
+        raise NotImplementedError(f"Unrecognized job result type '{type(job_out)}'.")
 
     def run_batch(
         self,
@@ -215,7 +226,11 @@ def run_batch(
             extra_query_params: Specify any parameters to include in the request.
 
         Returns:
-            A a list of `cirq.Result` for running the circuit.
+            A list of `cirq.Result` objects, one per circuit.
+
+        Notes:
+            The output list preserves the order of the input `circuits`
+            argument, regardless of how the IonQ API orders per-circuit results.
         """
         resolved_circuits = []
         for circuit in circuits:
@@ -233,6 +248,10 @@ def run_batch(
             dry_run=dry_run,
             extra_query_params=extra_query_params,
         ).results(sharpen=sharpen)
+        assert isinstance(job_results, Iterable), (
+            "Expected job results to be iterable, but got type "
+            f"{type(job_results)}. This is a bug in the IonQ API."
+        )
 
         cirq_results = []
         for job_result in job_results:
diff --git a/cirq-ionq/cirq_ionq/service_test.py b/cirq-ionq/cirq_ionq/service_test.py
index ce2957c1801..2dd89b8f767 100644
--- a/cirq-ionq/cirq_ionq/service_test.py
+++ b/cirq-ionq/cirq_ionq/service_test.py
@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import datetime
+import json
 import os
 from unittest import mock
 
@@ -296,3 +297,77 @@ def test_service_remote_host_default():
 def test_service_remote_host_from_env_var_cirq_ionq_precedence():
     service = ionq.Service(api_key='tomyheart')
     assert service.remote_host == 'http://example.com'
+
+
+def test_service_run_unwraps_single_result_list():
+    """`Service.run` should unwrap `[result]` to `result`."""
+    # set up a real Service object (we'll monkey-patch its create_job)
+    service = ionq.Service(remote_host="http://example.com", api_key="key")
+
+    # simple 1-qubit circuit
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.X(q), cirq.measure(q, key="m"))
+
+    # fabricate a QPUResult and wrap it in a list to mimic an erroneous behavior
+    qpu_result = ionq.QPUResult(counts={1: 1}, num_qubits=1, measurement_dict={"m": [0]})
+    mock_job = mock.MagicMock()
+    mock_job.results.return_value = [qpu_result]  # <- list of length-1
+
+    # monkey-patch create_job so Service.run sees our mock_job
+    with mock.patch.object(service, "create_job", return_value=mock_job):
+        out = service.run(circuit=circuit, repetitions=1, target="qpu")
+
+    # expected Cirq result after unwrapping and conversion
+    expected = qpu_result.to_cirq_result(params=cirq.ParamResolver({}))
+
+    assert out == expected
+    mock_job.results.assert_called_once()
+
+
+@pytest.mark.parametrize("target", ["qpu", "simulator"])
+def test_run_batch_preserves_order(target):
+    """``Service.run_batch`` must return results in the same order as the
+    input ``circuits`` list, regardless of how the IonQ API happens to order
+    its per-circuit results.
+    """
+
+    # Service with a fully mocked HTTP client.
+    service = ionq.Service(remote_host="http://example.com", api_key="key")
+    client = mock.MagicMock()
+    service._client = client
+
+    # Three trivial 1-qubit circuits, each measuring under a unique key.
+    keys = ["a", "b", "c"]
+    q = cirq.LineQubit(0)
+    circuits = [cirq.Circuit(cirq.measure(q, key=k)) for k in keys]
+
+    client.create_job.return_value = {"id": "job_id", "status": "ready"}
+
+    client.get_job.return_value = {
+        "id": "job_id",
+        "status": "completed",
+        "backend": target,
+        "qubits": "1",
+        "metadata": {
+            "shots": "1",
+            "measurements": json.dumps([{"measurement0": f"{k}\u001f0"} for k in keys]),
+            "qubit_numbers": json.dumps([1, 1, 1]),
+        },
+    }
+
+    # Intentionally scramble the order returned by the API: b, a, c.
+    client.get_results.return_value = {
+        "res_b": {"0": "1"},
+        "res_a": {"0": "1"},
+        "res_c": {"0": "1"},
+    }
+
+    results = service.run_batch(circuits, repetitions=1, target=target)
+
+    # The order of measurement keys in the results should match the input
+    # circuit order exactly (a, b, c).
+    assert [next(iter(r.measurements)) for r in results] == keys
+
+    # Smoke-test on the mocked client usage.
+    client.create_job.assert_called_once()
+    client.get_results.assert_called_once()
diff --git a/docs/hardware/ionq/jobs.md b/docs/hardware/ionq/jobs.md
index 3e0e6a6b87d..98a80cffad2 100644
--- a/docs/hardware/ionq/jobs.md
+++ b/docs/hardware/ionq/jobs.md
@@ -5,23 +5,25 @@ IonQ simulator.
 
 In this section we assume a `cirq_ionq.Service` object has been instantiated and is
 called `service` and `cirq` and `cirq_ionq` have been imported:
+
 ```python
 import cirq
 import cirq_ionq as ionq
 service = ionq.Service()
 ```
+
 See [IonQ API Service](service.md) for how to set up the service.
 
 ## Running programs
 
-The IonQ API is a service that allows you to send a quantum circuit as a *job*
-to a scheduler server.  This means that you can submit a job to the API, and
+The IonQ API is a service that allows you to send a quantum circuit as a _job_
+to a scheduler server. This means that you can submit a job to the API, and
 then this job is held in a queue before being scheduled to run on the appropriate
-hardware (QPU) or simulator.  Once a job is created (but not necessarily yet run)
+hardware (QPU) or simulator. Once a job is created (but not necessarily yet run)
 on the scheduler, the job is assigned an id and then you can query this
 job via the API. The job has a status on it, which describes what state the job is in
-`running`, `completed`, `failed`, etc.  From a users perspective, this is abstracted
-mostly away in Cirq.  A job can be run in either block modes, or non-blocking mode,
+`running`, `completed`, `failed`, etc. From a users perspective, this is abstracted
+mostly away in Cirq. A job can be run in either block modes, or non-blocking mode,
 as described below.
 
 Here we describe these different methods.
@@ -40,31 +42,34 @@ circuit = cirq.Circuit(
 result = service.run(circuit=circuit, repetitions=100, target='qpu')
 print(result)
 ```
+
 Which results in
+
 ```
 x=0000000000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111
 ```
+
 Looking at these results you should notice something strange. What are the odds
-that the x measurements were all 0s followed by all 1s?  The reason for this
+that the x measurements were all 0s followed by all 1s? The reason for this
 sorting is that the IonQAPI only returns statistics about the results, i.e. what
 count of results were 0 and what count were 1 (or if you are measuring
-multiple qubits the counts of the different outcome bit string outcomes).  In
+multiple qubits the counts of the different outcome bit string outcomes). In
 order to make this compatible with Cirq's notion of `cirq.Result`, these
 are then converted into raw results with the exactly correct number of
 results (in lexical order). In other words, the measurement results are not
 in an order corresponding to the temporal order of the measurements.
 
 When calling run, you will need to include the number of `repetitions` or shots
-for the given circuit.  In addition, if there is no `default_target` set on the
-service, then a `target` needs to be specified.  Currently the supported targets
+for the given circuit. In addition, if there is no `default_target` set on the
+service, then a `target` needs to be specified. Currently the supported targets
 are `qpu` and `simulator`.
 
 ### Via a sampler
 
-Another method to get results from the IonQ API is to use a sampler.  A sampler
+Another method to get results from the IonQ API is to use a sampler. A sampler
 is specifically design to be a lightweight interface for obtaining results
 in a [pandas](https://pandas.pydata.org/) dataframe and is the interface
-used by other classes in Cirq for objects that process data.  Here is a
+used by other classes in Cirq for objects that process data. Here is a
 simple example showing how to get a sampler and use it.
 
 ```python
@@ -81,11 +86,11 @@ print(result)
 ### Via create job
 
 The above two methods, using run and the sampler, both block waiting for
-results.  This can be problematic when the queueing time for the service
-is long.  Instead, it is recommended that you use the job api directly.
+results. This can be problematic when the queueing time for the service
+is long. Instead, it is recommended that you use the job api directly.
 In this pattern, you can first create the job with the quantum circuit you
 wish to run, and the service immediately returns an object that has
-the id of the job.  This job id can be recorded, and at any time in
+the id of the job. This job id can be recorded, and at any time in
 the future you can query for the results of this job.
 
 ```python
@@ -97,19 +102,34 @@ circuit = cirq.Circuit(
 job = service.create_job(circuit=circuit, target='qpu', repetitions=100)
 print(job)
 ```
+
 which shows that the returned object is a `cirq_ionq.Job`:
+
 ```
 cirq_ionq.Job(job_id=93d111c1-0898-48b8-babe-80d182f8ad66)
 ```
 
 One difference between this approach and the run and sampler methods
 is that the returned job object's results are more directly related to the
-return data from the IonQ API.  They are of types `ionq.QPUResult` or
-`ionq.SimulatorResult`.  If you wish to convert these into the
+return data from the IonQ API. They are of types `ionq.QPUResult` or
+`ionq.SimulatorResult`. If you wish to convert these into the
 `cirq.Result` format, you can use `to_cirq_result` on both of these.
 
+**Note - result shape of `Job.results()`:** For jobs created from a **single circuit**,  
+`job.results()` returns a **single** `ionq.QPUResult` or `ionq.SimulatorResult`.  
+For **batch** jobs, it returns a **list** of those results. To write code that
+works with either shape:
+
+```python
+r = job.results()
+results_list = r if isinstance(r, list) else [r]
+```
+
+Each entry can be converted to a `cirq.Result` via `.to_cirq_result(...)`.
+(`Service.run(...)` continues to return a single `cirq.Result`.)
+
 Another useful feature of working with jobs directly is that you can
-directly cancel or delete jobs.  In particular, the `ionq.Job` object
+directly cancel or delete jobs. In particular, the `ionq.Job` object
 returned by `create_job` has `cancel` and `delete` methods.
 
 ## Next steps