In the previous article,

1. Install and Verify the Google Cloud CLI

Before interacting with Google’s conversational agents through an API endpoint, make sure the Google Cloud CLI is installed on your machine. This command‑line tool handles authentication, configuration, and service management, so it’s essential for the steps that follow.

Once installed, confirm that it’s working by checking the version:

gcloud --version

In my setup, I’ve created a shorter alias to reduce typing during development. If you notice commands in this guide that look slightly different from the standard gcloud syntax, that’s why. You can stick with the full command or create your own alias if you prefer a more streamlined workflow.

Figure 1 - Verify the Google Cloud CLI

2. List Your Available Google Cloud Projects

With the CLI ready, the next step is to confirm which Google Cloud projects are accessible under your account. This helps you verify that you’re working in the correct environment before making any API calls.

Run the following command:

gcloud projects list

This will return a table of all projects linked to your account, including their project IDs — and the project ID is what you’ll need when making programmatic requests. If you’re using an alias like I am, your command may look slightly different, but the output will be the same.

3. Set Your Active Project and Authenticate

Before making any API calls, you need to tell the Google Cloud CLI which project you intend to work with. This ensures every command and request is scoped to the correct environment.

gcloud config set project <project-id>

After that, authenticate your user account so the CLI can generate the credentials required for API access:

gcloud auth login

This will open a browser window prompting you to sign in. Once authenticated, the CLI stores your credentials locally and you’re ready to interact with Google’s conversational agents programmatically.

4. Create and Verify a Service Account

To allow programmatic access to your conversational agent, you’ll need a dedicated service account. This account will later be assigned the appropriate roles and used to generate credentials for API calls.

gcloud iam service-accounts create my-agent-cxa \
  --display-name="NAME ACCORDINGLY"

Once created, verify that it exists within your project:

gcloud iam service-accounts list --project=<project-id>

You should see my-agent-cxa listed in the output.

5. Generate a Service Account Key and (Optionally) Test Authentication

With your service account created, the next step is to generate a key file. This key will later be used by your application to authenticate programmatic requests to Google’s conversational agent API.

gcloud iam service-accounts keys create service-account.json \
  --iam-account=my-agent-cxa@project-id.iam.gserviceaccount.com

This command downloads a JSON key file named service-account.json to your current directory. Keep this file secure — it grants access to your project.

If you want to quickly confirm that authentication is working, you can print an access token.

gcloud auth print-access-token

This optional step is handy for testing API calls manually before wiring everything into your code. As always, if you’re using a custom alias for gcloud, your commands may look slightly shorter, but the workflow remains unchanged.

6. Make Your First Programmatic Request to the Conversational Agent

With authentication in place and your service account ready, you can now send a direct API request to your conversational agent. This is the core of programmatic access — issuing a query and receiving the agent’s response without using the UI.

curl -X POST \
  -H "Authorization: Bearer <ACCESS-TOKEN>" \
  -H "x-goog-user-project: project-id" \
  -H "Content-Type: application/json; charset=utf-8" \
  -d '{
    "queryInput": {
      "text": {
        "text": "Hello!"
      },
      "languageCode": "en"
    }
  }' \
  "https://<region>-dialogflow.googleapis.com/v3/projects/<project-id>/locations/<region>/agents/<agent-id>/sessions/SESSION_ID:detectIntent"

Replace the placeholders with your actual values:

• <ACCESS-TOKEN> — the token printed earlier or generated via your service account
• project-id — your Google Cloud project ID
• <region> — the region where your agent is deployed
• <agent-id> — the ID of your Dialogflow CX agent
• SESSION_ID — any unique string to represent the conversation session

If everything is configured correctly, the API will return a JSON response containing the agent’s detected intent and generated reply. This confirms that your setup is working and that you can now integrate conversational queries directly into your applications.

Figure 2 - API Response

Working through these steps gives you a solid understanding of how to interact with Google’s conversational agents at the API level. Once the authentication flow and networking setup are in place, you can see just how flexible and powerful this approach becomes. With the right infrastructure, programmatic access can evolve into a unified, end‑to‑end solution for building intelligent, automated conversational systems.

In practical scenarios, developers rarely rely on raw curl commands for long. Instead, you wrap these API calls inside a scripting or programming language — C#, Node.js, Kotlin, or whatever fits your stack. From there, you build services around them: helper functions, reusable modules, microservices, event‑driven workflows, or full backend integrations. That’s where the real power shows up, turning simple API requests into scalable, production‑ready conversational experiences.