# X (twitter) Community Members List (`datamagnet/x-twitter-community-members-list`) Actor

Get the members of a community in a simple, downloadable list.

- **URL**: https://apify.com/datamagnet/x-twitter-community-members-list.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

## Community Members List scraper

Get a clean, downloadable list of members from a chosen community with the Community Members List scraper. It is built for marketers, researchers, community managers, and growth teams who need a simple way to collect community member data without manual copying. Use it to extract community members, review who belongs to a group, and export the results for analysis, outreach, or reporting. The actor automatically handles longer member lists so you can focus on the data, not the collection process.

### Key Features

- Extract community members into a clean, easy-to-review list.
- Collect only the number of members you need with a simple maximum limit.
- Export member data for spreadsheets, reports, and internal workflows.
- Save time by avoiding manual copying and repeated lookups.
- Handle longer member lists automatically so you get complete results up to your chosen limit.
- Review community membership in a format that is simple for non-technical teams to use.
- Support repeatable data collection for ongoing research and monitoring.

### Use Cases

#### Community Research
Community managers and analysts use this actor to understand who belongs to a specific community. The returned member list helps them review membership size, identify patterns, and compare communities over time. Because the output is clean and downloadable, it is easy to share with teammates or include in reports.

#### Audience Analysis
Marketing teams can collect community member records to better understand the audience around a niche topic or brand. By reviewing the member list, they can spot recurring profiles, assess community relevance, and decide whether the group is worth engaging with. This is especially useful when planning campaigns or partnerships.

#### Lead Qualification
Sales and growth teams often need a quick way to see whether a community contains people relevant to their target market. The member list gives them a practical starting point for qualification and prioritization. Instead of manually checking profiles one by one, they can export the results and review them in a structured way.

#### Competitive Intelligence
Businesses tracking competitor communities can use this actor to see who is participating in a chosen group. The member list can reveal audience overlap, community size, and engagement potential. That information helps teams make smarter decisions about positioning, outreach, and community strategy.

#### Internal Reporting
Operations and community teams can use the output to create simple membership reports for stakeholders. The returned community ID and total members returned make it easy to document what was collected and when. This supports recurring reporting without extra manual work.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| community_id | string | Yes | Paste the ID of the community whose members you want to collect. | 1493290339532222469 |
| max_results | integer | No | Limit how many members the actor should return in total. | 10 |

### Output

| Field | Type | Description |
|---|---|---|
| community_id | string | The community you selected, so you can easily match the results to the right group. |
| members | array | A list of cleaned member records that can be reviewed, filtered, or exported. |
| total_members_returned | integer | The total number of members included in the final result set. |
| run_status | string | A simple status message showing whether the collection finished successfully. |
| pagination_handled | boolean | Indicates whether the actor automatically continued through longer member lists behind the scenes. |

### Sample Output

```json
{
  "community_id": "1493290339532222469",
  "members": [
    {
      "member_id": "u_102938",
      "name": "Alex Johnson",
      "username": "alexj",
      "profile_url": "https://example.com/profiles/alexj",
      "joined_at": "2024-05-18T10:22:31Z"
    }
  ],
  "total_members_returned": 1,
  "run_status": "completed",
  "pagination_handled": false
}
````

### How It Works

1. You enter the community ID for the group whose members you want to collect.
2. You choose how many members you want returned in total, or keep the default limit.
3. The actor gathers the member list and continues automatically if more results are needed to reach your limit.
4. The results are cleaned and organized into a simple list that is easy to review.
5. You download the output and use it in spreadsheets, reports, or other business workflows.

### Getting Started

Getting started is simple and does not require coding knowledge. Click **Try for free**, paste in the community ID, choose your maximum results if needed, and click **Run**. In a short time, your member list will be ready to download and review. Results are available in JSON, CSV, or Excel, making it easy to work with the data in the format your team prefers.

### Frequently Asked Questions

#### Do I need technical skills?

No. This actor is designed for business users, researchers, and community teams who want a straightforward way to collect member lists. You only need to provide the community ID and choose how many results you want.

#### How fast does it run?

Most runs finish quickly, especially when you request a small number of members. Larger lists may take a bit longer because the actor keeps collecting results until it reaches your chosen limit.

#### What format is the output?

You can download the results in JSON, CSV, or Excel. That makes it easy to review the data in a spreadsheet, share it with teammates, or import it into your own reporting workflow.

#### Is this legal to use?

You should always use collected data responsibly and follow the rules that apply to your use case, including privacy and platform policies. This actor is intended for legitimate research, analysis, and operational workflows. If you plan to use the data for outreach or commercial purposes, make sure your process complies with applicable laws and internal policies.

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

Yes, you can set it up to run on a schedule if you need regular updates. That is useful for recurring reports, ongoing community tracking, or periodic checks of membership changes.

# Actor input Schema

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

Limit how many members to return in total.

## `community_id` (type: `string`):

Paste the ID of the community whose members you want to collect.

## Actor input object example

```json
{
  "max_results": 10,
  "community_id": "1493290339532222469"
}
```

# 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 = {
    "community_id": "1493290339532222469"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamagnet/x-twitter-community-members-list").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 = { "community_id": "1493290339532222469" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X (twitter) Community Members List",
        "description": "Get the members of a community in a simple, downloadable list.",
        "version": "0.0",
        "x-build-id": "rKVKHF9W0GEUQpOxw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~x-twitter-community-members-list/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-x-twitter-community-members-list",
                "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-community-members-list/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-x-twitter-community-members-list",
                "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-community-members-list/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-x-twitter-community-members-list",
                "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": [
                    "community_id"
                ],
                "properties": {
                    "max_results": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Limit how many members to return in total.",
                        "default": 10
                    },
                    "community_id": {
                        "title": "Community ID",
                        "type": "string",
                        "description": "Paste the ID of the community whose members you want to collect."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
