# Google Workspace Marketplace App Search & Category Browser (`nimbryxo-studio/google-workspace-marketplace-app-search`) Actor

Search Google Workspace Marketplace apps by keyword, browse a category, or fetch specific app IDs. Returns developer, rating, review count, pricing model, categories, compatible Google products and icon.

- **URL**: https://apify.com/nimbryxo-studio/google-workspace-marketplace-app-search.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Workspace Marketplace App Search & Category Browser

Pull app listings from the [Google Workspace Marketplace](https://workspace.google.com/marketplace), with no Google account, API key, or proxy needed. Search by keyword, browse an entire category, or fetch full details for specific app IDs you already know.

### What this actor does

- **Keyword search** across the whole marketplace, enriched with full listing detail
- **Category browsing** across 26 categories and subcategories (popular apps, top rated, business tools, productivity, education, and more)
- **Direct app lookup** by numeric app ID, with no practical limit on how many you can fetch
- **Multi-language results** — choose the language the listing page is read in
- Fields with no value for a given app (e.g. no reviews yet, unlisted pricing) are omitted rather than returned as `null`

### Output per app

- `appId` — numeric app identifier
- `name` — app display name
- `developer` — publisher/developer name
- `shortDescription` — one-line app summary
- `description` — full app description
- `rating` — average star rating, 0–5
- `reviewCount` — total number of ratings
- `installCount` — install count, when the listing publishes one
- `pricingModel` — `Free`, `Freemium`, or `Paid`
- `categories` — official Marketplace categories the app belongs to
- `worksWith` — Google products the app integrates with (e.g. Google Docs, Google Drive)
- `lastUpdated` — date of the listing's most recent update
- `appUrl` — direct link to the app's Marketplace listing
- `iconUrl` — app icon image, hosted by Google
- `recordType` — always `"workspace_app"`
- `scrapedAt` — ISO timestamp of the scrape

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search`, `byCategory`, or `byAppId` |
| `searchQuery` | string | `mail merge` | Keyword to search for (mode=search) |
| `category` | string | `popular-apps` | Category path to browse (mode=byCategory) |
| `appIds` | array | `[]` | Numeric app IDs to fetch (mode=byAppId) |
| `maxItems` | integer | `50` | Maximum records to emit (1–200) |
| `language` | string | `en` | Language for search/category pages |

#### Example: keyword search

```json
{
  "mode": "search",
  "searchQuery": "mail merge",
  "maxItems": 30
}
```

#### Example: browse a category

```json
{
  "mode": "byCategory",
  "category": "business-tools/sales-and-crm",
  "maxItems": 50
}
```

#### Example: fetch specific apps by ID

```json
{
  "mode": "byAppId",
  "appIds": ["7081045131", "218858140275"]
}
```

#### Example: search results in Spanish

```json
{
  "mode": "search",
  "searchQuery": "crm",
  "language": "es",
  "maxItems": 20
}
```

### Use cases

- **IT and procurement evaluation** — compare pricing models, ratings and Google-product compatibility before approving an app
- **Competitive research** — track where your app or a competitor's ranks within a category
- **Market mapping** — enumerate every app in a category (e.g. all CRM or accounting tools) for a landscape report
- **Vendor and partner discovery** — find developers building for a specific Workspace product
- **App directory sites** — populate a curated listing page with live Marketplace data

### FAQ

**Does this need a Google account or API key?** No — the Marketplace is publicly browsable, and this actor reads it without any authentication, cookies, or proxy.

**How many apps can one run return?** Search and category pages return up to 100 apps per query (the marketplace's own natural limit); `maxItems` controls how many of those are emitted. `byAppId` mode has no such limit since it fetches exact listings.

**What does `pricingModel` mean?** `Free` means no cost at all; `Freemium` covers listings marked "free with paid features" or offering a free trial; `Paid` means payment is required to use the app.

**What is `worksWith`?** The Google products the app integrates with (e.g. Google Drive, Gmail, Sheets, Slides, Docs, Calendar, Forms, Chat), taken directly from the listing.

**Why might `rating`, `reviewCount`, or `installCount` be missing?** New or lightly used listings may not have published figures yet; the field is omitted rather than shown as zero.

**Are reviews included in this actor's output?** No — this actor covers app listing data only; review text is out of scope here.

**Are the icon URLs publicly accessible?** Yes — icons are hosted at `lh3.googleusercontent.com` and load without authentication.

**Is this affiliated with Google?** No — this is an independent actor reading the public Google Workspace Marketplace; it is not operated by or affiliated with Google.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. search=keyword search, byCategory=browse a category, byAppId=fetch specific apps.

## `searchQuery` (type: `string`):

Keyword to search for apps. Required for mode=search.

## `category` (type: `string`):

Category path to browse. Required for mode=byCategory.

## `appIds` (type: `array`):

Numeric App IDs to fetch (e.g. 218858140275). Required for mode=byAppId.

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

Maximum number of records to emit.

## `language` (type: `string`):

Optional language for search/category pages.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "mail merge",
  "category": "popular-apps",
  "appIds": [],
  "maxItems": 50,
  "language": "en"
}
```

# Actor output Schema

## `apps` (type: `string`):

Dataset containing all scraped Workspace Marketplace apps.

# 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 = {
    "mode": "search",
    "searchQuery": "mail merge",
    "category": "popular-apps",
    "appIds": [],
    "maxItems": 50,
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/google-workspace-marketplace-app-search").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 = {
    "mode": "search",
    "searchQuery": "mail merge",
    "category": "popular-apps",
    "appIds": [],
    "maxItems": 50,
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/google-workspace-marketplace-app-search").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 '{
  "mode": "search",
  "searchQuery": "mail merge",
  "category": "popular-apps",
  "appIds": [],
  "maxItems": 50,
  "language": "en"
}' |
apify call nimbryxo-studio/google-workspace-marketplace-app-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/google-workspace-marketplace-app-search"
        }
    }
}
```

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/d8EIDG8VY8GDIfdge/builds/7C56s4ZpdozZWASi4/openapi.json