# Partnerbase Partnerships Scraper (`automation-lab/partnerbase-company-partnerships`) Actor

Export visible Partnerbase company-to-partner relationships with names, pair URLs, partnership types and available employee, industry and source-link context. Bounded snapshots for alliance mapping.

- **URL**: https://apify.com/automation-lab/partnerbase-company-partnerships.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 96.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.44 / 1,000 item extracteds

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

## Partnerbase Partnerships Scraper

Export **partnerbase partnerships** from supplied company pages into typed relationship rows for recurring alliance mapping. Each row connects a company to one visible partner, with the relationship type, company and pair URLs, and any employee, industry and external source-link context shown in the table.

This is a **bounded initial-page snapshot**, not a guaranteed complete ecosystem. Partnerbase currently displays up to 50 relationships in the initial company table. The Actor does not click Load More or paginate, and a company's advertised total can be much larger than the exported count.

### Who is it for?

- Alliance teams refreshing a company watchlist before account planning.
- Market researchers comparing visible technology and channel partner relationships.
- Revenue operations teams loading source-linked relationship rows into spreadsheets or CRM enrichment pipelines.

### Why use this Actor?

It returns normalized relationship records rather than raw HTML. Company and pair links are validated, mobile duplicates are excluded, and coverage fields distinguish a snapshot from an advertised ecosystem total. No source login, browser session, paid API key or proxy configuration is needed.

### Getting started

1. Choose a company page such as `https://www.partnerbase.com/salesforce`.
2. Add it to Company URLs. Use company pages, not two-company pair pages.
3. Set a global Maximum relationships limit.
4. Run the Actor and inspect the default dataset.
5. Download JSON, CSV or Excel through Apify, or consume the dataset in your pipeline.

```json
{
  "startUrls": [{"url": "https://www.partnerbase.com/salesforce"}],
  "maxItems": 10
}
```

### Input parameters

| Parameter | Default | Behavior |
| --- | --- | --- |
| `startUrls` | Required | 1–20 HTTPS Partnerbase company URLs, processed in order. Duplicate normalized URLs are fetched once. |
| `maxItems` | 100 | Integer 1–1000; global exported relationship cap across companies after within-company deduplication. |

Only `url` is used from each request-list entry. Editor metadata (`method`, `payload`, `headers`, `userData`) is ignored; the Actor always uses GET. URLs must contain one company slug. Query parameters, fragments, credentials, other domains and pair/detail paths are rejected. Zero/unlimited limits and unknown input fields are rejected. A high maxItems value does not enable pagination. Billing or runtime limits can stop a run before its collection cap.

### Extracted data

| Field | Meaning |
| --- | --- |
| `companyName`, `companyUrl` | Identity of the supplied company. |
| `partnerName`, `partnerUrl` | Identity of the visible partner. |
| `partnershipUrl` | Partnerbase details URL for the pair; not visited by this Actor. |
| `partnershipType` | Visible type, such as Technology or Channel; null if absent. |
| `employeeRange` | Displayed partner employee range, not an exact headcount; nullable. |
| `industry` | Displayed partner industry; nullable. |
| `sourceUrl` | Optional external attribution URL; not fetched or independently verified. |
| `totalPartners` | Source-advertised company total, not export count; nullable. |
| `visiblePartners` | Distinct rows in the fetched initial table before maxItems truncation. |
| `snapshotLimited` | True when the advertised total exceeds visible rows, the total is unknown, or the user cap truncates the table. |
| `scrapedAt` | UTC timestamp for this company snapshot. |

### Output example

A real local Salesforce snapshot returned:

```json
{
  "companyName": "Salesforce",
  "companyUrl": "https://www.partnerbase.com/salesforce",
  "partnerName": "Google",
  "partnerUrl": "https://www.partnerbase.com/google",
  "partnershipUrl": "https://www.partnerbase.com/google/salesforce",
  "partnershipType": "Channel",
  "employeeRange": "10,001+",
  "industry": "Software & Tech",
  "sourceUrl": "https://www.salesforce.com/news/press-releases/2023/06/07/salesforce-google-ai-partnership/",
  "totalPartners": 6622,
  "visiblePartners": 50,
  "snapshotLimited": true,
  "scrapedAt": "2026-10-03T20:11:29.799Z"
}
```

