> ## 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 Message to Private Topic

> Configure a Hedera Consensus Service topic with a submit key and learn to send messages to a private HCS topic where only authorized signers can publish.

## Summary

In the previous tutorial, "Submit Your First Message," you have learned how to submit a message to a **public topic**. It means anyone can send a message to the topic you created because you didn't set a [Submit Key](/native/consensus/create-topic#private-topic).

When setting a *Submit Key,* your topic becomes a **private topic** because each message needs to be signed by the Submit Key. Therefore, you can control who can submit messages to your topic. Of course, the data is still public, as is all data on a public ledger, but we say the topic is private because the topic is restricted by who can submit messages to it.

***

## Prerequisites

We recommend you complete the "Submit Your First Message" tutorial [here](/native/tutorials/consensus/submit-first-message) to get a basic understanding of the Hedera Consensus Service. This example does not build upon the previous examples.

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

***

## Table of Contents

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

***

## 1. Create a private topic

To create a private topic, you will use [***`setSubmitKey()`***](/native/consensus/create-topic#methods) to set a Submit Key. This key needs to sign all messages someone sends to the topic. A message will be rejected if you don't sign the message or sign with an incorrect key. The cost of creating a private topic is the same as a public topic: [**\$0.01**](/learn/networks/mainnet/fees#consensus-service).

<CodeGroup>
  ```java Java theme={null}
  // Create a new topic
  TransactionResponse txResponse = new TopicCreateTransaction()
     .setSubmitKey(operatorKey.getPublicKey())
     .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()
    .setSubmitKey(operatorKey.publicKey)
    .execute(client);

  // Grab the newly generated topic ID
  const receipt = await txResponse.getReceipt(client);
  console.log(`Your topic ID is: ${receipt.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().
  	SetSubmitKey(operatorKey.PublicKey()).
  	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

The code used to subscribe to a public or private topic doesn't change. Anyone can listen to the messages you send to your private topic. You need to provide the [***`TopicMessageQuery()`***](/native/consensus/get-message) with your topic ID to subscribe to it.

<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}`
      );
    });
  ```

  ```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 a message to your private topic. To do this, you will use [***`TopicMessageSubmitTransaction()`***](/native/consensus/submit-message). However, you need to sign this transaction with your Submit Key. The cost for sending a message to a private topic is the same as a public topic: [**\$0.0001**](/learn/networks/mainnet/fees#consensus-service).

<CodeGroup>
  ```java Java theme={null}
  // Send message to private topic
  TransactionResponse submitMessage = new TopicMessageSubmitTransaction()
        .setTopicId(topicId)
        .setMessage("Submitkey set!")
        .freezeWith(client)
        .sign(operatorKey)
        .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 private topic
  const submitMsgTx = await new TopicMessageSubmitTransaction({
    topicId: topicId,
    message: "Submitkey set!",
  })
    .freezeWith(client)
    .sign(operatorKey);

  const submitMsgTxSubmit = await submitMsgTx.execute(client);

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

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

  ```go Go theme={null}
  // Prepare message to send to private topic
  submitMessageTx, err := hedera.NewTopicMessageSubmitTransaction().
  	SetMessage([]byte("Submitkey set!")).
  	SetTopicID(topicID).
  	FreezeWith(client)

  if err != nil {
  	println(err.Error(), ": error freezing topic message submit transaction")
  	return
  }

  // Sign message with submit key
  submitMessageTx.Sign(operatorKey)

  // Submit message
  submitTxResponse, err := submitMessageTx.Execute(client)
  if err != nil {
  	println(err.Error(), ": error submitting to topic")
  	return
  }

  // Get the receipt of the transaction
  receipt, err := submitTxResponse.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(30 * time.Second)
  ```
</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()
                  .setSubmitKey(operatorKey.getPublicKey())
                  .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 private topic
          TransactionResponse submitMessage = new TopicMessageSubmitTransaction()
                .setTopicId(topicId)
                .setMessage("Submitkey set!")
                .freezeWith(client)
                .sign(operatorKey)
                .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 {
    AccountId,
    PrivateKey,
    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 operatorKeyStr = process.env.OPERATOR_KEY;

  // Parse the private key because we use .publicKey and .sign(...)
  const operatorKey = PrivateKey.fromString(operatorKeyStr);

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

  async function submitPrivateMessage() {
    // create a new topic with a submit key
    const txResponse = await new TopicCreateTransaction()
      .setSubmitKey(operatorKey.publicKey)
      .execute(client);

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

    // give the mirror a moment before subscribing
    await new Promise((resolve) => setTimeout(resolve, 5000));

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

    // send message to private topic
    const submitMsgTx = await new TopicMessageSubmitTransaction({
      topicId,
      message: "Submitkey set!",
    })
      .freezeWith(client)
      .sign(operatorKey);

    const submitMsgTxSubmit = await submitMsgTx.execute(client);
    const getReceipt = await submitMsgTxSubmit.getReceipt(client);

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

  submitPrivateMessage();
  ```
</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().
      	SetSubmitKey(operatorKey.PublicKey()).
      	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")
      	})

          // Prepare message to send to private topic
      submitMessageTx, err := hedera.NewTopicMessageSubmitTransaction().
      	SetMessage([]byte("Submitkey set!")).
      	SetTopicID(topicID).
      	FreezeWith(client)

      if err != nil {
      	println(err.Error(), ": error freezing topic message submit transaction")
      	return
      }

      // Sign message with submit key
      submitMessageTx.Sign(operatorKey)

      // Submit message
      submitTxResponse, err := submitMessageTx.Execute(client)
      if err != nil {
      	println(err.Error(), ": error submitting to topic")
      	return
      }

      // Get the receipt of the transaction
      receipt, err := submitTxResponse.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(30 * time.Second)
      }

  ```
</Accordion>

<Columns cols={2}>
  <Card title="Writer: Michiel, DevRel Engineer" title="Writer: 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>

```
```