> ## Documentation Index
> Fetch the complete documentation index at: https://hedera-0c6e0218-mintlify-bc559771.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Submit Your First Message

> Beginner tutorial that walks you through creating an HCS topic and submitting your first ordered, immutable message using the Hedera Consensus Service.

## Summary

With the Hedera Consensus Service (HCS), you can develop applications like stock markets, audit logs, stablecoins, or new network services that require high throughput and decentralized trust. This is made possible by having direct access to the native speed, security, and fair ordering guarantees of the Hashgraph consensus algorithm, with the full trust of the Hedera ledger.

In short, HCS offers the validity of the order of events and transparency into the history of events without requiring a persistent history of transactions. To achieve this, [Mirror nodes](/learn/core-concepts/mirror-nodes) store all transaction data so you can retrieve it to audit events.

***

## Prerequisites

We recommend you complete the following introduction to get a basic understanding of Hedera transactions. This example does not build upon the previous examples.

1. Get a [Hedera testnet account](/native/tutorials/getting-started/create-fund-account).
2. Set up your environment [here](/native/tutorials/consensus/create-first-topic#prerequisites).

✅ *You can find a full* [*code check*](#code-check) *for this tutorial at the bottom of this page.*

***

## Table of Contents

1. [Create Topic](#id-1.-create-your-first-topic)
2. [Subscribe to Topic](#id-2.-subscribe-to-a-topic)
3. [Submit Message](#id-3.-submit-a-message)
4. [Code Check](#code-check)

***

## 1. Create your first topic

To create your first topic, you will use the ***`TopicCreateTransaction()`***, set its properties, and submit it to the Hedera network. In this tutorial, you will create a **public topic** by not setting any properties on the topic. This means that anyone can send messages to your topic.

If you would like to create a **private topic,** you can optionally set a topic key ([*`setSubmitKey()`*](https://docs.hedera.com/guides/docs/sdks/consensus/create-a-topic#methods)). This means that messages submitted to this topic require the topic key to sign. If the topic key does not sign a message, the message will not be submitted to the topic.

After submitting the transaction to the Hedera network, you can obtain the new topic ID by requesting the receipt. Creating a topic only costs you [**\$0.01**](/learn/networks/mainnet/fees#consensus-service).

<CodeGroup>
  ```java Java theme={null}
  // Create a new topic
  TransactionResponse txResponse = new TopicCreateTransaction()
     .execute(client);

  // Get the receipt
  TransactionReceipt receipt = txResponse.getReceipt(client);

  // Get the topic ID
  TopicId topicId = receipt.topicId;

  // Log the topic ID
  System.out.println("Your topic ID is: " +topicId);

  // Wait 5 seconds between consensus topic creation and subscription creation
  Thread.sleep(5000);
  ```

  ```javascript JavaScript theme={null}
  // Create a new topic
  const txResponse = await new TopicCreateTransaction().execute(client);

  // Grab the newly generated topic ID
  const receipt = await txResponse.getReceipt(client);
  const topicId = receipt.topicId;
  console.log(`Your topic ID is: ${topicId}`);

  // Wait 5 seconds between consensus topic creation and subscription creation
  await new Promise((resolve) => setTimeout(resolve, 5000));
  ```

  ```go Go theme={null}
  // Create a new topic
  transactionResponse, err := hedera.NewTopicCreateTransaction().
  	Execute(client)

  if err != nil {
  	println(err.Error(), ": error creating topic")
  	return
  }

  // Get the topic create transaction receipt
  transactionReceipt, err := transactionResponse.GetReceipt(client)

  if err != nil {
  	println(err.Error(), ": error getting topic create receipt")
  	return
  }

  // Get the topic ID from the transaction receipt
  topicID := *transactionReceipt.TopicID

  //Log the topic ID to the console
  fmt.Printf("topicID: %v\n", topicID)
  ```
</CodeGroup>

***

## 2. Subscribe to a topic

After you create the topic, you will want to subscribe to the topic via a Hedera mirror node. Subscribing to a topic via a Hedera mirror node allows you to receive the stream of messages that are being submitted to it.

<Check>
  The ***Hedera Testnet*** client already establishes a connection to a Hedera
  mirror node. You can set a custom mirror node by calling
  ***`client.SetMirrorNetwork()`***. Please note that you can subscribe to
  Hedera Consensus Service (HCS) topics via [gRPC
  API](https://docs.hedera.com/guides/docs/mirror-node-api/hedera-consensus-service-api-1)
  only. Remember to set the mirror node's host and port accordingly when dealing
  with another mirror node provider.
</Check>

To subscribe to a topic, you will use [***`TopicMessageQuery()`***](/native/consensus/get-message). You will provide it with the topic ID to subscribe to, the Hedera mirror node client information, and the topic message contents to return.

<CodeGroup>
  ```java Java theme={null}
  // Subscribe to the topic
  new TopicMessageQuery()
      .setTopicId(topicId)
      .subscribe(client, resp -> {
              String messageAsString = new String(resp.contents, StandardCharsets.UTF_8);
              System.out.println(resp.consensusTimestamp + " received topic message: " + messageAsString);
      });
  ```

  ```javascript JavaScript theme={null}
  // Subscribe to the topic
  new TopicMessageQuery()
    .setTopicId(topicId)
    .subscribe(client, null, (message) => {
      const messageAsString = Buffer.from(message.contents, "utf8").toString();
      console.log(
        `${message.consensusTimestamp.toDate()} Received: ${messageAsString}`
      );

      // Close client right after the first received message
      client.close();
    });
  ```

  ```go Go theme={null}
  // Subscribe to the topic
  _, err = hedera.NewTopicMessageQuery().
  	SetTopicID(topicID).
  	Subscribe(client, func(message hedera.TopicMessage) {
  		fmt.Println(message.ConsensusTimestamp.String(), "received topic message ", string(message.Contents), "\r")
     	})
  ```
</CodeGroup>

***

## 3. Submit a message

Now you are ready to submit your first message to the topic. To do this, you will use [***`TopicMessageSubmitTransaction()`***](/native/consensus/submit-message). For this transaction, you will provide the topic ID and the message to submit to it. Each message you send to a topic costs you [**\$0.0001**](/learn/networks/mainnet/fees#consensus-service). In other words, you can send 10,000 messages for **\$1**
on the Hedera Network.

<CodeGroup>
  ```java Java theme={null}
  // Send message to the topic
  TransactionResponse submitMessage = new TopicMessageSubmitTransaction()
        .setTopicId(topicId)
        .setMessage("Hello, HCS!")
        .execute(client);

  // Get the receipt of the transaction
   TransactionReceipt receipt2 = submitMessage.getReceipt(client);

  // Prevent the main thread from exiting so the topic message can be returned and printed to the console
  Thread.sleep(30000);
  ```

  ```javascript JavaScript theme={null}
  // Send message to the topic
  const sendResponse = await new TopicMessageSubmitTransaction({
    topicId: topicId,
    message: "Hello, HCS!",
  }).execute(client);

  // Get the receipt of the transaction
  const getReceipt = await sendResponse.getReceipt(client);

  // Get the status of the transaction
  const transactionStatus = getReceipt.status;
  console.log("The message transaction status " + transactionStatus.toString());
  ```

  ```go Go theme={null}
  // Send message to the topic
  submitMessage, err := hedera.NewTopicMessageSubmitTransaction().
  	SetMessage([]byte("Hello, HCS!")).
  	SetTopicID(topicID).
  	Execute(client)

  if err != nil {
  	println(err.Error(), ": error submitting to topic")
  	return
  }

  // Get the receipt of the transaction
  receipt, err := submitMessage.GetReceipt(client)

  // Get the transaction status
  transactionStatus := receipt.Status
  fmt.Println("The message transaction status " + transactionStatus.String())

  // Prevent the program from exiting to display the message from the mirror node to the console
  time.Sleep(30000)
  ```
</CodeGroup>

To conclude: The total cost to create a topic and send a message to it is **\$0.0101.**

***

## Code Check ✅

<Accordion title="Java">
  ```java theme={null}
  import com.hedera.hashgraph.sdk.*;
  import io.github.cdimascio.dotenv.Dotenv;

  import java.nio.charset.StandardCharsets;
  import java.util.concurrent.TimeoutException;

  public class CreateTopicTutorial {
  public static void main(String[] args) throws TimeoutException, PrecheckStatusException, ReceiptStatusException, InterruptedException {

          // Grab your Hedera testnet account ID and private key
          AccountId operatorId = AccountId.fromString(Dotenv.load().get("OPERATOR_ID"));
          PrivateKey operatorKey = PrivateKey.fromString(Dotenv.load().get("OPERATOR_KEY"));

          // Build your Hedera client
          Client client = Client.forTestnet();
          client.setOperator(operatorId, operatorKey);

          // Create a new topic
          TransactionResponse txResponse = new TopicCreateTransaction()
                  .execute(client);

          // Get the receipt
          TransactionReceipt receipt = txResponse.getReceipt(client);

          // Get the topic ID
          TopicId topicId = receipt.topicId;

          // Log the topic ID
          System.out.println("Your topic ID is: " +topicId);

          // Wait 5 seconds between consensus topic creation and subscription creation
          Thread.sleep(5000);

          // Subscribe to the topic
          new TopicMessageQuery()
                  .setTopicId(topicId)
                  .subscribe(client, resp -> {
                      String messageAsString = new String(resp.contents, StandardCharsets.UTF_8);
                      System.out.println(resp.consensusTimestamp + " received topic message: " + messageAsString);
                  });

          // Send message to topic
          TransactionResponse submitMessage = new TopicMessageSubmitTransaction()
                  .setTopicId(topicId)
                  .setMessage("Hello, HCS!")
                  .execute(client);

          // Get the receipt of the transaction
          TransactionReceipt receipt2 = submitMessage.getReceipt(client);

          // Wait before the main thread exits to return the topic message to the console
          Thread.sleep(30000);

      }

  }

  ```
</Accordion>

<Accordion title="JavaScript">
  ```javascript theme={null}
  console.clear();
  import dotenv from "dotenv";
  dotenv.config();

  import {
    Client,
    TopicCreateTransaction,
    TopicMessageQuery,
    TopicMessageSubmitTransaction,
  } from "@hashgraph/sdk";

  // Grab the OPERATOR_ID and OPERATOR_KEY from the .env file
  const operatorId = process.env.OPERATOR_ID;
  const operatorKey = process.env.OPERATOR_KEY;

  // Build Hedera testnet and mirror node client
  const client = Client.forTestnet().setOperator(operatorId, operatorKey);

  async function submitFirstMessage() {
    // Create a new topic
    const txResponse = await new TopicCreateTransaction().execute(client);

    // Grab the newly generated topic ID
    const receipt = await txResponse.getReceipt(client);
    const topicId = receipt.topicId;
    console.log(`Your topic ID is: ${topicId}`);

    // Wait 5 seconds between consensus topic creation and subscription creation
    await new Promise((resolve) => setTimeout(resolve, 5000));

    // Subscribe to the topic
    new TopicMessageQuery()
      .setTopicId(topicId)
      .subscribe(client, null, (message) => {
        const messageAsString = Buffer.from(message.contents, "utf8").toString();
        console.log(
          `${message.consensusTimestamp.toDate()} Received: ${messageAsString}`
        );

        // Close client right after the first received message
        client.close();
      });

    // Send message to topic
    const sendResponse = await new TopicMessageSubmitTransaction({
      topicId: topicId,
      message: "Hello, HCS!",
    }).execute(client);
    const getReceipt = await sendResponse.getReceipt(client);

    // Get the status of the transaction
    const transactionStatus = getReceipt.status;
    console.log(
      "The message transaction status: " + transactionStatus.toString()
    );
  }

  submitFirstMessage();
  ```
</Accordion>

<Accordion title="Go">
  ```go theme={null}
  package main

  import (
  	"fmt"
  	"os"
  	"time"

      hedera "github.com/hiero-ledger/hiero-sdk-go/v2/sdk"
      "github.com/joho/godotenv"

  )

  func main() {

      // Loads the .env file and throws an error if it cannot load the variables from that file corectly
      err := godotenv.Load(".env")
      if err != nil {
      	panic(fmt.Errorf("Unable to load enviroment variables from .env file. Error:n%v\n", err))
      }

      // Grab your testnet account ID and private key from the .env file
      operatorId, err := hedera.AccountIDFromString(os.Getenv("OPERATOR_ID"))
      if err != nil {
      	panic(err)
      }

      operatorKey, err := hedera.PrivateKeyFromString(os.Getenv("OPERATOR_KEY"))
      if err != nil {
      	panic(err)
      }

      // Create your testnet client
      client := hedera.ClientForTestnet()
      client.SetOperator(operatorId, operatorKey)

      // Create a new topic
      transactionResponse, err := hedera.NewTopicCreateTransaction().
      	Execute(client)

      if err != nil {
      	println(err.Error(), ": error creating topic")
      	return
      }

      // Get the topic create transaction receipt
      transactionReceipt, err := transactionResponse.GetReceipt(client)

      if err != nil {
      	println(err.Error(), ": error getting topic create receipt")
      	return
      }

      // Get the topic ID from the transaction receipt
      topicID := *transactionReceipt.TopicID

      // Log the topic ID to the console
      fmt.Printf("topicID: %v\n", topicID)

      // Create the query to subscribe to a topic
      _, err = hedera.NewTopicMessageQuery().
      	SetTopicID(topicID).
      	Subscribe(client, func(message hedera.TopicMessage) {
      		fmt.Println(message.ConsensusTimestamp.String(), "received topic message ", string(message.Contents), "\r")
      	})

          // Submit message to topic
      submitMessage, err := hedera.NewTopicMessageSubmitTransaction().
      	SetMessage([]byte("Hello, HCS!")).
      	SetTopicID(topicID).
      	Execute(client)

      if err != nil {
      	println(err.Error(), ": error submitting to topic")
      	return
      }

          // Get the transaction receipt
      receipt, err := submitMessage.GetReceipt(client)

          // Log the transaction status
      transactionStatus := receipt.Status
      fmt.Println("The transaction message status " + transactionStatus.String())

          // Prevent the program from exiting to display the message from the mirror to the console
      time.Sleep(30 * time.Second)
      }

  ```
</Accordion>

<Columns cols={2}>
  <Card title="Writer: Simi, Sr. Software Manager" title="Writer: Simi, Sr. Software Manager" arrow>
    [GitHub](https://github.com/ed-marquez) | [LinkedIn](https://www.linkedin.com/in/shunjan)
    [GitHub](https://github.com/ed-marquez) | [LinkedIn](https://www.linkedin.com/in/shunjan)
  </Card>

  <Card title="Editor: Michiel, DevRel Engineer" title="Editor: Michiel, DevRel Engineer" arrow>
    [GitHub](https://github.com/michielmulders) | [LinkedIn](https://www.linkedin.com/in/michielmulders/)
    [GitHub](https://github.com/michielmulders) | [LinkedIn](https://www.linkedin.com/in/michielmulders/)
  </Card>

  <Card title="Editor: Krystal, Senior DX Engineer" title="Editor: Krystal, Senior DX Engineer" arrow>
    [GitHub](https://github.com/theekrystallee) | [X](https://x.com/theekrystallee)
    [GitHub](https://github.com/theekrystallee) | [X](https://x.com/theekrystallee)
  </Card>
</Columns>

```
```