# Instagram Search Users (`datamagnet/search-users`) Actor

Search for users by keyword and return matching profiles.

- **URL**: https://apify.com/datamagnet/search-users.md
- **Developed by:** [Datamagnet](https://apify.com/datamagnet) (community)
- **Categories:** Lead generation, Social media, Other
- **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

## User Search Scraper

User Search Scraper helps you find Instagram users by name, handle, or phrase and return the matching profiles in a clean, ready-to-use format. It is built for marketers, researchers, agencies, and creators who need fast Instagram user search results without manual digging. Use it to collect profile data, compare accounts, and optionally generate embed-safe media URLs for websites. If you need a simple Instagram user search scraper that delivers matching user profiles quickly, this actor is designed for that job.

### Key Features

- **Extract** matching Instagram user profiles from a single search keyword.
- **Collect** profile details such as username, full name, verification status, privacy status, and profile picture links.
- **Return** the source data exactly as provided, so you can review the original fields without losing detail.
- **Generate** embed-safe media URLs when you want image or video links that are easier to use on websites.
- **Support** brand, creator, and competitor research by turning a simple name or phrase into usable profile data.
- **Save** time by replacing manual Instagram searching with automated user discovery.
- **Export** results in formats that are easy to share with teams and clients.

### Use Cases

#### Influencer Discovery
Marketing teams use this actor to search for creators by name, handle, or niche phrase and quickly identify relevant Instagram profiles. The returned fields like `full_name`, `username`, `is_verified`, and `profile_pic_url` help teams shortlist creators before outreach.

#### Brand Monitoring
Brands can search for their own name, product name, or campaign phrase to find matching user profiles that may be related to their business. Fields such as `is_private`, `is_verified`, and `latest_reel_media` help teams understand whether an account is active, public, and worth reviewing.

#### Competitor Research
Agencies and analysts can search competitor names or related terms to discover official accounts and associated profiles. The output includes `id`, `username`, `full_name`, and `show_ring_award`, which makes it easier to compare account identity and profile presentation across competitors.

#### Lead List Building
Sales and partnership teams can search for industry keywords to find people and organizations that match a target audience. The profile data returned by the actor gives a fast starting point for building a contact list, prioritizing verified accounts, and filtering out private profiles.

#### Content and Audience Research
Creators and strategists can search for topics, public figures, or community terms to see which Instagram users appear in the results. The fields `unseen_count`, `latest_reel_media`, and `profile_pic_url_original` help users understand profile freshness and visual identity at a glance.

#### Website Embeds and Media Use
Publishers and web teams can turn on embed-safe media URLs when they need image links that are easier to place on websites. This is useful when building profile previews, internal dashboards, or content pages that need a cleaner media link for display.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| search_query | string | Yes | Enter the name, handle, or phrase you want to search for. | mrbeast |
| url_embed_safe | boolean | No | Turn this on if you want image or video links that are easier to embed on your website. These links work for a limited time. | false |

### Output

| Field | Type | Description |
|---|---|---|
| full_name | string | The person or account name shown on the profile. Useful for recognizing the right result quickly. |
| has_anonymous_profile_picture | boolean | Shows whether the profile uses a generic or anonymous profile image instead of a custom one. |
| id | string | The unique profile identifier returned with the result. Helpful for matching records across exports. |
| is_private | boolean | Tells you whether the account is private and may have limited visible content. |
| is_ring_creator | boolean | Indicates whether the profile has a special creator-related status. |
| is_verified | boolean | Shows whether the account has a verified badge. Useful for spotting official or notable profiles. |
| latest_reel_media | number | Indicates the most recent reel-related media value returned with the profile. Helpful for judging activity. |
| profile_pic_id | string | The identifier for the profile picture. Useful when comparing profile image records. |
| profile_pic_url | string | A media link for the profile picture that may be easier to use in websites or previews. |
| profile_pic_url_original | string | The original profile picture link returned by the source. |
| show_ring_award | boolean | Indicates whether a ring-style award or highlight is shown for the profile. |
| unseen_count | number | A count related to unseen items associated with the profile. Useful as a quick activity signal. |
| username | string | The account handle people use to find the profile on Instagram. |

### Sample Output

```json
{
  "full_name": "MrBeast",
  "has_anonymous_profile_picture": false,
  "id": "2278169415",
  "is_private": false,
  "is_ring_creator": false,
  "is_verified": true,
  "latest_reel_media": 0,
  "profile_pic_id": "1765328607101572916",
  "profile_pic_url": "https://ig.socialapi-v2.workers.dev/?q=Zk3YpkB9murhltrR5XJR5doCpX6umG8Rlt3RZyKh5Xgep0gMm0i-zjrtmEToBjfuOQ6omG8KmhBLBQpEOQ6Y4hSLBGcKBhlhBCvHiGpYOJnLBhvYihloihaLBh6oOQ8YBQ8t4tfRZe2eWEiYpQovpETMZe2e4tcH4EBLiG2fBGcH4E3YiqDxD0prD4xNBxb4iybqBx1_yQijZgbKjGD1zv1KlC1ZpX1kJ0DC3tLsGXojpJx4iyKqUGTLGc325Jx9jyx0c...",
  "profile_pic_url_original": "https://scontent-cph2-1.cdninstagram.com/v/t51.2885-19/31077884_211593632905749_1394765701385814016_n.jpg?stp=dst-jpg_e0_s150x150_tt6&efg=eyJ2ZW5jb2RlX3RhZyI6InByb2ZpbGVfcGljLmRqYW5nby41MDAuYzIifQ&_nc_ht=scontent-cph2-1.cdninstagram.com&_nc_cat=1&_nc_oc=Q6cZ2gEL71e93zpQ8TIYTV0H82IIaKqazG6Ss-Eur4dYA7...",
  "show_ring_award": false,
  "unseen_count": 0,
  "username": "mrbeast"
}
````

### How It Works

1. You enter a search keyword such as a name, handle, or phrase.
2. The actor searches for matching Instagram users automatically.
3. It gathers the profile details returned for each match.
4. If you enable embed-safe media URLs, it includes links that are easier to use on websites.
5. You receive the results in a clean format that is ready to review, filter, or export.

### Getting Started

Getting started is simple and does not require coding knowledge. Click **Try for free**, enter your search keyword, choose whether you want embed-safe media URLs, and click **Run**. In a short time, you will receive matching Instagram user profiles that you can review right away. Results are available in JSON, CSV, or Excel, making it easy to share with your team or import into your workflow.

### Frequently Asked Questions

#### Do I need technical skills?

No. This actor is designed for business users, marketers, researchers, and creators who want results without dealing with complicated setup. You only need to enter a search keyword and run it.

#### How fast does it run?

It is built for quick searches, so most runs finish fast enough for everyday research and lead-building tasks. The exact time depends on how broad your search term is and how many matching profiles are returned.

#### What format is the output?

You can work with the results in JSON, CSV, or Excel. That makes it easy to review the data yourself, share it with teammates, or move it into spreadsheets and reporting tools.

#### Is this legal to use?

It is your responsibility to use the results in a way that follows applicable laws, platform rules, and your organization’s policies. Many buyers use this kind of tool for research, monitoring, and internal analysis, but you should always review your own compliance requirements.

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

Yes, you can set it up to run on a schedule if you want regular searches for the same keyword or set of keywords. This is useful for ongoing brand monitoring, creator tracking, and recurring research workflows.

# Actor input Schema

## `search_query` (type: `string`):

Enter the name, handle, or phrase you want to search for.

## Actor input object example

```json
{
  "search_query": "mrbeast"
}
```

# 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 = {
    "search_query": "mrbeast"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamagnet/search-users").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 = { "search_query": "mrbeast" }

# Run the Actor and wait for it to finish
run = client.actor("datamagnet/search-users").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 '{
  "search_query": "mrbeast"
}' |
apify call datamagnet/search-users --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Search Users",
        "description": "Search for users by keyword and return matching profiles.",
        "version": "0.0",
        "x-build-id": "fPyZPc8yywFJW7O4v"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~search-users/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-search-users",
                "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~search-users/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-search-users",
                "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~search-users/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-search-users",
                "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": [
                    "search_query"
                ],
                "properties": {
                    "search_query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Enter the name, handle, or phrase you want to search for."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```