# X (Twitter) Similar Accounts Finder — No Login (`arjun_code/x-twitter-similar-accounts-finder`) Actor

Find accounts similar to any X (Twitter) user using X's native recommendations. No login, cookies, or API key required. Export ranked profiles with bios, follower counts, verification, professional categories, affiliations, websites, and profile links.

- **URL**: https://apify.com/arjun\_code/x-twitter-similar-accounts-finder.md
- **Developed by:** [Arjun AI](https://apify.com/arjun_code) (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 $1.40 / 1,000 similar x accounts

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?

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

## X (Twitter) Similar Accounts Finder — No Login

Turn one known X account into a ranked list of related profiles. Enter a username, `@handle`, or profile URL and get the accounts displayed in X's native **Similar to** recommendations—without providing an X login, cookies, or API key.

Unlike keyword search, this Actor starts from a specific account and follows X's own recommendation graph. It extracts only the direct **Similar to** module, not the seed profile or generic **Suggested for you** results.

### Why use this Actor?

- **X-native recommendations:** discover profiles X itself associates with the seed account.
- **No login setup:** users do not need to supply X credentials, cookies, or an API key.
- **Ranked results:** preserve X's original recommendation order in `similarity_rank`.
- **Multiple seed accounts:** research several creators, competitors, founders, brands, or experts in one run.
- **Clean profile data:** receive flat, analysis-ready fields instead of a nested raw user object.
- **Ready to export:** download results as JSON, CSV, Excel, XML, or RSS, or retrieve them through the Apify API.
- **Pay for successful profiles:** missing users and empty recommendation modules produce uncharged status records.

### Common use cases

- Find creators and influencers adjacent to an account you already know.
- Discover competitors, peer brands, founders, researchers, or subject-matter experts.
- Expand prospect and partnership lists without guessing more search keywords.
- Map a niche or community from several representative accounts.
- Enrich lead, creator, or market-research workflows with public profile metadata.

### Input

| Field | Type | Description | Default |
| --- | --- | --- | --- |
| `usernames` | string array | One X username, `@handle`, `x.com` URL, or `twitter.com` URL per line. Multiple seed accounts can be processed in one run. | `elonmusk` |
| `maxResultsPerUser` | integer | Maximum native similar accounts saved for each seed account. X currently exposes up to 15 direct results. | `15` |

Accepted formats:

```text
elonmusk
@elonmusk
https://x.com/elonmusk
https://twitter.com/elonmusk
```

Example input with multiple seed accounts:

```json
{
  "usernames": [
    "@AndrewYNg",
    "https://x.com/sama",
    "OpenAI"
  ],
  "maxResultsPerUser": 15
}
```

### Output

Each successful Dataset item represents one profile from the seed account's native **Similar to** module.

```json
{
  "status": "success",
  "seed_user_id": "216939636",
  "seed_screen_name": "AndrewYNg",
  "seed_profile_url": "https://x.com/AndrewYNg",
  "similarity_source": "x_connect_tab_similar_to",
  "similarity_rank": 1,
  "user_id": "4398626122",
  "screen_name": "OpenAI",
  "profile_url": "https://x.com/OpenAI",
  "name": "OpenAI",
  "description": "OpenAI’s mission is to ensure that artificial general intelligence benefits all of humanity.",
  "location": "",
  "followers_count": 5261434,
  "friends_count": 4,
  "tweets_count": 2104,
  "verified": false,
  "is_blue_verified": true,
  "professional_categories": [],
  "affiliation_name": "",
  "website_url": "https://openai.com"
}
```

Counts and optional profile fields in live results contain the values supplied by X at run time. The abbreviated example above focuses on the output structure.

#### Available data

| Group | Fields |
| --- | --- |
| Recommendation context | `seed_user_id`, `seed_screen_name`, `seed_profile_url`, `similarity_source`, `similarity_rank` |
| Identity | `user_id`, `screen_name`, `profile_url`, `name` |
| Biography | `description`, `description_entities`, `profile_description_language`, `bio_urls`, `bio_mentions`, `bio_hashtags` |
| Audience and activity | `followers_count`, `friends_count`, `tweets_count`, `media_count`, `favourites_count` |
| Verification and privacy | `verified`, `verified_type`, `is_blue_verified`, `protected`, `possibly_sensitive`, `account_label` |
| Professional profile | `professional_type`, `professional_categories`, `affiliation_name`, `affiliation_url`, `affiliation_badge_url` |
| Profile details | `location`, `created_at`, `website_url`, `profile_image_url`, `profile_banner_url`, `profile_image_shape` |
| Other native signals | `pinned_tweet_ids`, `subscription_eligible` |

The default Dataset view places the seed account, recommendation rank, handle, bio, professional category, follower count, verification, website, and profile link first for quick review.

### Result statuses

The Actor continues processing the remaining seed accounts when one input has no usable result.

| Status | Meaning | Charged as a result? |
| --- | --- | --- |
| `success` | One similar profile was returned and saved. | Yes |
| `not_found` | The requested seed username does not exist or is unavailable. | No |
| `no_results` | The seed account exists, but X did not expose a native Similar to module. | No |
| `error` | A request or response error prevented that seed account from being processed. | No |

Example `not_found` record:

```json
{
  "status": "not_found",
  "requested_username": "missing-user",
  "seed_user_id": "",
  "seed_screen_name": "",
  "seed_profile_url": "",
  "message": "X user @missing-user was not found or is unavailable."
}
```

### Run from the Apify Console

1. Open the Actor and click **Start**.
2. Enter one or more X usernames or profile URLs.
3. Choose up to 15 similar accounts per seed user.
4. Start the run and open the Dataset to preview, filter, or export the results.

### Run with the Apify API

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/arjun_code~x-twitter-similar-accounts-finder/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "usernames": ["AndrewYNg"],
    "maxResultsPerUser": 15
  }'
