# X (twitter) Company Account Affiliates (`datamagnet/x-twitter-company-account-affiliates`) Actor

Get the list of affiliates for a corporate account in a simple, downloadable format.

- **URL**: https://apify.com/datamagnet/x-twitter-company-account-affiliates.md
- **Developed by:** [Datamagnet](https://apify.com/datamagnet) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

## Affiliate List Scraper

Affiliate List Scraper helps you quickly collect the affiliates linked to a corporate account and save them in a simple, downloadable format. It is built for marketers, researchers, sales teams, and analysts who need reliable affiliate data from X without manually checking profiles one by one. Enter a username, choose how many records you want, and the actor gathers the affiliate list for you with automatic continuation through all available pages. The result is raw affiliate data you can review, filter, and export for lead generation, account research, and audience analysis.

### Key Features

- **Extract** affiliates linked to a specific corporate account in one run.
- **Collect** multiple pages of results automatically until the list is complete.
- **Limit** the number of records returned so you stay focused on the exact amount you need.
- **Return** the source data exactly as provided, preserving useful profile details.
- **Support** repeatable research workflows for sales, marketing, and competitive analysis.
- **Export** results in a format that is easy to download, share, and analyze.
- **Start** from a saved position when you want to continue a previous collection.

### Use Cases

#### Lead Generation
Sales teams can use this actor to build targeted prospect lists from the affiliates connected to a corporate account. The returned fields such as `name`, `screen_name`, `user_id`, and `description` help identify the right people quickly and understand their role or relevance before outreach.

#### Market Research
Researchers and analysts can study the affiliate network around a brand or public figure to understand audience relationships and account structure. Fields like `followers_count`, `friends_count`, `statuses_count`, and `media_count` help reveal account size, activity level, and influence.

#### Competitive Intelligence
Competitive intelligence teams can compare affiliate networks across different accounts to spot patterns, overlaps, and growth signals. By reviewing profile details such as `description`, `screen_name`, and `followers_count`, they can better understand who is connected to a competitor and how visible those accounts are.

#### Influencer and Creator Discovery
Agencies and brand teams can use the output to find accounts associated with a known corporate profile and evaluate whether they fit campaign goals. The combination of `name`, `profile_image`, `description`, and audience metrics makes it easier to shortlist relevant creators or partners.

#### CRM Enrichment
Operations teams can enrich internal records by matching affiliate profiles to existing contacts or account lists. The `user_id` and `screen_name` fields make matching easier, while profile and audience data add context that supports segmentation and prioritization.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| Cursor | string | No | Continue from a previous page if you already have a saved position. | eyJwYWdlIjoyfQ== |
| Screen name | string | Yes | The account username whose affiliates you want to retrieve. | elonmusk |
| Max results | integer | No | The maximum number of affiliate records to collect before stopping. | 100 |

### Output

| Field | Type | Description |
|---|---|---|
| name | string | The display name of the affiliate account, useful for identifying the person or brand at a glance. |
| user_id | string | The account’s unique identifier, helpful for matching records across systems. |
| description | string | The profile bio or short description, which gives context about who the account belongs to. |
| media_count | integer | The number of posts or media items associated with the account, showing how active it is. |
| screen_name | string | The account username, useful for searching, tagging, or matching records. |
| friends_count | integer | The number of accounts this profile follows, which can indicate networking behavior. |
| profile_image | string or null | The profile picture link or no image value if one is not available. |
| statuses_count | integer | The total number of posts made by the account, showing overall activity. |
| followers_count | integer | The number of followers the account has, which helps estimate reach and influence. |

### Sample Output

```json
{
  "name": "Elon Musk",
  "user_id": "44196397",
  "description": "Starmind",
  "media_count": 4589,
  "screen_name": "elonmusk",
  "friends_count": 1366,
  "profile_image": null,
  "statuses_count": 105263,
  "followers_count": 240727260
}
````

### How It Works

1. You enter the username of the corporate account you want to research.
2. You choose how many affiliate records you want to collect, or leave the default limit in place.
3. The actor gathers the affiliate list and keeps going through additional pages automatically.
4. It stops when it reaches your chosen limit or when there are no more affiliates to collect.
5. You receive the results in a clean downloadable format that is ready for review or export.

### Getting Started

Getting started is simple and does not require coding knowledge. Click **Try for free**, enter the username you want to check, adjust the maximum results if needed, and click **Run**. The actor will collect the affiliate list for you and make the results available for download. You can work with the output in JSON, CSV, or Excel depending on how you want to review or share the data.

### Frequently Asked Questions

#### Do I need technical skills?

No. This actor is designed for business users who want results without dealing with complicated setup. Just enter the username, choose your limit, and run it.

#### How fast does it run?

Speed depends on how many affiliate records are available and how many pages need to be collected. Smaller requests finish quickly, while larger collections take a bit longer because the actor keeps gathering results until it reaches your limit or the list ends.

#### What format is the output?

The results are available in downloadable formats that are easy to work with, including JSON, CSV, and Excel. This makes it simple to review the data in spreadsheets, share it with teammates, or import it into other tools.

#### Is this legal to use?

You should always use the data in a way that follows applicable laws, platform rules, and your organization’s policies. This actor is intended for legitimate research, analysis, and business workflows, and you are responsible for using the results appropriately.

#### Can I schedule it to run automatically?

Yes, you can set it up to run on a schedule if you want regular updates. This is useful for ongoing monitoring, recurring research, or keeping affiliate lists fresh over time.

# Actor input Schema

## `screenname` (type: `string`):

The account name to look up affiliates for.

## `max_results` (type: `integer`):

Maximum number of results to collect.

## Actor input object example

```json
{
  "screenname": "x",
  "max_results": 10
}
```

# 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 = {
    "screenname": "x"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamagnet/x-twitter-company-account-affiliates").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 = { "screenname": "x" }

# Run the Actor and wait for it to finish
run = client.actor("datamagnet/x-twitter-company-account-affiliates").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 '{
  "screenname": "x"
}' |
apify call datamagnet/x-twitter-company-account-affiliates --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datamagnet/x-twitter-company-account-affiliates",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X (twitter) Company Account Affiliates",
        "description": "Get the list of affiliates for a corporate account in a simple, downloadable format.",
        "version": "0.0",
        "x-build-id": "28mDIsLSpaRoh1nXF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~x-twitter-company-account-affiliates/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-x-twitter-company-account-affiliates",
                "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/datamagnet~x-twitter-company-account-affiliates/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-x-twitter-company-account-affiliates",
                "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/datamagnet~x-twitter-company-account-affiliates/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-x-twitter-company-account-affiliates",
                "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": [
                    "screenname"
                ],
                "properties": {
                    "screenname": {
                        "title": "Screen name",
                        "type": "string",
                        "description": "The account name to look up affiliates for."
                    },
                    "max_results": {
                        "title": "Max results",
                        "type": "integer",
                        "description": "Maximum number of results to collect.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
