# How to Automate Browser Tasks with Browser-Use and Pabbly Connect

APIs are usually the best way to automate apps.

But what happens when an API **doesn't provide the data or action you need**, while the website itself does?

That's where [Browser Use](https://browser-use.com/) becomes useful.

Browser Use lets an AI agent operate a real browser. You can tell it in plain English to open websites, click buttons, work with logged-in accounts, extract information, submit forms, download files, and perform other browser actions.

And because Browser Use provides an API, we can trigger those browser agents directly from [Pabbly Connect](https://connect.pabbly.com/).

**Pabbly Connect → Browser Use → AI performs browser task → Result comes back to Pabbly**

In this tutorial, I'll show you how using a real Google Tasks problem.

* * *

## The Problem: Google Tasks API Doesn't Return the Due Time I Need

Recently, I wanted to retrieve the exact due date and time of a Google Task inside Pabbly Connect.

For example, I had a task called **Test6**, and Google Tasks displayed:

**Monday, October 5, 10:30 AM**

Normally, you'd expect this to be simple:

**Google Tasks API → Get Task → Get Due Date & Time**

But there's a problem.

Google's Tasks API documents its `due` field as carrying the task's due **date**; the time portion is discarded. So even though Google Tasks can display a specific time in its interface, that exact time isn't available through this API field.

This isn't a Pabbly Connect limitation. If the underlying API doesn't expose something, changing the automation platform doesn't solve the problem.

But the time is visible in the browser.

So instead of asking the API, what if we tell an AI agent:

> Open Google Tasks, find Test6, and return the date and time exactly as displayed.

That's exactly the kind of problem Browser Use can solve.

![](https://cdn.hashnode.com/uploads/covers/6aae254b972739e74429fd87/10b401a6-e162-4c03-8d7a-3ee44eb502eb.png align="center")

Use a screenshot showing a Google Task with its due date **and time** clearly visible. This immediately helps readers understand the API-vs-browser problem.

* * *

# What Is Browser Use?

Browser Use lets AI agents interact with websites through cloud browsers.

Instead of programming:

**Click this → Find this element → Click that → Extract this text**

you describe the goal:

**Open Google Tasks, find Test6, and return its due time.**

The agent figures out how to navigate the website and complete the task.

Browser Use Cloud can start browsers and agents on demand from prompts submitted through its API. [GitHub](https://github.com/browser-use/browser-use/blob/main/CLOUD.md?utm_source=chatgpt.com)

This creates an interesting combination:

**Pabbly Connect handles the workflow. Browser Use handles the browser.**

A few one-line examples:

**Invoice Download:** Login to a vendor portal and download the latest invoice.

**Dashboard Extraction:** Open a logged-in dashboard and return a specific metric.

**Form Submission:** Take Pabbly data and submit it through a website form.

**Order Lookup:** Search a supplier portal and return the current order status.

**Data Entry:** Take information from Google Sheets and enter it into a website.

The idea isn't to replace APIs.

**Use APIs when they can do the job. Use browser automation when they can't.**

* * *

# How Our Google Tasks Automation Works

Here's the complete flow:

**Pabbly → Browser Use API → Open Google Tasks → Find Task → Read Due Time → Return Result → Continue Pabbly Workflow**

The first Browser Use request starts the browser task.

Browser Use returns an ID for that execution.

We can then retrieve the execution result and use the returned data in Pabbly.

* * *

# Step 1: Create a Browser Use Account

First, create your Browser Use Cloud account:

[Open Browser Use Cloud](https://cloud.browser-use.com/)

Before connecting anything to Pabbly, I recommend trying a browser task directly inside Browser Use.

This makes the rest much easier to understand.

* * *

# Step 2: Generate Your Browser Use API Key

Pabbly Connect needs an API key to communicate with Browser Use.

You can create one from Browser Use Cloud:

[Generate Browser Use API Key](https://cloud.browser-use.com/settings)

Browser Use's REST API currently expects the API key in this header:

```plaintext
X-Browser-Use-API-Key: YOUR_API_KEY
```

Browser Use's official API reference confirms this authentication method and currently documents [`https://api.browser-use.com/api/v3`](https://api.browser-use.com/api/v3) as its API base URL. [Browser Use](https://docs.browser-use.com/api-reference/api-v1/get-browser-use-version)

Keep your API key private. If you're recording a tutorial or sharing screenshots, hide it.

* * *

# Step 3: Create a Browser Profile

This is one of the most useful parts of Browser Use.

A **Browser Profile** allows browser data such as authentication cookies, local storage, saved credentials, and preferences to persist across sessions. [GitHub](https://github.com/browser-use/browser-use/blob/main/CLOUD.md?utm_source=chatgpt.com)

Why does that matter?

Our agent needs to access Google Tasks, which requires us to be logged into Google.

Without a saved profile:

**Open Browser → Login to Google → Open Google Tasks**

With a saved profile:

**Open Saved Profile → Open Google Tasks**

In other words:

> **Browser Profile = Reusable logged-in browser**

Create your profile from the Browser Use Cloud dashboard and log into the accounts you want the agent to access.

![](https://cdn.hashnode.com/uploads/covers/6aae254b972739e74429fd87/4747801c-1d96-4e02-8090-17e1e2c32dfb.png align="center")

* * *

# Step 4: Login to Google Using the Profile

Open a browser using your new profile and go to:

[Google Tasks](https://tasks.google.com/tasks/)

Login to your Google account normally.

Then make sure your tasks are visible.

In my case, I can see:

**Test6 → Monday, October 5, 10:30 AM**

Once your login is stored in the profile, Browser Use can reuse that authenticated state for future browser tasks.

* * *

# Step 5: Test the Browser Task

Before connecting Browser Use with Pabbly, test the task directly.

Select your saved Google profile and give the agent an instruction like:

```plaintext
Go to https://tasks.google.com/tasks/ and get the due date and time for task "Test6".

Give me the date and time exactly as it is shown.

Return it with the key name "dateTime".

Do not make any changes to the formatting.
```

Browser Use can now:

**Open Google Tasks → Find Test6 → Read the Time → Return the Result**

For example:

```plaintext
{
  "dateTime": "Monday, October 5, 10:30 AM"
}
```

That's exactly what we wanted.

![](https://cdn.hashnode.com/uploads/covers/6aae254b972739e74429fd87/6a08641d-4091-47e0-b60c-948c2134ebe6.png align="center")

* * *

# Why Ask for Structured Output?

You could simply ask:

> When is Test6 due?

But Browser Use might return:

> I found Test6. It is scheduled for Monday, October 5 at 10:30 AM.

That's fine for a human.

For automation, this is better:

```plaintext
{
  "dateTime": "Monday, October 5, 10:30 AM"
}
```

Now Pabbly can easily use `dateTime` in later steps.

**Structured output makes browser automation much easier to use in workflows.**

* * *

# Step 6: Create Your Pabbly Connect Workflow

Now open:

[Pabbly Connect](https://connect.pabbly.com/?utm_source=chatgpt.com)

Create a workflow.

Your trigger can be anything depending on your actual automation.

For example:

**Webhook → Receive Task Name**

or:

**Google Sheets → New Row**

or:

**Schedule → Run Every Morning**

For this example, assume we have:

```plaintext
Task Name = Test6
```

* * *

# Step 7: Add API by Pabbly

Add another action and search for:

**API by Pabbly**

Choose:

**Execute API Request**

Pabbly's API module supports requests such as GET, POST, PUT, PATCH and DELETE and allows you to configure endpoints, headers, authentication and request data. [Pabbly](https://www.pabbly.com/how-to-use-the-api-module-inside-pabbly-connect-a-step-by-step-guide/?utm_source=chatgpt.com)

If you've never used API by Pabbly before, this guide explains it:

%[https://youtu.be/wQEpTxM13Q0] 

* * *

# Step 8: Send the Browser Use Request

Now configure the API request using the request generated/documented by Browser Use.

You'll need your:

**Browser Use API Key, Task/Prompt, Profile ID, Browser Settings** and any other settings you want to use.

For the latest API structure, always refer to:

[Browser Use API Documentation](https://docs.browser-use.com/api-reference/api-v1/get-browser-use-version?utm_source=chatgpt.com)

The important part is the task.

Instead of permanently writing:

```plaintext
Find the task named "Test6"
```

map the task name dynamically from Pabbly:

```plaintext
Find the task named "{{Task Name}}"
```

Now your workflow isn't limited to Test6.

**Client Meeting → Browser Use finds Client Meeting**

**Submit Invoice → Browser Use finds Submit Invoice**

**Call John → Browser Use finds Call John**

The same workflow can handle different tasks dynamically.

![](https://cdn.hashnode.com/uploads/covers/6aae254b972739e74429fd87/a33ac97f-0c88-44db-939c-be4d1c160e6c.png align="center")

# Step 9: Get the Run ID

When you trigger the browser task, Browser Use starts the execution and returns an ID.

Why not immediately return the final answer?

Because the agent has actual browser work to perform:

**Start Browser → Load Google Tasks → Find Test6 → Read Time → Return Result**

Think of the ID like a tracking number.

The first request starts the job.

The ID lets us retrieve its status/result afterward.

![](https://cdn.hashnode.com/uploads/covers/6aae254b972739e74429fd87/ba3d3eef-abde-4669-9166-b191c5a3c14c.png align="center")

* * *

# Step 10: Retrieve the Result

Add another **API by Pabbly** action.

This time, use Browser Use's endpoint for retrieving the execution and map the Run ID returned by the previous step.

The flow becomes:

**Start Run → Get Run ID → Get Run → Read Result**

Because browser tasks aren't instantaneous, make sure the execution has completed before relying on the final result.

Once completed, we get something like:

```plaintext
{
  "dateTime": "Monday, October 5, 10:30 AM"
}
```

And that's it.

We've retrieved information from a logged-in website and brought it back into Pabbly Connect.

![](https://cdn.hashnode.com/uploads/covers/6aae254b972739e74429fd87/59d89c80-0df2-459b-98af-59d4c3e9535b.png align="center")

**Google API couldn't give us the time → Browser Use read it → Pabbly received it.**

![](https://cdn.hashnode.com/uploads/covers/6aae254b972739e74429fd87/c3f20df4-5bb4-4429-a8fc-558e78de7fbc.png align="center")

* * *

# Step 11: Use the Result Anywhere

Once `dateTime` is inside Pabbly Connect, it's just normal workflow data.

**Google Sheets:** Save the task and due time.

**WhatsApp:** Send a reminder.

**Slack:** Notify your team.

**CRM:** Update a custom field.

**AI:** Send the information into another AI step.

Browser Use handles the browser interaction.

Pabbly handles everything before and after it.

* * *

# Record Your Browser Sessions While Testing

I strongly recommend enabling **recording** while building your Browser Use automation.

If something goes wrong, you can inspect what the agent actually did.

Maybe the Google login expired.

Maybe a popup appeared.

Maybe the wrong task was opened.

Maybe the website took too long to load.

Browser Use Cloud includes live session viewing and task results, while browser recording can be enabled for cloud browsers. [GitHub](https://github.com/browser-use/browser-use/blob/main/CLOUD.md?utm_source=chatgpt.com)

Instead of guessing why your automation failed, you can actually watch what happened.

* * *

# Write Better Browser Instructions

Browser agents work better when the goal is specific.

Don't just say:

```plaintext
Check Google Tasks.
```

Say:

```plaintext
Go to https://tasks.google.com/tasks/.

Find the exact task named "Test6".

Return its due date and time exactly as displayed.

Do not convert the timezone.

Do not edit, complete or delete the task.

Return the result using the key "dateTime".
```

A useful formula is:

**Where to go → What to find → What to do → What to return → What NOT to change**

This is especially important when the agent is logged into business accounts.

* * *

# What Else Can You Automate?

The Google Tasks example is small, but the same approach opens up many interesting workflows.

**Invoice Download:** Login to a vendor portal and download the newest invoice.

**Dashboard Data:** Open a private dashboard and extract a metric unavailable through its API.

**Form Submission:** Send Pabbly data into a website form.

**Supplier Portal:** Search an order and return its latest status.

**Legacy Software:** Enter information into an old browser-based application with no API.

**Report Download:** Login to a dashboard and download the newest report.

**Client Portal:** Retrieve information that's only available after login.

The pattern stays the same:

**Pabbly Trigger → Browser Use → Browser Action → Result → Continue Workflow**

* * *

# Turn Browser Use Into a Reusable Pabbly Connect App

There's one more thing I'm exploring.

Instead of manually configuring **API by Pabbly** every time, you can turn Browser Use into a reusable Pabbly Connect custom app.

For example, you could have actions such as:

**Run Browser Task**

**Get Run by ID**

Then your workflow becomes much simpler:

**Browser Use → Run Browser Task**

Enter the instructions, select your profile, and run it.

You can build reusable Pabbly integrations using Pabbly's app-building tools rather than configuring the same raw API requests repeatedly. Pabbly's developer documentation covers creating custom actions and configuring their endpoints and parameters. [Pabbly Docs](https://docs.pabbly.com/pabbly/doc/how-to-configuring-details-and-authentication-method-within-pabbly-connect.2426?utm_source=chatgpt.com)

* * *

# When Should You Use Browser Use?

My rule is simple:

**If a reliable API can do it → use the API.**

**If the website can do it but the API can't → Browser Use becomes interesting.**

Browser automation is usually slower than a normal API request, login sessions can expire, and websites can change.

But it gives you another way to automate something that might otherwise require a person sitting in front of a browser.

* * *

# Final Thoughts

My Google Tasks example started with a very small problem.

I wanted the exact due time of a task.

The Google Tasks API wasn't giving me what I needed, but the information was clearly visible inside Google Tasks.

So Browser Use opened Google Tasks using my saved profile, found the task, read the time, and returned it to Pabbly Connect.

And that's the bigger idea.

Previously, many automations stopped when you discovered:

> **The API doesn't support this.**

Now there can be another option:

> **Let an AI agent use the browser instead.**

Combine Browser Use with Pabbly Connect, and your workflows can use **APIs where possible and browser actions where necessary.**