As of January 1, 2020 this library no longer supports Python 2 on the latest released version. Library versions released prior to that date will continue to be available. For more information please visit Python 2 support on Google Cloud.

Publishing Messages

Publishing messages is handled through the Client class (aliased as This class provides methods to create topics, and (most importantly) a publish() method that publishes messages to Pub/Sub.

Instantiating a publishing client is straightforward:

from import pubsub
publish_client = pubsub.PublisherClient()

Publish a Message

To publish a message, use the publish() method. This method accepts two positional arguments: the topic to publish to, and the body of the message. It also accepts arbitrary keyword arguments, which are passed along as attributes of the message.

The topic is passed along as a string; all topics have the canonical form of projects/{project_name}/topics/{topic_name}.

Therefore, a very basic publishing call looks like:

topic = 'projects/{project}/topics/{topic}'
publish_client.publish(topic, b'This is my message.')


The message data in Pub/Sub is an opaque blob of bytes, and as such, you must send a bytes object in Python 3 (str object in Python 2). If you send a text string (str in Python 3, unicode in Python 2), the method will raise TypeError.

The reason it works this way is because there is no reasonable guarantee that the same language or environment is being used by the subscriber, and so it is the responsibility of the publisher to properly encode the payload.

If you want to include attributes, simply add keyword arguments:

topic = 'projects/{project}/topics/{topic}'
publish_client.publish(topic, b'This is my message.', foo='bar')


Whenever you publish a message, the publisher will automatically batch the messages over a small time window to avoid making too many separate requests to the service. This helps increase throughput.


By default, this uses threading, and you will need to be in an environment with threading enabled. It is possible to provide an alternative batch class that uses another concurrency strategy.

The way that this works is that on the first message that you send, a new batch is created automatically. For every subsequent message, if there is already a valid batch that is still accepting messages, then that batch is used. When the batch is created, it begins a countdown that publishes the batch once sufficient time has elapsed (by default, this is 0.05 seconds).

If you need different batching settings, simply provide a BatchSettings object when you instantiate the Client:

from import pubsub
from import types

client = pubsub.PublisherClient(

Pub/Sub accepts a maximum of 1,000 messages in a batch, and the size of a batch can not exceed 10 megabytes.


Every call to publish() returns an instance of Future.


The returned future conforms for the most part to the interface of the standard library’s Future, but might not be usable in all cases which expect that exact implementaton.

You can use this to ensure that the publish succeeded:

# The .result() method will block until the future is complete.
# If there is an error, it will raise an exception.
future = client.publish(topic, b'My awesome message.')
message_id = future.result()

You can also attach a callback to the future:

# Callbacks receive the future as their only argument, as defined in
# the Future interface.
def callback(future):
    message_id = future.result()

# The callback is added once you get the future. If you add a callback
# and the future is already done, it will simply be executed immediately.
future = client.publish(topic, b'My awesome message.')