diff --git a/examples/publish/basic-1.c b/examples/publish/basic-1.c
index a330db1d..f2ad98a0 100644
--- a/examples/publish/basic-1.c
+++ b/examples/publish/basic-1.c
@@ -17,6 +17,12 @@ void on_connect(struct mosquitto *mosq, void *obj, int reason_code)
 	 * clients is mosquitto_reason_string().
 	 */
 	printf("on_connect: %s\n", mosquitto_connack_string(reason_code));
+	if(reason_code != 0){
+		/* If the connection fails for any reason, we don't want to keep on
+		 * retrying in this example, so disconnect. Without this, the client
+		 * will attempt to reconnect. */
+		mosquitto_disconnect(mosq);
+	}
 
 	/* You may wish to set a flag here to indicate to your application that the
 	 * client is now connected. */
diff --git a/examples/subscribe/basic-1.c b/examples/subscribe/basic-1.c
new file mode 100644
index 00000000..613e29b8
--- /dev/null
+++ b/examples/subscribe/basic-1.c
@@ -0,0 +1,119 @@
+/*
+ * This example shows how to write a client that subscribes to a topic and does
+ * not do anything other than handle the messages that are received.
+ */
+
+#include <mosquitto.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+
+/* Callback called when the client receives a CONNACK message from the broker. */
+void on_connect(struct mosquitto *mosq, void *obj, int reason_code)
+{
+	int rc;
+	/* Print out the connection result. mosquitto_connack_string() produces an
+	 * appropriate string for MQTT v3.x clients, the equivalent for MQTT v5.0
+	 * clients is mosquitto_reason_string().
+	 */
+	printf("on_connect: %s\n", mosquitto_connack_string(reason_code));
+	if(reason_code != 0){
+		/* If the connection fails for any reason, we don't want to keep on
+		 * retrying in this example, so disconnect. Without this, the client
+		 * will attempt to reconnect. */
+		mosquitto_disconnect(mosq);
+	}
+
+	/* Making subscriptions in the on_connect() callback means that if the
+	 * connection drops and is automatically resumed by the client, then the
+	 * subscriptions will be recreated when the client reconnects. */
+	rc = mosquitto_subscribe(mosq, NULL, "example/temperature", 1);
+	if(rc != MOSQ_ERR_SUCCESS){
+		fprintf(stderr, "Error subscribing: %s\n", mosquitto_strerror(rc));
+		/* We might as well disconnect if we were unable to subscribe */
+		mosquitto_disconnect(mosq);
+	}
+}
+
+
+/* Callback called when the broker sends a SUBACK in response to a SUBSCRIBE. */
+void on_subscribe(struct mosquitto *mosq, void *obj, int mid, int qos_count, const int *granted_qos)
+{
+	int i;
+	bool have_subscription = false;
+
+	/* In this example we only subscribe to a single topic at once, but a
+	 * SUBSCRIBE can contain many topics at once, so this is one way to check
+	 * them all. */
+	for(i=0; i<qos_count; i++){
+		printf("on_subscribe: %d:granted qos = %d\n", i, granted_qos[i]);
+		if(granted_qos[i] <= 2){
+			have_subscription = true;
+		}
+	}
+	if(have_subscription == false){
+		/* The broker rejected all of our subscriptions, we know we only sent
+		 * the one SUBSCRIBE, so there is no point remaining connected. */
+		fprintf(stderr, "Error: All subscriptions rejected.\n");
+		mosquitto_disconnect(mosq);
+	}
+}
+
+
+/* Callback called when the client receives a message. */
+void on_message(struct mosquitto *mosq, void *obj, const struct mosquitto_message *msg)
+{
+	/* This blindly prints the payload, but the payload can be anything so take care. */
+	printf("%s %d %s\n", msg->topic, msg->qos, (char *)msg->payload);
+}
+
+
+int main(int argc, char *argv[])
+{
+	struct mosquitto *mosq;
+	int rc;
+
+	/* Required before calling other mosquitto functions */
+	mosquitto_lib_init();
+
+	/* Create a new client instance.
+	 * id = NULL -> ask the broker to generate a client id for us
+	 * clean session = true -> the broker should remove old sessions when we connect
+	 * obj = NULL -> we aren't passing any of our private data for callbacks
+	 */
+	mosq = mosquitto_new(NULL, true, NULL);
+	if(mosq == NULL){
+		fprintf(stderr, "Error: Out of memory.\n");
+		return 1;
+	}
+
+	/* Configure callbacks. This should be done before connecting ideally. */
+	mosquitto_connect_callback_set(mosq, on_connect);
+	mosquitto_subscribe_callback_set(mosq, on_subscribe);
+	mosquitto_message_callback_set(mosq, on_message);
+
+	/* Connect to test.mosquitto.org on port 1883, with a keepalive of 60 seconds.
+	 * This call makes the socket connection only, it does not complete the MQTT
+	 * CONNECT/CONNACK flow, you should use mosquitto_loop_start() or
+	 * mosquitto_loop_forever() for processing net traffic. */
+	rc = mosquitto_connect(mosq, "test.mosquitto.org", 1883, 60);
+	if(rc != MOSQ_ERR_SUCCESS){
+		mosquitto_destroy(mosq);
+		fprintf(stderr, "Error: %s\n", mosquitto_strerror(rc));
+		return 1;
+	}
+
+	/* Run the network loop in a blocking call. The only thing we do in this
+	 * example is to print incoming messages, so a blocking call here is fine.
+	 *
+	 * This call will continue forever, carrying automatic reconnections if
+	 * necessary, until the user calls mosquitto_disconnect().
+	 */
+	mosquitto_loop_forever(mosq, -1, 1);
+
+	mosquitto_lib_cleanup();
+	return 0;
+}
+