# Slack App Directory Scraper (`maximedupre/slack-app-directory-scraper`) Actor

Scrape Slack App Directory apps, categories, pricing, languages, vendor links, policy URLs, and public emails. Search by keyword, browse categories, fetch known apps, or export public Slack marketplace data.

- **URL**: https://apify.com/maximedupre/slack-app-directory-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.90 / 1,000 scraped apps

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### 🔎 Slack App Directory scraper for app listings

Scrape public [Slack App Directory](https://slack.com/marketplace) listings into a clean Apify dataset. Use this Slack App Directory scraper to export app names, IDs, categories, pricing, languages, vendor links, policy URLs, and public emails when they are available.

The Actor is built for app ecosystem research, SaaS partner discovery, integration catalog building, lead research, and scheduled refreshes. Use it as a Slack marketplace scraper when you need app listings, vendor links, and contact evidence in one export. You can search by keyword, browse Slack categories, fetch known apps by URL or ID, or leave the target sections empty to collect the public directory.

No Slack login, cookies, workspace membership, or Slack API key is needed. The Actor only collects public directory and linked public vendor/contact facts.

### 📦 What you get

Each output item represents one successfully scraped public Slack app listing. The dataset includes:

- `appId` and `appSlug` for stable deduplication and refreshes.
- App `name`, `description`, `pricingType`, `categories`, and `supportedLanguages`.
- Source-hosted `iconUrl`.
- `vendor` details with website and location when public source data exposes them.
- `contact` details with support URL, privacy policy URL, terms URL, and public emails when available.

The marketplace URL is not repeated as a separate field because it can be rebuilt from the slug: `https://slack.com/marketplace/{appSlug}`.

### 🎯 Ways to run it

Choose one target section per run:

- Search apps by keyword, such as `github`, `crm`, `calendar`, or `security`.
- Browse one or more Slack App Directory categories.
- Fetch known apps with public Slack marketplace URLs, app IDs, or app slugs.
- Leave target sections empty to export the public directory across categories.

Global options apply across target types. Use `pricingFilter` to limit search or category results to free, freemium, or paid apps. Use `maxItems` to cap the number of apps returned.

### 💼 Use cases

- Build a Slack integration catalog for internal tools or market research.
- Find Slack app vendors with public support, privacy, terms, and email evidence.
- Track category coverage across developer tools, analytics, security, sales, HR, and other Slack app groups.
- Refresh known app profiles by app ID or Slack marketplace URL.
- Export app facts to CSV, JSON, Google Sheets, a data warehouse, or an Apify integration.

### 🧾 Input

The public form has target sections and global options:

- `searchQueries`: keywords to search in Slack App Directory.
- `categories`: Slack App Directory categories to browse.
- `appTargets`: known public app URLs, app IDs, or app slugs.
- `pricingFilter`: optional filter for the pricing type shown by Slack.
- `maxItems`: maximum number of apps to emit, from 1 to 10,000.

Fill only one target section for the clearest run. If you fill no target section, the Actor collects from the public directory and deduplicates apps found through multiple categories.

### 📤 Output example

```json
{
  "appId": "A01BP7R4KNY",
  "appSlug": "A01BP7R4KNY-github",
  "name": "GitHub",
  "description": "Stay updated on projects and access GitHub Copilot's AI-powered developer tools.",
  "pricingType": "freemium",
  "categories": [
    {
      "id": "At0EFRCDNY-developer-tools",
      "name": "Developer Tools"
    }
  ],
  "supportedLanguages": ["en-GB", "en-US"],
  "iconUrl": "https://avatars.slack-edge.com/example-github-icon.png",
  "vendor": {
    "name": "GitHub",
    "websiteUrl": "https://github.com",
    "location": null
  },
  "contact": {
    "supportUrl": "https://support.github.com",
    "privacyPolicyUrl": "https://github.com/privacy",
    "termsUrl": "https://github.com/site/terms",
    "emails": ["support@github.com", "security@github.com"]
  }
}
````

Nullable fields mean Slack or a linked public vendor page did not expose that fact. Empty arrays mean the field is part of the output contract, but no source-backed values were found for that app.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each successfully scraped app saved to the dataset.

- Event: `slack-app-record`
- Price: `$0.0009` per scraped app
- Equivalent: `$0.90` per 1,000 scraped apps

No separate event is charged for public emails, support links, privacy links, actor starts, no-result searches, or failed targets.

### ⚠️ Limits and caveats

This Actor collects public Slack App Directory data. It does not access private Slack workspaces, installed-app state, workspace usage, private reviews, user data, or account data.

Slack and vendor pages do not expose every field for every app. When a pricing type, vendor website, policy URL, location, language, or email is missing from public source data, the Actor leaves that value as `null` or an empty array instead of guessing.

Icon URLs are returned as source-hosted URLs. The Actor does not download or mirror Slack-hosted images into Apify storage.

### ❓ FAQ

#### 🔐 Do I need a Slack account?

No. The Actor runs against public Slack App Directory pages and linked public vendor/contact pages. You do not need Slack credentials, cookies, workspace membership, or a Slack API key.

#### 🧩 Can I scrape a known Slack app?

Yes. Add a public Slack marketplace URL, app ID, or app slug to `appTargets`. This is useful when you want to refresh specific listings without crawling a category or the full directory.

#### 📧 Where do the emails come from?

Emails are collected only from public Slack app data or linked public vendor/contact pages. If no public email is found for an app, `contact.emails` is an empty array.

#### 🗂️ Can I scrape the whole directory?

Yes. Leave the target sections empty and set `maxItems` to the number of apps you want. The Actor crawls public categories and deduplicates apps by Slack identity.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~slack-app-directory-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Chrome Extensions Scraper ↗](https://apify.com/maximedupre/chrome-extensions-scraper) - Scrape Chrome Web Store extension listings, publisher contacts, privacy links, manifests, and related extensions.
- [ChatGPT Marketplace Scraper ↗](https://apify.com/maximedupre/chatgpt-marketplace-scraper) - Export public GPT marketplace listings from URLs, search phrases, categories, or tags.
- [Google Play Store Scraper ↗](https://apify.com/maximedupre/google-play-store-scraper) - Scrape Android app metadata, reviews, permissions, ratings, installs, and developer facts.
- [Apple App Store Scraper ↗](https://apify.com/maximedupre/apple-app-store-scraper) - Scrape iOS app data, reviews, search results, top charts, screenshots, and developer facts.
- [RapidAPI Scraper ↗](https://apify.com/maximedupre/rapidapi-scraper) - Scrape RapidAPI marketplace listings, provider data, pricing labels, metrics, plans, and endpoint metadata.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `searchQueries` (type: `array`):

Find Slack apps by keyword.

## `categories` (type: `array`):

Collect apps from one or more Slack App Directory categories.

## `appTargets` (type: `array`):

Fetch specific public Slack app listings by marketplace URL, app ID, or app slug.

## `pricingFilter` (type: `string`):

Limit search or category results by the pricing type shown by Slack.

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

Cap app rows for directory, search, category, and featured runs.

## Actor input object example

```json
{
  "searchQueries": [],
  "categories": [],
  "appTargets": [],
  "pricingFilter": "",
  "maxItems": 250
}
```

# Actor output Schema

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

Open the dataset with one item for each successfully scraped Slack App Directory app.

# 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 = {
    "searchQueries": [],
    "categories": [],
    "appTargets": [],
    "pricingFilter": "",
    "maxItems": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/slack-app-directory-scraper").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 = {
    "searchQueries": [],
    "categories": [],
    "appTargets": [],
    "pricingFilter": "",
    "maxItems": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/slack-app-directory-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [],
  "categories": [],
  "appTargets": [],
  "pricingFilter": "",
  "maxItems": 250
}' |
apify call maximedupre/slack-app-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/slack-app-directory-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Slack App Directory Scraper",
        "description": "Scrape Slack App Directory apps, categories, pricing, languages, vendor links, policy URLs, and public emails. Search by keyword, browse categories, fetch known apps, or export public Slack marketplace data.",
        "version": "0.1",
        "x-build-id": "B2xuMVvDrYHqfalDE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~slack-app-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-slack-app-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~slack-app-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-slack-app-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~slack-app-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-slack-app-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "maxItems"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Find Slack apps by keyword.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Collect apps from one or more Slack App Directory categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "At0B6CJ29JDB-mcp-registry",
                                "At0EFWTR6D-featured",
                                "At07HZAKCSAC-ai-apps-assistants",
                                "At01EB3C3VKK-enterprise-ready-apps",
                                "AtVCT88N5T-working-from-home",
                                "AtHC5Q7RUJ-daily-tools",
                                "At64BY3G3F-essential-apps",
                                "At0EFT67V3-new-noteworthy",
                                "At0EFT6813-brilliant-bots",
                                "At0G5YTKU2-analytics",
                                "At0EFT6869-communication",
                                "At0EFRCDQC-customer-support",
                                "At0EFX4CCE-design",
                                "At0EFRCDNY-developer-tools",
                                "At0EFRCDPW-file-management",
                                "At0EFX9EF9-finance",
                                "At0MRS55PA-health-wellness",
                                "At0EFT6893-hr-team-culture",
                                "At0EFRCDQU-marketing",
                                "At0EFWTRAM-office-management",
                                "At0EFXUU6N-productivity",
                                "At0EFY3MJ4-project-management",
                                "At0G5VPH19-sales",
                                "At0EFWTRA5-security-compliance",
                                "At0EFXUU0J-social-fun",
                                "At0QUNV823-travel",
                                "At7KGP7Z3N-voice-video",
                                "At7KK5H6AZ-media-news"
                            ],
                            "enumTitles": [
                                "MCP registry",
                                "Featured",
                                "AI Apps & Assistants",
                                "Enterprise-ready apps",
                                "Working from home",
                                "Daily Tools",
                                "Essential Apps",
                                "New & Noteworthy",
                                "Brilliant Bots",
                                "Analytics",
                                "Communication",
                                "Customer Support",
                                "Design",
                                "Developer Tools",
                                "File Management",
                                "Finance",
                                "Health & Wellness",
                                "HR & Team Culture",
                                "Marketing",
                                "Office Management",
                                "Productivity",
                                "Project Management",
                                "Sales",
                                "Security & Compliance",
                                "Social & Fun",
                                "Travel",
                                "Voice & Video",
                                "Media & News"
                            ]
                        },
                        "default": []
                    },
                    "appTargets": {
                        "title": "Known app URLs or IDs",
                        "type": "array",
                        "description": "Fetch specific public Slack app listings by marketplace URL, app ID, or app slug.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "pricingFilter": {
                        "title": "Pricing filter",
                        "enum": [
                            "",
                            "free",
                            "freemium",
                            "paid"
                        ],
                        "type": "string",
                        "description": "Limit search or category results by the pricing type shown by Slack.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Maximum app records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Cap app rows for directory, search, category, and featured runs.",
                        "default": 250
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```