# Instagram Search Hashtags ✅ (`datamagnet/hashtag-search`) Actor

Search Instagram hashtags by keyword and get the matching hashtag results exactly as returned by the source. Use it to discover hashtag ideas for social posts, research, and trend tracking without manual searching.

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

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Hashtag Searcher — Instagram Hashtag Scraper

Find Instagram hashtags related to a keyword and get the matching hashtag results in a ready-to-use format. Hashtag Searcher is built for marketers, creators, researchers, and social media managers who want fast hashtag discovery without manual searching. Use it to collect Instagram hashtag data for content planning, trend tracking, and post optimization. It returns the matching hashtag results exactly as provided by the source, so you can review and reuse the data with confidence.

### Key Features

- **Extract** related Instagram hashtags from a keyword you provide.
- **Collect** hashtag results in a clean format that is easy to review and share.
- **Discover** new hashtag ideas for social posts, campaigns, and content calendars.
- **Support** trend research by showing which hashtags match your topic.
- **Save** time by replacing manual hashtag searching with automated collection.
- **Review** raw hashtag details exactly as returned, with no extra interpretation.
- **Reuse** the output for reporting, planning, and audience research.

### Use Cases

#### Social Media Content Planning
Social media managers use this actor to find hashtag ideas for upcoming posts. By entering a keyword like “summer,” they can quickly see related hashtags such as `summer16` or `summerwear` and decide which ones fit a campaign theme. The returned fields like `name` and `media_count` help them choose hashtags that are relevant and active.

#### Trend Tracking
Brand and content teams use the results to monitor how hashtag ideas connect to a topic over time. The `media_count` field gives a quick sense of how widely a hashtag is used, which helps teams compare popularity and spot stronger options. This is useful when deciding whether to use broad hashtags or more specific ones.

#### Influencer and Creator Research
Creators and influencer managers can use the actor to discover hashtags that match a niche or seasonal topic. The `name` field shows the exact hashtag, while `allow_following` and `profile_pic_url` provide additional context from the source. This helps creators build more targeted posts and improve discoverability.

#### Campaign Brainstorming
Marketing teams often need fresh hashtag ideas before launching a promotion. This actor helps them gather matching hashtags from a single keyword so they can build a shortlist for ads, organic posts, and branded content. The raw results make it easy to compare options without guessing.

#### Competitive Content Analysis
Analysts can use the output to understand which hashtag variations appear around a topic. By reviewing the returned hashtag names and their usage counts, they can identify patterns that may inform content strategy. This is especially helpful when comparing different wording choices for the same theme.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| search_query | string | Yes | Enter a word or phrase to find related hashtags. | summer |

### Output

| Field | Type | Description |
|---|---|---|
| allow_following | boolean | Shows whether the hashtag can be followed from the source result. Useful if you want to understand how the hashtag behaves in the platform. |
| id | string | The unique identifier for the hashtag result. Helpful for keeping records or matching the same hashtag later. |
| media_count | number | The number of posts associated with the hashtag. This helps you judge how popular or active the hashtag is. |
| name | string | The hashtag text itself, without the # symbol. This is the main value most buyers want to review and reuse. |
| profile_pic_url | string or null | A profile image link if one is available for the result. If it is null, no image was provided. |

### Sample Output

```json
{
  "allow_following": false,
  "id": "17843706556001073",
  "media_count": 1988163,
  "name": "summer16",
  "profile_pic_url": null
}
````

### How It Works

1. You enter a keyword such as a topic, season, product type, or campaign theme.
2. The actor searches for hashtags related to that keyword.
3. It gathers the matching hashtag results and keeps them in the same form as the source.
4. You review the returned hashtag names and usage counts to find the best options.
5. You export or reuse the results in your workflow for planning, research, or reporting.

### Getting Started

Getting started is simple and does not require coding knowledge. Click **Try for free**, enter your search keyword, and click **Run**. In a short time, your hashtag results will be ready to review and download. You can work with the output in JSON, CSV, or Excel, depending on how you prefer to analyze or share the data.

### Frequently Asked Questions

#### Do I need technical skills?

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

#### How fast does it run?

It usually runs quickly because it performs one focused search based on your keyword. The exact time can vary depending on how busy the source is and how many matching results are returned.

#### What format is the output?

The results are available in formats that are easy to work with, including JSON, CSV, and Excel. That makes it simple to review the hashtag names, usage counts, and other returned fields in the tool you already use.

#### Is this legal to use?

This actor is intended for lawful business, research, and content planning use. You are responsible for making sure your use follows applicable laws, platform rules, and your own internal policies.

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

Yes, you can set it up to run on a schedule if you want regular hashtag research or trend tracking. This is useful for teams that want fresh results every day, week, or month without manual work.

# Actor input Schema

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

Enter a word or phrase to find related hashtags.

## Actor input object example

```json
{
  "search_query": "summer"
}
```

# 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": "summer"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Search Hashtags ✅",
        "description": "Search Instagram hashtags by keyword and get the matching hashtag results exactly as returned by the source. Use it to discover hashtag ideas for social posts, research, and trend tracking without manual searching.",
        "version": "0.0",
        "x-build-id": "9ypasMebPQ6yjufLG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~hashtag-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-hashtag-search",
                "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~hashtag-search/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-hashtag-search",
                "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~hashtag-search/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-hashtag-search",
                "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 a word or phrase to find related hashtags."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
