# Telegram Username Marketplace Search - Fragment (`maged120/fragment-marketplace-search`) Actor

Search Fragment collectible Telegram usernames by keyword and get every match with its status (available, on auction, for sale, or sold), price in TON and USD, and auction end time. Accepts multiple queries per run. API-ready.

- **URL**: https://apify.com/maged120/fragment-marketplace-search.md
- **Developed by:** [Maged](https://apify.com/maged120) (community)
- **Categories:** Automation, Other
- **Stats:** 6 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.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

### What does Telegram Username Marketplace Search do?

**Telegram Username Marketplace Search** turns a keyword into a ready-to-use list of collectible Telegram usernames. Enter a search term — like `king`, `crypto`, or your brand name — and get back every matching username with its **status** (on auction, for sale, or sold), its **price in TON and USD**, and the **auction end time** when it's on auction.

It accepts **multiple search queries per run**, so you can scan a whole list of keywords in one go. Run it on the [Apify platform](https://apify.com) to schedule searches, call it from the API, and get reliable results on large queries with built-in proxy rotation.

### Why use Telegram Username Marketplace Search?

- **Find deals** — surface usernames that are on auction or for sale for a keyword, sorted by price.
- **Discover handles** — find short, brandable, keyword-based usernames worth registering or bidding on.
- **Market research** — see what comparable usernames sell for and what's currently listed.
- **Bulk keywords** — search many terms at once and export everything to one dataset.

### How to use Telegram Username Marketplace Search

1. Open the Actor and go to the **Input** tab.
2. Enter one or more **search queries**, one per line.
3. Pick a **Status** (all, on auction, for sale, or sold) and a **Sort** order.
4. Press **Start**.
5. When the run finishes, open the **Output** tab or download the dataset.

### Input

| Field | Description |
| --- | --- |
| **Search queries** | Keywords to search for, one per line (up to 100). |
| **Status** | Which listings to return: all, on auction, for sale, or sold. |
| **Sort by** | Relevance, price (low→high or high→low), recently listed, or auction ending soon. |
| **Max results per query** | Cap the number of usernames per query (0 = no limit). |
| **Proxy configuration** | Proxy used for the search. The default (Apify residential proxy) is recommended. |

#### Input example

```json
{
  "queries": ["king", "crypto"],
  "statusFilter": "for_sale",
  "sort": "price_asc",
  "maxResultsPerQuery": 50,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

### Output

Each matching username produces one record. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Output example

```json
[
  {
    "query": "king",
    "username": "dmw_king",
    "status": "on_auction",
    "for_sale": true,
    "price_ton": 11,
    "price_usd": 16.90,
    "auction_ends_at": "2026-07-02T10:34:41+00:00",
    "url": "https://fragment.com/username/dmw_king"
  },
  {
    "query": "king",
    "username": "kingp2p",
    "status": "for_sale",
    "for_sale": true,
    "price_ton": 80,
    "price_usd": 122.43,
    "auction_ends_at": null,
    "url": "https://fragment.com/username/kingp2p"
  }
]
```

#### Data fields

| Field | Description |
| --- | --- |
| `query` | The search query this result came from. |
| `username` | The matching username. |
| `status` | One of `on_auction`, `for_sale`, or `sold`. |
| `for_sale` | `true` when the username can be bought right now. |
| `price_ton` | Price / minimum bid in TON. |
| `price_usd` | Approximate price in USD. |
| `auction_ends_at` | Auction end time (ISO 8601), for usernames on auction. |
| `url` | Link to the username's marketplace page. |

### How much does it cost?

Each search is lightweight, so runs are inexpensive — you can start on the **Apify free tier** and only pay for what you use. Use **Max results per query** and the **Status** filter to keep only the records you need.

### Tips

- Use **Status: For sale** or **On auction** with **Sort: Price low to high** to find the cheapest available handles fast.
- Pass a list of brand or keyword variations as multiple queries to cover more ground in one run.
- Schedule the Actor to re-run your keywords and track new listings over time.

### FAQ and support

**Is this legal?** The Actor only reads publicly available marketplace information about username status and pricing.

**How many results can I get per query?** The marketplace returns a large batch of matches per query; use **Max results per query** to cap it.

**Found an issue or need a custom version?** Open the **Issues** tab on the Actor's page — feedback and custom requests are welcome.

# Actor input Schema

## `queries` (type: `array`):

Keywords to search for. Each query returns the matching collectible usernames. Enter one query per line.

## `statusFilter` (type: `string`):

Which listings to return for each query.

## `sort` (type: `string`):

Order of the results within each query.

## `maxResultsPerQuery` (type: `integer`):

Limit how many usernames to return for each query. Set 0 for no limit.

## `proxyConfiguration` (type: `object`):

Proxy settings used for the search. Keeping the default (Apify residential proxy) gives the most reliable results.

## Actor input object example

```json
{
  "queries": [
    "king"
  ],
  "statusFilter": "for_sale",
  "sort": "",
  "maxResultsPerQuery": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing one record per matching username.

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

// Run the Actor and wait for it to finish
const run = await client.actor("maged120/fragment-marketplace-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 = { "queries": ["king"] }

# Run the Actor and wait for it to finish
run = client.actor("maged120/fragment-marketplace-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 '{
  "queries": [
    "king"
  ]
}' |
apify call maged120/fragment-marketplace-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Username Marketplace Search - Fragment",
        "description": "Search Fragment collectible Telegram usernames by keyword and get every match with its status (available, on auction, for sale, or sold), price in TON and USD, and auction end time. Accepts multiple queries per run. API-ready.",
        "version": "0.1",
        "x-build-id": "1la1DtbwueLfNoRzw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maged120~fragment-marketplace-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maged120-fragment-marketplace-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/maged120~fragment-marketplace-search/runs": {
            "post": {
                "operationId": "runs-sync-maged120-fragment-marketplace-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/maged120~fragment-marketplace-search/run-sync": {
            "post": {
                "operationId": "run-sync-maged120-fragment-marketplace-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Keywords to search for. Each query returns the matching collectible usernames. Enter one query per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "statusFilter": {
                        "title": "Status",
                        "enum": [
                            "all",
                            "on_auction",
                            "for_sale",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Which listings to return for each query.",
                        "default": "for_sale"
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "",
                            "price_asc",
                            "price_desc",
                            "listed",
                            "ending"
                        ],
                        "type": "string",
                        "description": "Order of the results within each query.",
                        "default": ""
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Limit how many usernames to return for each query. Set 0 for no limit.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings used for the search. Keeping the default (Apify residential proxy) gives the most reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
