“Requesting incompatible QoS. No messages will be sent to it” in ROS 2: RELIABILITY, DURABILITY, DEADLINE and LIVELINESS mismatches, measured
[WARN] [1793163962.254306106] [qos_pub]: New subscription discovered on topic '/x', requesting incompatible QoS. No messages will be sent to it. Last incompatible policy: RELIABILITY
[WARN] [1793163962.254307173] [qos_sub]: New publisher discovered on topic '/x', offering incompatible QoS. No messages will be received from it. Last incompatible policy: RELIABILITY
The first line is printed by the publisher’s process, the second by the subscriber’s. You see one or both, depending on which terminal you are looking at. The last word can also be DURABILITY, DEADLINE or LIVELINESS.
Short answer: the two endpoints never connected. The subscription asked for more than the publisher offers, so DDS refused to match them, and no message goes across. It isn’t a timing problem and it doesn’t fix itself. The typical case is a sensor driver that publishes with qos_profile_sensor_data (BEST_EFFORT) and a node that subscribes with the default profile or a plain depth of 10 (RELIABLE). Make the subscriber ask for less:
from rclpy.qos import qos_profile_sensor_data
from sensor_msgs.msg import LaserScan
# BEST_EFFORT subscription: matches BEST_EFFORT and RELIABLE publishers
self.sub = self.create_subscription(LaserScan, '/scan', self.on_scan, qos_profile_sensor_data)
A BEST_EFFORT subscription received all 30 messages from a RELIABLE publisher and from a BEST_EFFORT one in my runs, so it is the safe choice when you don’t control the publisher. For the other policies the rule is the same. The subscription must not request a stronger guarantee than the publisher offers.