```

The run response contains `defaultDatasetId`, which you can use to retrieve the result items from the Dataset API.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("arjun_code/x-twitter-similar-accounts-finder").call(
    run_input={
        "usernames": ["AndrewYNg"],
        "maxResultsPerUser": 15,
    }
)

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

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('arjun_code/x-twitter-similar-accounts-finder').call({
    usernames: ['AndrewYNg'],
    maxResultsPerUser: 15,
});

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

### How it works

1. The Actor normalizes each username or profile URL.
2. It resolves the seed profile to its numeric X user ID.
3. It requests X's native Connect timeline using that ID as `contextualUserId`.
4. It extracts only entries from the direct **Similar to** module.
5. It flattens the returned public profiles and preserves their native order.

The Actor does not invent or calculate a similarity score. `similarity_rank` is the position supplied by X, where `1` is the first native recommendation.

### Pricing

This Actor uses **pay per event** pricing. On the Free plan, each successful similar-account profile costs **$0.002**, or **$2.00 per 1,000 results**. Higher Apify subscription tiers receive lower per-result prices.

| Apify plan | Price per successful profile | Price per 1,000 results |
| --- | ---: | ---: |
| Free | $0.0020 | $2.00 |
| Bronze | $0.0018 | $1.80 |
| Silver | $0.0016 | $1.60 |
| Gold | $0.0014 | $1.40 |
| Platinum | $0.0014 | $1.40 |
| Diamond | $0.0014 | $1.40 |

One `similar-account-result` event is charged for each successful profile saved to the Dataset. A small **$0.00005 Actor Start** event is charged once per run. `not_found`, `no_results`, and `error` status records are not charged as profile results, although the Actor Start charge still applies.

For example, requesting the maximum 15 recommendations for one seed account costs up to **$0.03005** on the Free plan when all 15 profiles are returned. Use `maxResultsPerUser` and Apify's **Maximum cost per run** setting to control spend. Apify platform usage is not added by this Actor's pricing configuration.

### Limitations

- X currently returns no more than 15 direct Similar to accounts for each seed profile through this surface.
- X controls recommendation order and availability, so results can change between runs.
- Some valid profiles do not have a native Similar to module and return `no_results`.
- X does not provide a numeric similarity percentage through this response.
- Protected, suspended, restricted, or incomplete profiles may expose fewer public fields.
- This Actor finds related accounts; it does not return tweets, followers, or following lists.

### Continue your X research workflow

| Goal | Actor |
| --- | --- |
| Discover public accounts by keyword, profession, niche, or location | [X (Twitter) People Search Scraper](https://apify.com/arjun_code/x-twitter-people-search-scraper) |
| Expand from a known profile through X's native Similar to recommendations | [X (Twitter) Similar Accounts Finder — No Login](https://apify.com/arjun_code/x-twitter-similar-accounts-finder) |
| Export followers or accounts followed by one or more profiles | [X Followers & Following Scraper — No Login](https://apify.com/arjun_code/x-twitter-followers-followings-scraper) |
| Inspect account origin, signup source, and username-change history | [X Twitter Account Origin Intelligence](https://apify.com/arjun_code/x-twitter-account-origin-scraper) |

A practical workflow is: find accounts by keyword, expand each seed through native Similar to recommendations, export selected audiences, then inspect origin signals for shortlisted profiles.

### Privacy and responsible use

The Actor exports public profile information returned by X. Private credentials and proxy configuration are managed by the Actor and are not requested through public input or written to the Dataset.

Use the data responsibly and comply with applicable laws, privacy requirements, X's terms, and Apify's terms. This independent Actor is not affiliated with, endorsed by, or sponsored by X Corp.

### Support

If a run fails or the output changes, open an issue on the Actor page and include the Apify run ID, input, and expected behavior. Do not include passwords, cookies, tokens, or other secrets.

# Actor input Schema

## `usernames` (type: `array`):

Enter one X account per line. Accepted examples: elonmusk, @elonmusk, or https://x.com/elonmusk.

## `maxResultsPerUser` (type: `integer`):

Maximum number of X-native Similar to accounts saved for each input user. X currently returns up to 15 direct matches.

## Actor input object example

```json
{
  "usernames": [
    "elonmusk"
  ],
  "maxResultsPerUser": 15
}
```

# Actor output Schema

## `results` (type: `string`):

Accounts returned by X's native Similar to module.

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

// Run the Actor and wait for it to finish
const run = await client.actor("arjun_code/x-twitter-similar-accounts-finder").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 = { "usernames": ["elonmusk"] }

# Run the Actor and wait for it to finish
run = client.actor("arjun_code/x-twitter-similar-accounts-finder").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 '{
  "usernames": [
    "elonmusk"
  ]
}' |
apify call arjun_code/x-twitter-similar-accounts-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arjun_code/x-twitter-similar-accounts-finder"
        }
    }
}

```

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/xGldkorKApEijpEqx/builds/KvOXCLRXDffXLt1BW/openapi.json