# Create Google Listing API (`listingsapi/create-google-listing-api`) Actor

Connect a Google account, match its profiles to your locations, and create a Google Business Profile listing for any location that does not have one. The single location tool behind bulk GBP creation.

- **URL**: https://apify.com/listingsapi/create-google-listing-api.md
- **Developed by:** [Local Business Listings Submission API](https://apify.com/listingsapi) (community)
- **Categories:**
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Create Google Listing API

Create a Google Business Profile listing for a location that does not have one, connect the Google account it lives under, and match existing profiles to the right locations.

A location in your account and a Google Business Profile are two different things. This Actor is where you join them: connect a Google account, see which of its profiles match which of your locations, link them, and create a fresh Google listing for anything still missing one. It wraps the connected account endpoints of the [Listings API](https://www.listingsapi.com).

For hundreds of locations at once, use [Create Bulk GBP Listings API](https://apify.com/listingsapi/create-bulk-gbp-listings-api) instead. This one is the single location tool and the place you get the connected account ID that the bulk Actor needs.

### Creation is asynchronous

`createGmbListingForLocation` answering `success: true` means the request was accepted, not that the listing is live. Google verifies and provisions on its own schedule. Check the real state later with `premiumListingsOfLocation` in the [Local SEO Analytics API](https://apify.com/listingsapi/local-seo-analytics-api) Actor.

### What this Actor does

**Create a Google listing**

- Creates a Google Business Profile listing for one of your locations, under a connected Google account
- Creates a location in your account from a Google profile you already own, for the reverse direction

**Connect the account**

- Connects a Google account, or a Facebook account
- Lists the accounts already connected, with status
- Returns full detail for one connected account and its GMB folders, meaning its location groups
- Disconnects either provider

**Match profiles to locations**

- Lists every profile inside a connected account, so you can see what is available to link
- Returns suggested profile to location matches
- Triggers a fresh match run after you add locations or profiles
- Confirms suggested matches in bulk
- Links one profile to one location, or unlinks them

### Why this comes first

| You want to | You need first |
| --- | --- |
| Reply to a Google or Facebook review | That profile connected and matched to the location |
| Publish a post to Google, Facebook or Instagram | A connected account with at least one matched profile |
| Read Google, Facebook or Bing performance | The matching profile connected to the location |
| Create listings in bulk | A `connectedAccountId` from `connectedAccounts` here |

If an analytics call comes back empty or a reply fails, an unmatched profile is the usual cause. Run `connectedAccounts` here to check before you go looking anywhere else.

### Who this is for

- Multi location brands standing up Google profiles for stores that never had one
- Agencies onboarding a client account and linking profiles to locations in one pass
- Franchise systems auditing which stores are still unmatched
- Anyone running a nightly check that no profile has silently dropped its connection

### What you need

A Listings API account and an API key. Create one at [listingsapi.com](https://www.listingsapi.com/pricing).

| Access level | Covers |
| --- | --- |
| Read | `connectedAccounts`, `connectedAccountDetails`, `gmbFoldersOfConnectedAccount`, `connectionSuggestions` |
| Write | Creating listings, connecting, disconnecting and matching |

Google and Facebook connections are established through an OAuth grant on the Listings API side. This Actor sends the resulting authorization payload, so complete the OAuth step in your dashboard or your own OAuth flow first, then pass the value through `body`. The exact payload is documented at [docs.listingsapi.com/docs/connected-accounts](https://docs.listingsapi.com/docs/connected-accounts).

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `apiKey` | string | Yes | Your Listings API key. Stored as a secret. |
| `operation` | string | Yes | Which endpoint to call. See the operations table. |
| `pathParams` | object | No | Values for placeholders in the path, for example `{ "connectedAccountId": "88" }`. |
| `query` | object | No | Query string values such as `limit` or `after`. |
| `body` | object | No | JSON payload for the create, connect and match operations. |
| `paginate` | boolean | No | Keep requesting pages while `pageInfo.hasNextPage` is true. Default `false`. |
| `maxItems` | integer | No | Stop after this many dataset items. `0` means no limit. |

### Operations

| Operation | Method and path | Returns |
| --- | --- | --- |
| `createGmbListingForLocation` | `POST /locations/create/gmb-listing` | Creates a Google listing for a location |
| `createLocationFromListing` | `POST /connected-accounts/create-location-from-listing` | Creates a location from a profile you own |
| `connectedAccounts` | `GET /connected-accounts` | Every connected Google and Facebook account |
| `connectedAccountDetails` | `GET /connected-accounts/{connectedAccountId}/details` | Detail for one connected account |
| `gmbFoldersOfConnectedAccount` | `GET /connected-accounts/{connectedAccountId}/folders` | GMB location groups under the account |
| `connectGoogle` | `POST /connected-accounts/connect-google` | Links a Google account |
| `connectFacebook` | `POST /connected-accounts/connect-facebook` | Links a Facebook account |
| `disconnectGoogle` | `POST /connected-accounts/disconnect-google` | Unlinks a Google account |
| `disconnectFacebook` | `POST /connected-accounts/disconnect-facebook` | Unlinks a Facebook account |
| `connectedAccountListings` | `POST /connected-accounts/connected-account-listings` | Profiles held inside a connected account |
| `connectionSuggestions` | `GET /connected-accounts/{connectedAccountId}/connection-suggestions` | Suggested profile to location matches |
| `triggerMatches` | `POST /connected-accounts/trigger-matches` | Starts a fresh match run |
| `confirmMatches` | `POST /connected-accounts/confirm-matches` | Accepts suggested matches in bulk |
| `connectListing` | `POST /connected-accounts/connect-listing` | Links one profile to one location |
| `disconnectListing` | `POST /connected-accounts/disconnect-listing` | Unlinks profiles from locations |
| `allLocations` | `GET /locations` | Your locations, used to look up location IDs |
| `searchLocations` | `GET /locations/search` | Locations matching a search term |

### Examples

Create a Google listing for one location. Both fields are required:

```json
{
  "apiKey": "<your key>",
  "operation": "createGmbListingForLocation",
  "body": {
    "input": {
      "locationId": "TG9jYXRpb246MTgwMDI4OQ==",
      "connectedAccountId": "4f712c17-4f95-42dd-90f4-97171a2e67b5"
    }
  }
}
```

It answers like this. `success` means accepted, not live:

```json
{
  "clientMutationId": null,
  "success": true,
  "errors": null
}
```

Find the connected account ID you need for that call, and for the bulk Actor:

```json
{
  "apiKey": "<your key>",
  "operation": "connectedAccounts"
}
```

Connect a Google account with an authorization payload from your OAuth step:

```json
{
  "apiKey": "<your key>",
  "operation": "connectGoogle",
  "body": {
    "input": {
      "authorizationCode": "<code from the Google OAuth redirect>",
      "redirectUri": "https://example.com/oauth/google/callback"
    }
  }
}
```

List every profile inside a connected account:

```json
{
  "apiKey": "<your key>",
  "operation": "connectedAccountListings",
  "body": {
    "input": { "connectedAccountId": "4f712c17-4f95-42dd-90f4-97171a2e67b5" }
  }
}
```

Review the matches the system suggests before accepting any:

```json
{
  "apiKey": "<your key>",
  "operation": "connectionSuggestions",
  "pathParams": { "connectedAccountId": "4f712c17-4f95-42dd-90f4-97171a2e67b5" },
  "query": { "limit": 50 },
  "paginate": true
}
```

Accept a batch of suggested matches:

```json
{
  "apiKey": "<your key>",
  "operation": "confirmMatches",
  "body": {
    "input": {
      "connectedAccountId": "4f712c17-4f95-42dd-90f4-97171a2e67b5",
      "matches": [
        { "locationId": "TG9jYXRpb246MTgwMDI4OQ==", "listingId": "gmb-a41" },
        { "locationId": "TG9jYXRpb246MTgwMDI5MA==", "listingId": "gmb-a42" }
      ]
    }
  }
}
```

Create a location from a Google profile you already own:

```json
{
  "apiKey": "<your key>",
  "operation": "createLocationFromListing",
  "body": {
    "input": {
      "connectedAccountId": "4f712c17-4f95-42dd-90f4-97171a2e67b5",
      "listingId": "gmb-a44"
    }
  }
}
```

### A normal onboarding run

1. `connectGoogle` to link the account
2. `connectedAccounts` to read back its `connectedAccountId`
3. `connectedAccountListings` to see every profile the account holds
4. `triggerMatches` to run matching against your locations
5. `connectionSuggestions` to review what matched and how confidently
6. `confirmMatches` for the ones that look right, `connectListing` for the rest by hand
7. `createGmbListingForLocation` for locations with no Google profile at all, or the [bulk Actor](https://apify.com/listingsapi/create-bulk-gbp-listings-api) if there are many
8. `createLocationFromListing` for profiles you own but have no location for yet

After that the review, posting and analytics Actors have live profiles to work with.

### Output

Each item becomes one dataset row. A connected account row looks roughly like this:

```json
{
  "id": "4f712c17-4f95-42dd-90f4-97171a2e67b5",
  "provider": "GOOGLE",
  "accountName": "Acme Group",
  "email": "ops@acme.com",
  "state": "CONNECTED",
  "listingCount": 42,
  "matchedCount": 39,
  "connectedAt": "2026-07-02T11:04:00Z"
}
```

`listingCount` against `matchedCount` is the number to watch. The gap is the set of profiles that will silently do nothing when you try to post or reply.

Exact fields follow the API response. Download the dataset as JSON, CSV, Excel or XML, or read it from the Apify API. The run also writes a `SUMMARY` record to the key value store.

### Running it on a schedule

Run `connectedAccounts` daily and send the dataset to a webhook that alerts when a `state` stops reading as connected. Google and Facebook tokens expire, and a broken connection is usually noticed only when a post fails. Run `triggerMatches` after any batch of new locations so nothing sits unmatched.

### Rate limits and pagination

Requests go out one at a time. The Actor reads `pageInfo.hasNextPage` before fetching the next page, waits out a 429 using `retry_after_seconds`, and retries server errors with a backoff. Plan limits are 10 requests per minute on Launch and 50 on Growth. See [rate limits](https://docs.listingsapi.com/docs/rate-limits).

### Errors

A non success response stops the run and logs the status, the URL and the response body including the `correlation_id`. Codes are listed at [docs.listingsapi.com/docs/error-codes](https://docs.listingsapi.com/docs/error-codes).

The create and connect endpoints also carry `success` and `errors` inside a 200 response, so read those fields on the returned row rather than trusting the status code alone.

Disconnecting an account removes the link, not the profile. The Google or Facebook profile itself stays live and untouched.

### Cost

You pay Apify for platform usage of the run. Listing creation, connections and matching are billed by your Listings API plan, which starts at 99 dollars a month with a 14 day trial.

### Related Actors

- [Create Bulk GBP Listings API](https://apify.com/listingsapi/create-bulk-gbp-listings-api) for creating Google listings across hundreds of locations in one run
- [Local Business Listings Submission API](https://apify.com/listingsapi/local-business-listings-submission-api) for creating and syncing locations
- [Local Business Reviews API](https://apify.com/listingsapi/local-business-reviews-api) for reading and replying to reviews
- [Local Business Posts API](https://apify.com/listingsapi/local-business-posts-api) for publishing to Google, Facebook, Instagram and X
- [Local SEO Analytics API](https://apify.com/listingsapi/local-seo-analytics-api) for publisher performance and listing coverage

### Links

- Documentation: [docs.listingsapi.com](https://docs.listingsapi.com/docs)
- Create a GMB listing: [docs.listingsapi.com/docs/api/connected-accounts-create-gmb-listing](https://docs.listingsapi.com/docs/api/connected-accounts-create-gmb-listing)
- Connected account endpoints: [docs.listingsapi.com/docs/connected-accounts](https://docs.listingsapi.com/docs/connected-accounts)
- SDKs: [docs.listingsapi.com/sdks](https://docs.listingsapi.com/sdks)
- MCP server: [listingsapi.com/mcp](https://www.listingsapi.com/mcp)
- Support: support@listingsapi.com

# Actor input Schema

## `apiKey` (type: `string`):

Your Listings API key. Create one at https://listingsapi.com. Connecting, disconnecting and matching all need a key with Write access.

## `operation` (type: `string`):

Which Google listing or connected account endpoint to call.

## `pathParams` (type: `object`):

Values for placeholders in the endpoint path, for example { "connectedAccountId": "88" }.

## `query` (type: `object`):

Query string values such as limit or after.

## `body` (type: `object`):

JSON payload for the connect, disconnect and match operations. Payload shapes are at https://docs.listingsapi.com/docs/connected-accounts.

## `paginate` (type: `boolean`):

Keep requesting pages while pageInfo.hasNextPage is true.

## `maxItems` (type: `integer`):

Stop after this many dataset items. Set 0 for no limit.

## Actor input object example

```json
{
  "operation": "connectedAccounts",
  "pathParams": {},
  "query": {},
  "body": {},
  "paginate": false,
  "maxItems": 0
}
```

# Actor output Schema

## `results` (type: `string`):

One row per Google listing, connected account, profile, match suggestion or location returned by the operation you ran.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("listingsapi/create-google-listing-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("listingsapi/create-google-listing-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call listingsapi/create-google-listing-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,listingsapi/create-google-listing-api"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/627MvRvODCVixI44e/builds/alr8WCDJ6O4AVJo0r/openapi.json