Source values may change. The record is an observation of Partnerbase's table, not independent confirmation of a current commercial partnership.

### How much does it cost to export Partnerbase partnerships?

Pricing is pay per event: **$0.005 per valid run started**, plus one `item` event per exported relationship. No separate fee is charged for firmographic fields or attribution links. Invalid input fails before the start event; a valid run with no relationships still incurs the start event.

| Apify spend tier | Price per relationship |
| --- | ---: |
| FREE | $0.00276 |
| BRONZE | $0.0024 |
| SILVER | $0.001872 |
| GOLD | $0.00144 |
| PLATINUM | $0.00144 |
| DIAMOND | $0.00144 |

At BRONZE, 10 exported relationships cost approximately **$0.029**, 50 cost **$0.125**, and 100 cost **$0.245**, including the start event. At FREE, 10 cost approximately **$0.0326**. These are estimates; check the current Pricing tab and your billing limit. Spend tiers depend on qualifying aggregate monthly Apify Store spend, not this Actor's private volume schedule. Infrastructure is covered by the Actor's event pricing; no external subscription is required.

### Limits and failure behavior

Only the first visible table is collected. No history, monitoring, alerts, discovery search, guaranteed complete ecosystems or automated change detection is included. `snapshotLimited: false` means the source's displayed total agrees with the captured table; it is not independent proof of completeness.

A company-to-partner row is unique within that company snapshot. If both companies are supplied, the same pair may appear in two company contexts; use `partnershipUrl` to collapse those contexts downstream if desired.

Requests are sequential with a 30-second request timeout and at most three attempts for network failures, HTTP 429 or server errors. Stable client errors and parser/challenge failures stop the run. Previously exported records from a failed run are partial; do not treat them as a complete successful watchlist.

A recognized company page with an explicit zero partner count is a valid empty snapshot. Unrecognized pages or missing tables with positive/unknown counts fail instead of silently returning zero rows.

### Integrations

Use Apify schedules to refresh the same input watchlist. Save each successful dataset externally and compare `companyUrl` + `partnerUrl`; this Actor does not maintain historical state. An absent relationship in a later bounded snapshot is not proof that the partnership ended.

Send dataset rows to Google Sheets, Airtable, Make, Zapier or a CRM pipeline using their Apify integrations. Preserve pair/source URLs and scrape timestamps for auditability. Export full datasets outside AI chat context when larger outputs are needed.

### API usage

#### cURL

```bash
curl -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  'https://api.apify.com/v2/acts/automation-lab~partnerbase-company-partnerships/run-sync-get-dataset-items' \
  -d '{"startUrls":[{"url":"https://www.partnerbase.com/salesforce"}],"maxItems":10}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/partnerbase-company-partnerships').call({
  startUrls: [{ url: 'https://www.partnerbase.com/salesforce' }], maxItems: 10
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 10 });
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/partnerbase-company-partnerships').call(
    run_input={'startUrls': [{'url': 'https://www.partnerbase.com/salesforce'}], 'maxItems': 10})
print(client.dataset(run['defaultDatasetId']).list_items(limit=10).items)
```

### MCP usage

#### Claude Code

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/partnerbase-company-partnerships"
```

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

Use your client's HTTP MCP settings with Apify authentication. Clients using `mcpServers` can use:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/partnerbase-company-partnerships"
    }
  }
}
```

VS Code uses its `servers` configuration format; put the same URL in an HTTP server entry. Keep authentication in client secret settings, not committed JSON.

Example prompt: “Export 10 visible Salesforce partner relationships and summarize the types, keeping source links and the coverage warning.”

