# Companies Using Any Technology: B2B Leads from Job Posts (`andinoworks/companies-using-technology`) Actor

Find companies that use Salesforce, Snowflake, HubSpot or any tool, including internal software that website scanners cannot see. Each lead shows the job post that proves it, hiring activity and new-match alerts.

- **URL**: https://apify.com/andinoworks/companies-using-technology.md
- **Developed by:** [Ignacio Andino](https://apify.com/andinoworks) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 company delivereds

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

## Companies Using Any Technology: B2B Leads from Job Posts

Find companies that use Salesforce, Snowflake, HubSpot, Kubernetes or any other tool, based on what they write in their own job postings. Use it to build **technographic lead lists**, target accounts of a competitor, and time your outreach to companies hiring around a tool right now.

Website scanners such as BuiltWith or Wappalyzer only see what a website loads, so they miss internal software: data warehouses, CRMs, ERPs and DevOps tools. Job posts often name those tools directly, and this Actor shows you the exact sentence.

It reads about 9,500 companies through the public Greenhouse, Lever and Ashby job board APIs, so it needs no login, cookies or proxies.

**Results appear while it runs.** Open the **Output** tab and start reviewing right away: new companies keep arriving, and the search stops when it reaches your limit, so you do not pay for companies it did not need. Companies known to mention the tool are read first. Sort by `score` when you export them if you want the strongest first.

**Typos are fine.** `snowflak` and `sales force` find Snowflake and Salesforce, and the final message shows what was searched.

### What you get: one row per company

| Field | Example |
|---|---|
| `company`, `website`, `careersUrl` | Acme, acme.com |
| `matchedTechnologies` | `["Snowflake", "dbt"]` |
| `technologies` | Each tool with its job count, wording strength and the sentence found |
| `matchingJobs`, `matchingJobsLast30Days` | How many open roles mention the tools |
| `openRoles`, `rolesPostedLast30Days`, `remoteRoles` | Hiring activity |
| `hiringIn`, `topDepartments`, `seniorityMix` | Where and who they are hiring |
| `whyNow` | A short reason you can use when prioritizing an account |
| `sampleJobs` | Up to 3 postings with links |
| `isNew`, `newTechnologies` | For alerts on scheduled runs |

#### Sample result

```json
{
  "company": "Example Corp",
  "website": "example.com",
  "careersUrl": "https://job-boards.greenhouse.io/example",
  "matchedTechnologies": ["Snowflake"],
  "technologies": [{ "name": "Snowflake", "category": "Data warehouse", "jobs": 4, "signal": "stated", "evidence": "We use Snowflake and dbt for analytics." }],
  "matchingJobs": 4,
  "matchingJobsLast30Days": 3,
  "openRoles": 58,
  "rolesPostedLast30Days": 21,
  "whyNow": "4 open roles mention Snowflake; 21 of 58 open roles were posted in the last 30 days."
}
```

This example shows the format. The values are illustrative.

### How much it costs

**USD 8 per 1,000 companies delivered**, plus **USD 0.10 per 1,000 job boards read** and Apify's small default run-start fee.

| Search | Boards read | Companies | Cost |
|---|---:|---:|---:|
| Quick test | 50 | 10 | About USD 0.09 |
| Default search | 150 | 50 | About USD 0.42 |
| Large list | 1,000 | 500 | About USD 4.10 |

`maxResults` limits the companies delivered, and `maxCompanies` limits the boards read. The Actor also stops at any spending limit you set for the run.

### How to use it

1. Enter one or more **Technologies**.
2. Click **Start**.
3. Export the list as JSON, CSV or Excel, or read it through the API.

#### Example: companies hiring around Snowflake now

```json
{
  "technologies": ["Snowflake"],
  "postedWithinDays": 30,
  "minMatchingJobs": 2,
  "maxCompanies": 500,
  "maxResults": 100
}
```

#### Example: competitor displacement list

```json
{
  "technologies": ["Pipedrive", "Zoho CRM"],
  "countries": ["US", "GB"],
  "maxCompanies": 1000
}
```

#### Example: weekly alert for new accounts

Schedule this weekly. It delivers a company only the first time it matches, or when it starts mentioning another of your tools.

```json
{
  "technologies": ["Databricks", "Fivetran"],
  "onlyNew": true,
  "monitorName": "data-accounts"
}
```

### How to read the signal

- **`stated`:** the post says the company uses the tool, as in "we use Snowflake". This is the stronger signal.
- **`required`:** the post asks for experience with the tool. It usually means the team uses it, but it can also be a nice-to-have.

Common words that are also product names, such as Clay, Linear or Notion, count only in a clear tool context. Privacy notices, sentences about customers, investors or past employers, and text repeated across most of a company's posts are ignored. A company is not listed as a user of its own product.

#### Limits you should know

- **A mention is a signal, not proof of a purchase.** Check the sentence in `evidence` before relying on it. In one manual review of 60 random rows, judged from the sentence shown, 3 were clearly wrong and 5 were doubtful. Most of the doubtful ones were consultancies that may be naming their clients' tools.
- **Coverage is limited.** Only companies on these three job board systems are included, which tends to favor tech and startup companies. Companies with no matching open roles will not appear.
- **Famous products are harder.** Names like Stripe or Shopify also appear in sentences about customers, investors or a team's past employers. Those sentences are filtered, but more mistakes get through than with internal tools such as NetSuite, Workday or Salesforce.
- **`website` is a best guess** from careers links or posting text. It appears only when it resembles the company's name, so it is often empty.
- **Staffing firms are left out by default**, because they list their clients' tools. The detection uses names and posts written for a client, so some may slip through.
- **No personal data:** this Actor returns company information, not people's contact details.

### Data and terms

It reads only published job postings through public job board endpoints. You are responsible for using the results in line with applicable law and the terms of the job board providers, and for following the rules on commercial outreach in your country.

### Input summary

| Field | What it does | Default |
|---|---|---|
| `technologies` | Tools to look for. Required | None |
| `matchAll` | Requires every tool | Off |
| `statedOnly` | Keeps only direct statements | Off |
| `minMatchingJobs` | Minimum roles mentioning the tools | 1 |
| `jobKeywords` | Words required in the job title | All roles |
| `countries` | Where the role is based, plus worldwide remote | All |
| `postedWithinDays` | Only recent postings | No limit |
| `companies` | Specific companies instead of the directory | Directory |
| `maxCompanies` | Boards to read | 150 |
| `maxResults` | Companies delivered. The search stops at this number | 50 |
| `onlyNew`, `monitorName` | Alerts for scheduled runs | Off |

### FAQ

**How is this different from BuiltWith or Wappalyzer?** They detect what a website loads. This reads what companies say about their internal tools. They work well together: use a website scanner for marketing tags, and this for internal software.

**Can I search for a tool that is not in the list?** Yes. Type any name, and it becomes a text search. Unknown tools are not in the index, so the Actor reads the largest companies first. Raise `maxCompanies` for more coverage.

**Why did I get few results?** The tool may be rare in job posts. Try removing filters, or raise `maxCompanies`.

**Can I use it with a CRM, Make, Zapier, n8n or an AI agent?** Yes. Apify provides those integrations and an API for every Actor.

### Related

Looking for remote roles rather than company leads? See [Remote Jobs by Country](https://apify.com/andinoworks/remote-jobs-direct), which detects where each remote job is really open.

# Changelog

This Actor's version history is a separate document: https://apify.com/andinoworks/companies-using-technology/changelog.md

# Actor input Schema

## `technologies` (type: `array`):

Tools or software to look for, such as Salesforce, Snowflake, HubSpot, dbt or Kubernetes. Common typos in known tools are corrected, and the result message shows what was searched. You can also enter any other word or product name.

## `matchAll` (type: `boolean`):

Off: any of the technologies counts. On: the company must mention every one.

## `statedOnly` (type: `boolean`):

Keep only wording such as "we use Snowflake". This gives fewer but stronger results than "experience with Snowflake".

## `minMatchingJobs` (type: `integer`):

Raise it to keep only companies where several open roles mention the tool.

## `jobKeywords` (type: `array`):

For example, data or sales. Leave empty for all roles.

## `countries` (type: `array`):

Worldwide remote roles also count. Leave empty for all.

## `postedWithinDays` (type: `integer`):

For example, 30 finds companies actively hiring for this tool now.

## `includeStaffingFirms` (type: `boolean`):

They usually list their clients' tools rather than their own, so they are left out by default.

## `companies` (type: `array`):

Optional. Check only these: Greenhouse, Lever or Ashby URLs, or slugs such as gitlab or lever:spotify. Leave empty to search the built-in directory.

## `maxCompanies` (type: `integer`):

Companies known to mention the tool are read first. More companies take longer and cost slightly more.

## `onlyNew` (type: `boolean`):

For scheduled runs: delivers a company only the first time it matches, or when it starts mentioning another of your tools.

## `monitorName` (type: `string`):

Use a different name for each saved search so their histories stay separate.

## `maxResults` (type: `integer`):

You pay per company delivered, so this also limits the cost. The search stops when it reaches this number. Companies known to mention the tool are read first.

## `maxRunSeconds` (type: `integer`):

Stops reading more companies after this time. Companies already found stay in Output.

## Actor input object example

```json
{
  "technologies": [
    "Snowflake"
  ],
  "matchAll": false,
  "statedOnly": false,
  "minMatchingJobs": 1,
  "includeStaffingFirms": false,
  "maxCompanies": 150,
  "onlyNew": false,
  "monitorName": "default",
  "maxResults": 50,
  "maxRunSeconds": 200
}
```

# Actor output Schema

## `companies` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {
    "technologies": [
        "Snowflake"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("andinoworks/companies-using-technology").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 = { "technologies": ["Snowflake"] }

# Run the Actor and wait for it to finish
run = client.actor("andinoworks/companies-using-technology").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 '{
  "technologies": [
    "Snowflake"
  ]
}' |
apify call andinoworks/companies-using-technology --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,andinoworks/companies-using-technology"
        }
    }
}
```

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/QHZwXkm6H6ZU5NalX/builds/qozdZ52PvWwoaHHOQ/openapi.json