# StackShare Company Tech Stack Scraper (`automation-lab/stackshare-company-tech-stack-scraper`) Actor

🏢 Turn public StackShare company profiles into structured technographic records with company metadata, technology layers, displayed counts, observable tool links, and transparent source provenance.

- **URL**: https://apify.com/automation-lab/stackshare-company-tech-stack-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 83.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

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

## StackShare Company Tech Stack Scraper

Turn public StackShare company profiles into structured technographic records.

Give the Actor one or many StackShare profile URLs and receive company metadata, displayed technology-layer counts, and observable tool links in JSON, CSV, Excel, XML, or RSS through Apify datasets.

It supports both public profile formats:

- `https://stackshare.io/airbnb/airbnb`
- `https://stackshare.io/companies/stackshare`

StackShare may show an anti-bot checkpoint to automated visitors. The Actor handles this transparently with bounded live attempts and an optional public archive fallback. Every result says whether it came from the live page or an archived snapshot, so stale data is never presented as current.

### What does StackShare Company Tech Stack Scraper do?

The Actor extracts one company technology-stack record per input URL.

Each successful record can include:

- company name and description;
- company website and displayed location;
- total displayed tool count;
- StackShare's update label;
- ordered technology layers;
- displayed count for every layer;
- observable tool names and StackShare links;
- live-versus-archive provenance;
- scrape and snapshot timestamps.

When one URL cannot be extracted, the dataset contains a clear diagnostic for that URL. If every URL fails, the run exits with an error after preserving those diagnostics.

### Who is it for?

#### Sales and RevOps teams

Enrich target-account lists with declared infrastructure, data, DevOps, utility, AI, and business tools.

#### Vendor marketing teams

Track which companies publicly associate themselves with a category or competing product.

#### Investors and analysts

Compare the technology choices of portfolio companies, competitors, or market segments.

#### Engineering teams

Research peer architectures before evaluating a framework, cloud service, database, or monitoring tool.

#### Data teams

Schedule repeatable snapshots and send structured records to a warehouse, spreadsheet, webhook, or BI workflow.

### Why use this Actor?

🧩 **Structured layers** — preserve StackShare's displayed categories instead of returning an ungrouped keyword list.

🔗 **Useful tool links** — receive normalized StackShare URLs for tools observable on the profile.

🛡️ **Transparent fallback** — blocked live pages can fall back to the newest public Wayback snapshot.

🧾 **Explicit provenance** — `fetchSource`, `snapshotTimestamp`, and `archiveUrl` reveal exactly where a record came from.

📦 **Bounded batch input** — submit up to 4 public profile URLs per run, a limit verified for the archive-backed path within the 5-minute timeout.

⏱️ **Bounded retries** — avoid endless CAPTCHA and checkpoint loops.

🔌 **Apify integrations** — export datasets or connect runs to API clients, schedules, webhooks, Make, Zapier, Google Sheets, and MCP.

### Supported StackShare URLs

Use public company-profile URLs only.

Supported:

```text
https://stackshare.io/airbnb/airbnb
https://stackshare.io/stackshare/stackshare
https://stackshare.io/companies/stackshare
```

Not supported:

- StackShare search pages;
- category or tool pages;
- private account pages;
- arbitrary company websites;
- URLs from hosts other than `stackshare.io`.

Unsupported URLs fail closed rather than producing misleading records.

### How to scrape a StackShare company tech stack

1. Open the Actor input page.
2. Add one or more public StackShare company profile URLs.
3. Keep **Use archived profile fallback** enabled for the most reliable first run.
4. Keep the retry limit at `1` unless you have a reason to retry the live route.
5. Click **Start**.
6. Open the dataset to inspect company, layer, tool, and provenance fields.
7. Export the dataset or connect it to your workflow.

A one-URL prefilled run is intentionally small and suitable for a first test.

### Input

| Field | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | Airbnb profile | One to 4 supported public StackShare company URLs. The four-profile ceiling keeps sequential archive fallbacks within the 5-minute run timeout. |
| `allowArchivedFallback` | boolean | `true` | Use the newest public Wayback snapshot if the live profile is blocked. |
| `maxRetries` | integer | `1` | Bounded live attempts before fallback or an error. Range: 1–3. |
| `proxyConfiguration` | object | disabled | Optional Apify Proxy or custom proxy for live requests. |