Discover actual tools and argument schemas with scoped `tools/list`. Actor selection also adds run/storage helper tools; it does not expose exactly one tool. Discovery is read-only and is not permission to start a run.

For an authorized invocation, start once and retain the run ID, status and storage IDs. These are metadata, not result rows. If pending, follow that same run with bounded backoff (2, 4, 8 seconds, capped at 10) and a total deadline such as 120 seconds; do not restart on timeout. `call-actor` waits at most 45 seconds, so client timeouts must allow transport margin. At the deadline report pending with its run ID.

After success, read the returned dataset with explicit limit, offset and fields. Example consumer budget: pages of 20 rows, at most 100 source rows or 64 KiB serialized UTF-8 result content admitted to model context, whichever comes first. Enforce the byte ceiling host-side; if your client cannot intercept oversized responses, do not claim a hard guarantee. Report truncation and continuation offset. This consumer context budget does not change Actor collection limits.

### Legality, responsible use and data handling

This unofficial Actor is not affiliated with or endorsed by Partnerbase or Crossbeam. Use the results responsibly and comply with applicable law, source terms and your data obligations. It collects public business relationship context, not personal contact lists. It does not use AI at runtime or send scraped rows to an AI provider.

Company URLs are sent to Partnerbase; outputs and logs are stored in your Apify run storage according to your account settings. The Actor creates no independent historical cache or session store. Delete datasets, key-value stores and logs through Apify when no longer needed; platform backups follow Apify's policy.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair; secret fields and URL queries are removed and reports are retained for 30 days. No diagnostic credentials are exposed as inputs.

### FAQ and troubleshooting

**Why did I receive 50 rows when totalPartners says thousands?** Only the initial visible page is exported. This is intentional bounded coverage, not full pagination.

**Can I supply a pair URL or filter by industry?** No. Supply company URLs; apply downstream filters to exported rows. Unknown fields are rejected rather than ignored.

**Why did a run fail?** Check that URLs identify real company pages without queries or fragments. A missing company, upstream challenge, source change or exhausted transient retries fails visibly. Inspect the run log and any partial rows.

**Can I track changes?** Schedule runs and compare successful snapshots externally. Source ordering and limited coverage can change; missing rows do not establish partnership termination.

### Related workflows

This is a standalone alliance-relationship source. Company-directory Actors answer different firmographic questions and are not substitutes for partnership records. Find other tools in the [automation-lab portfolio](https://apify.com/automation-lab) when you need a separate enrichment workflow.

### Support

For a defect, use the Actor's Apify Issues tab and include your run URL, public company URL and expected behavior. Do not include passwords or private credentials.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/partnerbase-company-partnerships/changelog.md

# Actor input Schema

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

Supply 1–20 HTTPS partnerbase.com company URLs with one slug. Pair/detail URLs, queries and fragments are rejected. Duplicate URLs are normalized and fetched once. Pages are processed in input order; only the initial visible partner table is exported (currently up to 50 rows/company), without Load More pagination. Only url is used from each entry: editor metadata such as method, payload, headers and userData is ignored. Requests always use GET.

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

Global run cap on exported relationship rows across all supplied companies, after within-company deduplication. Default 100; integer 1–1000. Zero/unlimited is unsupported. Reaching the cap stops subsequent company fetches. Increasing this does not bypass the initial-page source cap or guarantee full coverage. Billing/runtime limits may stop earlier.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.partnerbase.com/salesforce"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Bounded initial-page relationship rows.

# 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://www.partnerbase.com/salesforce"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/partnerbase-company-partnerships").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://www.partnerbase.com/salesforce" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/partnerbase-company-partnerships").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 '{
  "startUrls": [
    {
      "url": "https://www.partnerbase.com/salesforce"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/partnerbase-company-partnerships --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/partnerbase-company-partnerships"
        }
    }
}
```

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/eIjmZJVuRbmgCzFcJ/builds/X7YjqYb16xesjrS8Q/openapi.json