The compatibility matrix
Each row is a publisher and a subscriber in two separate rclpy processes on topic /x. The publisher waited up to 4 seconds for a matched subscription, then sent 30 std_msgs/Int32 messages at 20 Hz. The reliability and durability rows ran 3 times each on Humble, Jazzy and Lyrical. All 9 runs of each row gave the same count.
| Publisher offers | Subscriber requests | Received (of 30) | Warning |
|---|---|---|---|
| RELIABLE | RELIABLE | 30 | none |
| RELIABLE | BEST_EFFORT | 30 | none |
| BEST_EFFORT | RELIABLE | 0 | both sides, RELIABILITY |
| BEST_EFFORT | BEST_EFFORT | 30 | none |
| VOLATILE | VOLATILE | 30 | none |
| VOLATILE | TRANSIENT_LOCAL | 0 | both sides, DURABILITY |
| TRANSIENT_LOCAL | VOLATILE | 30 | none |
| TRANSIENT_LOCAL | TRANSIENT_LOCAL | 30 | none |
The durability rows used RELIABLE on both sides. The other policies ran once per distro, with the same result on all three:
| Publisher offers | Subscriber requests | Received (of 30) | Last incompatible policy |
|---|---|---|---|
| BEST_EFFORT + VOLATILE | RELIABLE + TRANSIENT_LOCAL | 0 | RELIABILITY only |
| deadline 1.0 s | deadline 0.5 s | 0 | DEADLINE |
| deadline 0.5 s | deadline 1.0 s | 30 | compatible |
| no deadline (default) | deadline 1.0 s | 0 | DEADLINE |
| liveliness AUTOMATIC | liveliness MANUAL_BY_TOPIC | 0 | LIVELINESS |
| liveliness MANUAL_BY_TOPIC | liveliness AUTOMATIC | 30 | compatible |
| lease 2.0 s | lease 1.0 s | 0 | LIVELINESS |
| lease 1.0 s | lease 2.0 s | 30 | compatible |
qos_profile_sensor_data |
RELIABLE, depth 10 | 0 | RELIABILITY |
qos_profile_sensor_data |
BEST_EFFORT, depth 10 | 30 | compatible |
Matching deadline and liveliness only lets the two endpoints connect. How each policy actually reports a sensor topic that stopped publishing is measured in liveliness vs deadline: detecting a stopped sensor topic.
Every incompatible pair printed exactly one warning line in each process, at discovery. The subscriber’s own get_publisher_count() stayed at 0 (Jazzy and Lyrical; Humble’s Subscription has no such method), and the publisher’s get_subscription_count() was 0 before and after sending. When two policies were wrong at once, the message named only one of them. Fixing that one and running again can show you the next.
What I ran
On 2026-10-28 I used the official ros:humble-ros-base, ros:jazzy-ros-base and ros:lyrical-ros-base images with the default RMW (Fast DDS). The containers ran one after another, each with its own ROS_DOMAIN_ID (11, 12, 13), so no other DDS participant could join the test.
The script has a small QoS helper, a publisher (pub.py) and a subscriber (sub.py). Each prints its QoS, the warnings rclpy logs, and its counts. The subscriber starts first and spins for 9 seconds. The CLI tests use a publisher that runs for 50 seconds at 20 Hz, so ros2 topic info -v can see both endpoints while they are alive.
RELIABILITY: the sensor driver case
RELIABLE means the subscription wants lost samples resent. A BEST_EFFORT publisher doesn’t keep anything to resend, so it can’t serve that request. The opposite direction works: a RELIABLE publisher can always send to a subscriber that accepts losses. This is why a camera or lidar driver that uses qos_profile_sensor_data goes silent for a node written as create_subscription(Msg, topic, cb, 10), because the integer is only a queue depth. My “RELIABLE, depth 10” subscriber was QoSProfile(depth=10) with nothing else set, and it printed reliability=RELIABLE. In my run that pair received 0 of 30, and changing only the subscriber to BEST_EFFORT gave 30 of 30.
Change the subscriber when you can. If you change the publisher to RELIABLE instead, every BEST_EFFORT subscriber still works (row 2 of the matrix). But a reliable publisher on a high-rate topic will try to resend, and I didn’t measure the cost of that.
DURABILITY: TRANSIENT_LOCAL on the wrong side
A TRANSIENT_LOCAL subscription asks the publisher to keep old samples for late joiners. A VOLATILE publisher keeps nothing, so that pair failed with Last incompatible policy: DURABILITY. A TRANSIENT_LOCAL publisher with a VOLATILE subscriber connected and delivered all 30 messages. It just doesn’t replay history to that subscriber. The usual mistake is copying a /map or /robot_description style subscription (TRANSIENT_LOCAL) onto a topic whose publisher uses the defaults. What a matched TRANSIENT_LOCAL pair delivers to a late subscriber, and how depth and lifespan limit it, is covered in TRANSIENT_LOCAL late joiners and lifespan, measured. This post only covers whether the pair matches at all.
DEADLINE and LIVELINESS
A deadline is a promise from the publisher to send at least once per period. The subscriber’s requested period must be equal to or longer than the publisher’s. A subscriber asking for 0.5 s from a publisher offering 1.0 s failed, and the reverse worked. A publisher with no deadline set offers an infinite period, so any subscriber that sets a deadline doesn’t match it. That’s the easy one to miss. You add a deadline to your subscriber to detect a stalled sensor, and the result is a subscriber that never receives anything from it.
Liveliness works the same way. MANUAL_BY_TOPIC is stronger than AUTOMATIC, so a subscriber requesting MANUAL_BY_TOPIC from an AUTOMATIC publisher failed, and the reverse worked. For the lease duration, a subscriber requesting 1.0 s from a publisher offering 2.0 s failed, and the reverse worked. Both cases print Last incompatible policy: LIVELINESS.
What ros2 topic echo and hz subscribe with
The CLI tools pick their own QoS, and that’s where “echo works but my node doesn’t” comes from. I ran each command against a BEST_EFFORT publisher and against a RELIABLE + TRANSIENT_LOCAL publisher, and read the subscription’s QoS from ros2 topic info -v while the command was running.
| Command | Distro | vs BEST_EFFORT pub | vs RELIABLE + TRANSIENT_LOCAL pub |
|---|---|---|---|
ros2 topic echo /x |
all three | BEST_EFFORT, VOLATILE, received | RELIABLE, TRANSIENT_LOCAL, received |
echo --qos-reliability reliable |
all three | 0 messages, incompatible warning | received |
echo --qos-profile services_default |
Humble | RELIABLE, VOLATILE: 0 messages, warning | RELIABLE, VOLATILE |
| Jazzy, Lyrical | BEST_EFFORT, VOLATILE, received | RELIABLE, TRANSIENT_LOCAL | |
ros2 topic hz /x |
Humble, Jazzy | BEST_EFFORT, VOLATILE | BEST_EFFORT, VOLATILE |
| Lyrical | BEST_EFFORT, VOLATILE | RELIABLE, TRANSIENT_LOCAL |
So ros2 topic echo with no QoS options matched the publisher on every distro I tested, including Humble. A working echo proves the publisher is sending. It says nothing about your subscriber’s QoS. An echo started before any publisher existed also received all 80 messages from a BEST_EFFORT publisher that started 2 seconds later, on all three distros.
An explicit --qos-reliability reliable is respected on all three, and it reproduces your node’s problem from the terminal:
$ ros2 topic echo --qos-reliability reliable /x std_msgs/msg/Int32
[WARN] [1793164761.860513932] [_ros2cli_1384]: New publisher discovered on topic '/x', offering incompatible QoS. No messages will be received from it. Last incompatible policy: RELIABILITY
The --qos-profile option changed between Humble and Jazzy. On Humble, --qos-profile services_default is used as given, RELIABLE, and against a BEST_EFFORT publisher it printed the warning and nothing else. On Jazzy and Lyrical the same command subscribed BEST_EFFORT and printed data. The help text points at the reason. From Jazzy, --qos-reliability, --qos-durability and --qos-liveliness accept best_available, and --qos-profile lists best_available as well. With a profile given and no explicit reliability, the newer echo still adapted reliability and durability to the publisher. If you want echo to behave like a specific subscriber on Jazzy or newer, set --qos-reliability and --qos-durability explicitly.
ros2 topic hz has no --qos options on Humble and Jazzy. It subscribed BEST_EFFORT and VOLATILE against both publishers. That’s compatible with anything, which is why hz shows a rate on a topic your node can’t receive. On Lyrical, hz has the same --qos-* options as echo and adapted to the publisher. Against the TRANSIENT_LOCAL publisher it subscribed RELIABLE and TRANSIENT_LOCAL, and the stored samples arrived at once. The first window printed average rate: 23.575 with min: 0.000s, where the same publisher measured average rate: 19.328 on Humble. The publisher’s loop is nominally 20 Hz, and every other hz run reported between 19.093 and 19.340. On Lyrical, ignore the first windows of hz on a TRANSIENT_LOCAL topic.
See the mismatch with ros2 topic info -v
The warning names the policy, but not the values. ros2 topic info -v shows both endpoints. This is the BEST_EFFORT publisher and RELIABLE subscriber pair on Humble, with the GID lines and the subscriber’s last four lines removed:
$ ros2 topic info -v /x
Type: std_msgs/msg/Int32
Publisher count: 1
Node name: qos_pub
Node namespace: /
Topic type: std_msgs/msg/Int32
Endpoint type: PUBLISHER
QoS profile:
Reliability: BEST_EFFORT
History (Depth): UNKNOWN
Durability: VOLATILE
Lifespan: Infinite
Deadline: Infinite
Liveliness: AUTOMATIC
Liveliness lease duration: Infinite
Subscription count: 1
Node name: qos_sub
Node namespace: /
Topic type: std_msgs/msg/Int32
Endpoint type: SUBSCRIPTION
QoS profile:
Reliability: RELIABLE
History (Depth): UNKNOWN
Durability: VOLATILE
...
Both endpoints are listed, so discovery worked. The counts don’t tell you whether they matched. Compare the Reliability, Durability, Deadline and Liveliness lines between the PUBLISHER and SUBSCRIPTION blocks, and use the table above. Jazzy and Lyrical add a Topic type hash line. Lyrical prints the real history, KEEP_LAST (10), where Humble and Jazzy print UNKNOWN.
Detect it in code
rclpy logs the warning by default. To act on it, pass an incompatible QoS callback when you create the subscription or publisher:
try:
from rclpy.event_handler import SubscriptionEventCallbacks, PublisherEventCallbacks
except ImportError: # older rclpy
from rclpy.qos_event import SubscriptionEventCallbacks, PublisherEventCallbacks
def on_incompatible(event):
node.get_logger().error(
f'QoS mismatch on /x: total_count={event.total_count} '
f'last_policy_kind={event.last_policy_kind}')
sub = node.create_subscription(
Int32, '/x', cb, qos,
event_callbacks=SubscriptionEventCallbacks(incompatible_qos=on_incompatible))
pub = node.create_publisher(
Int32, '/x', qos,
event_callbacks=PublisherEventCallbacks(incompatible_qos=on_incompatible))
The callback fired once per incompatible peer on both sides, with the same output on all three distros:
SUB EVENT incompatible_qos total_count=1 total_count_change=1 last_policy_kind=rmw_qos_policy_kind_t.RMW_QOS_POLICY_RELIABILITY
PUB EVENT incompatible_qos total_count=1 total_count_change=1 last_policy_kind=rmw_qos_policy_kind_t.RMW_QOS_POLICY_RELIABILITY
For the durability and deadline mismatches it reported RMW_QOS_POLICY_DURABILITY and RMW_QOS_POLICY_DEADLINE. With the callback set, the default [WARN] line wasn’t printed, so log it yourself if you still want it in the console.
Fix it without a rebuild: QoS overrides
If the node opts in, a parameter can change the QoS at startup. I created the subscription with qos_overriding_options=QoSOverridingOptions.with_default_policies() and RELIABLE in code, then started it with:
python3 sub.py ... --ros-args -p "qos_overrides./x.subscription.reliability:=best_effort"
It printed SUB qos reliability=BEST_EFFORT and received 30 of 30 from the BEST_EFFORT publisher. The same node without the parameter stayed RELIABLE, warned, and received 0. This only works for nodes that pass qos_overriding_options. For a node that doesn’t, the parameter has nothing to override.
Version notes
The matrix, the warning texts, the event output and the override behavior were identical on Humble (rclpy 3.3.22, Fast DDS 2.6.12), Jazzy (rclpy 7.1.12, Fast DDS 2.14.7) and Lyrical (rclpy 10.0.11, Fast DDS 3.6.2). The differences were all in the CLI. --qos-profile adapts on Jazzy and Lyrical but not on Humble. ros2 topic hz got --qos-* options and QoS adaptation only on Lyrical. Lyrical’s --qos-profile list also includes rosout_default. One Jazzy ros2 topic echo, started before its publisher, kept running after timeout sent SIGTERM, and I had to kill it with kill -9. It had already printed all 80 messages. I saw this once and didn’t investigate it.
Not tested
rclcpp, other RMWs (Cyclone DDS, Zenoh), nodes on different machines, history (KEEP_ALL) and lifespan compatibility, QoSSubscriptionEventType.SUBSCRIPTION_INCOMPATIBLE_QOS used through a separate event handler API, best_available passed explicitly, ros2 bag record and RViz, launch-file QoS overrides, and Foxy, Iron and Rolling.
FAQ
What does “requesting incompatible QoS. No messages will be sent to it” mean?
The publisher printing it found a subscription that asks for a stronger QoS than it offers, and DDS won’t connect them. No message goes to that subscription. The policy after Last incompatible policy: is the one to fix. In my runs the subscriber printed the matching “offering incompatible QoS” line at the same moment.
Why does ros2 topic echo show data but my subscriber gets nothing?
With no QoS options, ros2 topic echo matched the publisher’s reliability and durability on Humble, Jazzy and Lyrical. Your node uses whatever is in its code, usually RELIABLE. Run ros2 topic echo --qos-reliability reliable to see what your node sees, and subscribe with qos_profile_sensor_data for sensor topics.
Is a BEST_EFFORT subscriber compatible with a RELIABLE publisher?
Yes. It received 30 of 30 on all three distros. Only a RELIABLE subscriber with a BEST_EFFORT publisher fails.
Does a TRANSIENT_LOCAL publisher work with a VOLATILE subscriber?
Yes, it received 30 of 30. The failing pair is a TRANSIENT_LOCAL subscriber with a VOLATILE publisher, which prints Last incompatible policy: DURABILITY.
How do I detect incompatible QoS in Python?
Pass event_callbacks=SubscriptionEventCallbacks(incompatible_qos=cb) to create_subscription, or PublisherEventCallbacks to create_publisher. The callback gets total_count and last_policy_kind, for example RMW_QOS_POLICY_RELIABILITY.
Measured on 2026-10-28 with ros:humble-ros-base (sha256:d9bcf2e6f72d..., rclpy 3.3.22, rmw_fastrtps_cpp 6.2.10, ros2cli 0.18.20), ros:jazzy-ros-base (sha256:8eed0a4669bb..., rclpy 7.1.12, rmw_fastrtps_cpp 8.4.4, ros2cli 0.32.13) and ros:lyrical-ros-base (sha256:3224ee150cb0..., rclpy 10.0.11, rmw_fastrtps_cpp 9.4.10, ros2cli 0.40.9), default RMW (Fast DDS). Full digests are in digests.txt.
Script and raw output: evidence folder. Questions this answers: Getting QoS error on running code, Last incompatible policy: RELIABILITY_QOS_POLICY – Ros2 bag problem, New publisher discovered on topic, offering incompatible QoS, New publisher discovered on topic ‘zed/right/image_rect_color’, offering incompatible QoS, ROS2 Foxy incompatible QoS policies no warnings.