Example:

```json
{
  "startUrls": [
    { "url": "https://stackshare.io/airbnb/airbnb" },
    { "url": "https://stackshare.io/companies/stackshare" }
  ],
  "allowArchivedFallback": true,
  "maxRetries": 1
}
```

### Output data

| Field | Type | Meaning |
|---|---|---|
| `sourceUrl` | string | Canonical public StackShare URL requested. |
| `status` | string | `ok` or `error`. |
| `companyName` | string | Company name displayed on the profile. |
| `description` | string | Public company description when observable. |
| `website` | string | Displayed company website when observable. |
| `location` | string | Displayed location when observable. |
| `totalTools` | number | Total tools reported by the profile. |
| `updatedLabel` | string | StackShare update label when displayed. |
| `layers` | array | Ordered layers with counts and observable tools. |
| `fetchSource` | string | `live` or `archive`. |
| `snapshotTimestamp` | string | Wayback capture timestamp for archived records. |
| `archiveUrl` | string | Immutable public snapshot URL. |
| `error` | string | Per-URL diagnostic when extraction fails. |
| `scrapedAt` | string | ISO timestamp when the Actor processed the URL. |

### Output example

```json
{
  "sourceUrl": "https://stackshare.io/airbnb/airbnb",
  "status": "ok",
  "companyName": "Airbnb",
  "description": "Founded in August 2008 and based in San Francisco, California...",
  "website": "https://nerds.airbnb.com/",
  "totalTools": 55,
  "updatedLabel": "Updated 1 year ago",
  "layers": [
    {
      "name": "Application & Data",
      "count": 20,
      "tools": [
        { "name": "Amazon EC2", "url": "https://stackshare.io/amazon-ec2" },
        { "name": "Ruby", "url": "https://stackshare.io/ruby" }
      ]
    }
  ],
  "fetchSource": "archive",
  "snapshotTimestamp": "20260125051238",
  "archiveUrl": "https://web.archive.org/web/20260125051238id_/https://stackshare.io/airbnb/airbnb",
  "scrapedAt": "2026-07-22T00:00:00.000Z"
}
```

Actual tools and timestamps depend on the source profile or newest available snapshot.

### Technology layers

StackShare commonly groups tools into these layers:

- AI;
- Application & Data;
- Utilities;
- DevOps;
- Business Tools.

The Actor preserves the order shown by StackShare. `count` is the displayed layer count. `tools` includes only tool names and links observable in the fetched HTML.

Some `/companies/<slug>` pages display only a subset of tool cards while reporting a larger count. The Actor intentionally keeps the displayed count separate from the observable tool array rather than inventing missing tool names.

### Live and archived data provenance

A result with `fetchSource: "live"` was parsed from the live StackShare response.

A result with `fetchSource: "archive"` came from the newest successful public snapshot found through the Wayback CDX index.

For archived records:

- `snapshotTimestamp` identifies capture time;
- `archiveUrl` links to the immutable source;
- `scrapedAt` identifies processing time, not data freshness.

Disable `allowArchivedFallback` when your workflow must reject anything except live data. A checkpointed URL will then emit an error diagnostic.

### How much does it cost to scrape StackShare company stacks?

The Actor uses pay-per-event pricing:

- a small one-time start event per run;
- one result event for each successfully extracted company record;
- no result charge for error diagnostic rows.

The input form and run console show the exact price for your Apify plan. Tiered result pricing decreases on higher plans. Group several profile URLs into one run to spread the start event across more companies.

A one-company prefilled run is the cheapest way to validate the output contract before scheduling a larger account list.

### Sales enrichment workflow

1. Export StackShare profile URLs from your CRM research queue.
2. Run the Actor with those URLs.
3. Filter records with `status = ok`.
4. Flatten `layers[].tools[]` in your data warehouse or automation tool.
5. Match tool names against your product, partners, or competitors.
6. Write the result back to account fields.
7. Preserve provenance fields for analyst review.

This workflow is suitable for declared/public technographic evidence. It is not proof that every displayed tool remains deployed today.

### Monitoring workflow

Use an Apify schedule to run the same URL set weekly or monthly.

Store each dataset with:

- company name;
- snapshot timestamp;
- total tool count;
- layer counts;
- normalized tool names;
- fetch source.

Compare successive datasets downstream to detect additions, removals, or changed counts. When the source is archived, compare `snapshotTimestamp` first so an unchanged archive is not mistaken for a new company update.

### Integrations

#### Google Sheets

Use the Apify Google Sheets integration to send one company record per row. Keep `layers` as JSON or flatten it with an automation step.

#### Make and Zapier

Trigger a run when a CRM account reaches a research stage, then map successful results back to the account.

#### Webhooks

Send a run-succeeded webhook to your data pipeline and fetch the default dataset through its API URL.

#### Data warehouses

Export JSON or CSV to BigQuery, Snowflake, PostgreSQL, or an object-storage ingestion job.

#### Slack alerts

Compare scheduled datasets and notify a channel when selected tool names appear or disappear.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/stackshare-company-tech-stack-scraper').call({
  startUrls: [
    { url: 'https://stackshare.io/airbnb/airbnb' },
    { url: 'https://stackshare.io/companies/stackshare' }
  ],
  allowArchivedFallback: true,
  maxRetries: 1
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/stackshare-company-tech-stack-scraper').call(run_input={
    'startUrls': [
        {'url': 'https://stackshare.io/airbnb/airbnb'}
    ],
    'allowArchivedFallback': True,
    'maxRetries': 1,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~stackshare-company-tech-stack-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://stackshare.io/airbnb/airbnb"}],
    "allowArchivedFallback": true,
    "maxRetries": 1
  }'
```

Fetch dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### MCP and AI agents

Connect the Actor to Claude or another MCP client through this actor-scoped Apify MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/stackshare-company-tech-stack-scraper
```

#### Claude Code

```bash
claude mcp add --transport http stackshare-tech-stacks "https://mcp.apify.com/?tools=automation-lab/stackshare-company-tech-stack-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Add the same HTTP server in Claude Desktop, Cursor, or VS Code with this MCP JSON configuration:

```json
{
  "mcpServers": {
    "stackshare-tech-stacks": {
      "url": "https://mcp.apify.com/?tools=automation-lab/stackshare-company-tech-stack-scraper"
    }
  }
}
```

Example prompts:

- “Extract the technology layers from this StackShare Airbnb profile and summarize the data stack.”
- “Compare these five public StackShare company profiles and list shared DevOps tools.”
- “Return only companies that visibly use Datadog, and include source provenance.”
- “Explain whether each result is live or archived before drawing conclusions.”

Keep your Apify token in the MCP client environment rather than in prompts.

### Tips for reliable runs

- Keep `maxRetries` at `1`; repeated checkpoint requests rarely improve a blocked live route.
- Leave the archived fallback enabled for general research.
- Disable the fallback for workflows that require only live pages.
- Review `snapshotTimestamp` before using a record in time-sensitive decisions.
- Batch up to four URLs to reduce start-fee cost per company while staying within the verified archive-backed runtime envelope.
- Use canonical profile URLs rather than redirected tracking links.
- Schedule moderate snapshots instead of polling profiles continuously.
- Treat displayed tools as public declarations, not independent deployment verification.

### Troubleshooting

#### Why is `fetchSource` set to `archive`?

StackShare served a security checkpoint or otherwise did not return useful profile HTML. The Actor used the newest public snapshot and recorded its timestamp and URL.

#### Why are there fewer `tools` than the layer `count`?

Some company-profile layouts report a total but render only a visible subset of tool cards in the HTML. The Actor preserves the reported count and returns only observable tools.

#### Why did the run fail after saving error rows?

Every requested profile failed. The Actor preserves per-URL diagnostics, then exits non-zero so schedules and monitoring systems do not mistake total extraction failure for success.

#### Why was my URL rejected before scraping?

The Actor accepts only the two documented public StackShare company URL shapes. Tool pages, search pages, and other hosts are rejected to prevent false output.

### Data quality and limitations

StackShare profiles are community or company-declared data. A listed technology may be historical, incomplete, or scoped to one team.

Archive snapshots can lag behind the live profile. Always inspect:

- `fetchSource`;
- `snapshotTimestamp`;
- `updatedLabel`;
- observable tool count versus displayed count.

The Actor does not infer hidden technologies, access private stacks, bypass account permissions, or claim that a tool is currently deployed.

### Is scraping StackShare legal?

Public web data can often be collected for legitimate purposes, but legal obligations depend on your location, purpose, contract, and data handling.

Use the Actor responsibly:

- process only public profile URLs;
- respect applicable laws and contractual restrictions;
- avoid personal-data enrichment without a lawful basis;
- store only data necessary for your workflow;
- review source provenance before redistribution.

This documentation is not legal advice.

### FAQ

#### Does the Actor require a StackShare account?

No. V1 is limited to public company profiles.

#### Does it use StackShare's paid API?

No. It reads public HTML or a public archived snapshot.

#### Can it discover StackShare companies from a keyword?

No. Supply exact public company profile URLs.

#### Can I submit both URL formats in one run?

Yes.

#### Are failed URLs charged as results?

No. The result event is charged only after a successful company record is saved.

#### Can I export to CSV or Excel?

Yes. Use the dataset export controls or API format parameter.

#### Does it return every tool on `/companies/<slug>` pages?

It returns every tool observable in fetched HTML and separately preserves the displayed layer counts.

#### Can I force live-only extraction?

Yes. Set `allowArchivedFallback` to `false`.

### Related scrapers

Build a broader company-intelligence workflow with other Automation Lab Actors:

- [Similarweb Scraper](https://apify.com/automation-lab/similarweb-scraper) for website traffic context;
- [The Org Company Profiles & People Scraper](https://apify.com/automation-lab/the-org-company-profiles-people-scraper) for public organization research;
- [Company Funding Tracker](https://apify.com/automation-lab/company-funding-tracker) for funding signals;
- [Sitemap URL Status Auditor](https://apify.com/automation-lab/sitemap-url-status-auditor) for website URL monitoring.

Use StackShare Company Tech Stack Scraper when the source of truth you want to capture is a public StackShare company profile.

### Support

If a supported URL fails unexpectedly, share:

- the public StackShare URL;
- the run ID;
- whether archived fallback was enabled;
- the saved `error` diagnostic;
- the approximate time of the run.

That evidence makes it possible to distinguish URL validation, source blocking, archive availability, and parser changes quickly.

# Actor input Schema

## `startUrls` (type: `array`):

Public StackShare URLs such as /airbnb/airbnb or /companies/stackshare. Up to 4 URLs per run so archive-backed batches finish within the 5-minute timeout.

## `allowArchivedFallback` (type: `boolean`):

When the live profile is blocked, use its newest public Wayback snapshot and include snapshotTimestamp and archiveUrl.

## `maxRetries` (type: `integer`):

Bounded attempts before the actor uses the archived fallback or emits an error diagnostic.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy or custom proxy configuration for live StackShare requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://stackshare.io/airbnb/airbnb"
    }
  ],
  "allowArchivedFallback": true,
  "maxRetries": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset table containing one typed company record or error diagnostic per input URL.

# 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 = {
    "startUrls": [
        {
            "url": "https://stackshare.io/airbnb/airbnb"
        }
    ],
    "allowArchivedFallback": true,
    "maxRetries": 1,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/stackshare-company-tech-stack-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 = {
    "startUrls": [{ "url": "https://stackshare.io/airbnb/airbnb" }],
    "allowArchivedFallback": True,
    "maxRetries": 1,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/stackshare-company-tech-stack-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 '{
  "startUrls": [
    {
      "url": "https://stackshare.io/airbnb/airbnb"
    }
  ],
  "allowArchivedFallback": true,
  "maxRetries": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/stackshare-company-tech-stack-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/stackshare-company-tech-stack-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/HCjMcXxeSVRgJgeNZ/builds/1fFM2EhrIcxLgnHu9/openapi.json