# Hinge Email Scraper - Keyword Search & Domain Filter (`parse-point/hinge-email-scraper-lightning-fast-and-accurate`) Actor

💜 Hinge Email Scraper extracts public profile emails using keyword and location filters. 🎯 Domain restriction, obfuscated-address decoding and duplicate skipping. 📊 For dating market research and analysis.

- **URL**: https://apify.com/parse-point/hinge-email-scraper-lightning-fast-and-accurate.md
- **Developed by:** [Parse Point](https://apify.com/parse-point) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

### Hinge Email Scraper 📬

**Hinge Email Scraper** is an Apify actor that automates extracting email addresses from Hinge using keywords and optional email-domain filters. It solves the biggest pain point for marketers, recruiters, and data teams: slow, manual contact research. Get scalable, structured leads fast for better ROI and faster outreach.

***

### What is Hinge Email Scraper? 🔍

**Hinge Email Scraper** is an automated web scraping tool (an Apify actor) built to extract publicly listed email addresses from Hinge. It helps you turn Hinge profile research into a clean contact list—without spending hours copy-pasting data. As a Hinge email extractor and Hinge contact scraper, it supports B2B lead generation, contact list building, and lead enrichment by producing structured results per keyword. For teams working on email outreach automation, this Hinge lead generation tool helps you scale personal email extraction efforts from a handful of leads to thousands, quickly and consistently.

***

### What Data Does a Hinge Email Scraper Collect? 📊

This Hinge email scraping software collects a focused set of fields to support CRM integration and downstream lead enrichment. It captures contact details plus enough context to understand and verify each lead.

| Data Category | Fields Extracted | Description |
|---|---|---|
| Contact | `email` | Public email address found for the lead |
| Identity | `title` | Profile name, business title, or label associated with the result |
| Context | `description` | Profile summary or bio-style text shown on the profile/result |
| Discovery | `keyword` | The keyword that surfaced this result in the run |
| Navigation | `url` | Direct link to the Hinge profile page |
| Location | *(not provided in dataset)* | This actor does not include a `location` field in the dataset output schema |

> Note: The dataset output schema includes `keyword`, `title`, `description`, `url`, and `email`—those are the fields you can rely on for analysis and CRM import.

***

### What Do Results from a Hinge Email Scraper Look Like? 👀

Each result is a structured JSON record saved to your Apify dataset. Here’s a real example:

```json
{
  "keyword": "founder",
  "title": "Jordan Mitchell",
  "description": "Product builder | Founder at Northwind Labs | Building tools for teams",
  "url": "https://www.hinge.co/profile/jordan-mitchell-7g9k2",
  "email": "jordan@northwindlabs.com"
}
```

After execution, you can export the dataset from Apify Console (JSON is the native format; CSV is available via Apify dataset export options).

***

#### Core Features: Hinge Email Scraper ⚡

| Feature | Benefit |
|---|---|
| ✅ **Keyword-Driven Targeting** | Use targeted keywords to focus Hinge profile scraping on the audience you want |
| ✅ **Location Filter** | Add a `location` filter to refine what results you capture |
| ✅ **Custom Domain Filter** | Use `customDomains` to restrict results to specific email domains (e.g., `@gmail.com` or business domains) |
| ✅ **Configurable Result Cap** | Set `maxEmails` to control how many emails to collect per run and manage runtime/cost |
| ✅ **Proxy Support** | Built-in proxy support helps keep large-scale runs stable when web access is inconsistent |
| ✅ **Real-Time Data Saving** | Results are pushed to your dataset incrementally, reducing the risk of losing data during longer runs |
| ✅ **Structured Dataset Output** | Clean, labeled records ready for CRM integration, contact list building, and web scraping tools workflows |
| ✅ **No Login Required** | Operates on publicly available data, aligning with typical email address finder workflows |

***

### Getting Started with Hinge Email Scraper 🚀

1. **Open Apify Store** — Go to [apify.com/store](https://apify.com/store) and search **Hinge Email Scraper**
2. **Click Try for Free** — Sign in or create a free Apify account
3. **Open the Input Tab** — Configure your keywords and optional filters
4. **Add Keywords** — Enter search terms (like job titles or roles) for B2B lead generation
5. **Set Optional Filters** — Add `location` and `customDomains` to shape results
6. **Cap Your Results** — Use `maxEmails` to limit run size and cost
7. **Click Start** — Launch the run and monitor logs
8. **Access Your Data** — Open the Dataset tab to preview and export the results

First results are typically visible quickly, and you can iterate on keywords/domains if you need higher yield for email address finder tasks.

***

### Ways to Use Hinge Email Scraper 💡

- 🎯 **B2B Lead Generation** — Build segmented contact lists from Hinge profile scraping results for outreach
- 📣 **Email Marketing** — Source leads for email outreach automation campaigns and newsletters
- 🤝 **Talent & Partner Sourcing** — Find founders, managers, and relevant professionals for partnerships
- 🔬 **Market Research** — Analyze communities and roles discovered via keywords, then enrich with emails
- 📊 **CRM Enrichment** — Append emails and profile context to existing databases for lead enrichment
- ⚙️ **Data Pipelines** — Feed scraped data into analysts’ and automation workflows at scale

***

#### Input Parameters — Hinge Email Scraper

```json
{
  "keywords": ["manager", "founder"],
  "location": "",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
```

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | array | ✅ Yes | — | A list of keywords or queries used to find relevant Hinge leads |
| `location` | string | No | `""` | A location filter to narrow which results are returned |
| `customDomains` | array | No | `["@gmail.com","@yahoo.com"]` | Email domains to keep (e.g., `@gmail.com`, `@yahoo.com`) |
| `maxEmails` | integer | No | `20` | Maximum number of emails to collect. Higher caps may find more results but can take longer |

***

#### Output Parameters — Hinge Email Scraper

```json
{
  "keyword": "creative director",
  "title": "Alex Rivera",
  "description": "Creative Director at Studio Co. | Available for freelance",
  "url": "https://www.hinge.co/profile/alex-rivera-3qk7t",
  "email": "alex@studioco.com"
}
```

| Field | Label | Format | Description |
|---|---|---|---|
| `keyword` | Keyword | text | The search term that surfaced this result |
| `title` | Title | text | Profile name, business name, or handle associated with the result |
| `description` | Description | text | Profile bio or summary text shown for the lead |
| `url` | Url | link | Direct link to the Hinge profile page |
| `email` | Email | text | Extracted public email address |

***

### Why Choose This Hinge Email Scraper? 🏆

If you’re comparing web scraping tools for email address finder workflows, **Hinge Email Scraper** stands out for practical, structured outputs you can use immediately for contact list building and CRM integration. It’s built around keyword-based targeting, supports custom email-domain filtering, and lets you control results with `maxEmails`. With proxy support and incremental dataset saving, it’s designed for stable, scalable data harvesting—without requiring logins. It’s also cost-efficient when you use it like a lead generator tool: you set a cap and collect only what you need, enabling tight control over spend.

***

### How Many Results Can You Scrape? 📈

Use `maxEmails` to set a cap from 1 up to 10,000. The actual number of emails you receive depends on how many Hinge profiles match your keywords and include publicly available emails (and, if you set it, your `customDomains`). For larger collection goals, consider increasing the allowed runtime via Apify **Run Options**—the actor notes that bigger searches or higher limits can take longer. Your dataset stores results so you can export anytime.

***

### Legal Guidelines for Scraping Hinge ⚖️

**Hinge Email Scraper** extracts data only from **publicly available sources** on Hinge. It does not access private data, and it does not require login or authenticated pages. You’re responsible for using extracted emails in accordance with applicable laws and platform policies, including compliance and GDPR considerations and spam regulations. For data removal requests, contact <hello.parsepoint@gmail.com>.

***

### FAQ — Hinge Email Scraper ❓

#### How does the Hinge Email Scraper identify data?

The actor uses your provided keywords (and optional `location` and `customDomains` filters) to discover relevant publicly available Hinge leads, then extracts any publicly listed email addresses along with the associated profile context that’s included in the dataset output.

#### What Hinge profile types can I scrape?

You can target any public Hinge profiles that match your keywords and that have publicly visible contact information. The results depend on what’s available publicly on each profile.

#### How did the Hinge Email Scraper perform in our tests?

Actual performance varies by niche and by how many profiles include public emails. Email availability is not guaranteed, which is why the actor supports configurable keywords and domain filters to help increase yield for lead generation and email address finder use cases.

#### Why scrape Hinge for contacts?

Hinge hosts many professionals and creators who may list contact details publicly. This actor automates web scraping tasks involved in building a contact list, helping you move from manual research to structured data harvesting for outreach.

#### How much does the Hinge Email Scraper cost?

Pricing is effectively controlled by your `maxEmails` setting, which caps how many emails the actor will collect. That makes it easier to estimate cost versus collecting unlimited data. (Exact pricing depends on your Apify usage and plan.)

#### How does the Hinge Email Scraper help my business?

It converts keyword-based Hinge profile research into a structured dataset you can export and use in CRM integration, lead enrichment, and email outreach automation. The dataset includes `keyword`, `title`, `description`, `url`, and `email`—so analysts and marketers can segment results by what surfaced each lead.

#### What challenges should I expect when using the Hinge Email Scraper?

Not every matching Hinge profile includes a public email address, so your volume depends on both your keyword set and your domain filters. If you get fewer results than expected, try widening keywords, adding related terms, or including more domains in `customDomains`.

#### How do I choose a high-performing Hinge Email Scraper?

Choose inputs based on the output you need for email outreach automation: use focused keywords, restrict with meaningful `customDomains`, and set an appropriate `maxEmails` cap. For better results in B2B lead generation and contact list building, iterate on keywords/domains until you see consistent email yields.

***

### Conclusion 🏁

**Hinge Email Scraper** is a fast, structured way to extract publicly available emails from Hinge for lead generation, contact list building, and CRM enrichment. If you’re building scalable outreach lists, set your keywords, apply custom email-domain filters, and cap results with `maxEmails` to control runtime and ROI.

***

### 🆘 Support & Feedback

Need help configuring your run or have a feature request for **Hinge Email Scraper**? Email us at <hello.parsepoint@gmail.com>. We’re happy to help with questions related to data harvesting, output usability, and best practices for compliance and GDPR-friendly lead generation.

### Run Memory

**Skip keywords already scraped in a previous run** - the actor keeps a
persistent record of every keyword it finishes, in a named key-value store that
survives between runs. Turn this on and a repeat run silently drops the keywords
it has already covered, so a scheduled job over a fixed list only pays for new
ground.

A keyword is identified by the keyword *plus* the set of email domains it was
searched against, so re-running `fitness` against a new domain list is correctly
treated as new work rather than a duplicate.

**Reset keyword history** - wipe that record before the run starts, so
everything counts as new again.

**Max emails per keyword** - cap how many results any single keyword may
produce before the actor moves on to the next one. Stops one broad term from
consuming the entire run budget. `0` means no per-keyword limit.

These sit alongside the existing address-level deduplication: *Skip previous
runs* prevents re-pushing an individual mailbox, while *Skip duplicate keywords*
prevents re-running the search at all.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `decodeProtectedEmails` (type: `boolean`):

Read addresses the page hides behind Cloudflare protection or HTML entities. These are invisible to a plain text scan.

## `decodeWrittenEmails` (type: `boolean`):

Read addresses written to defeat scrapers, such as 'name \[at] example \[dot] com'.

## `decodeEncodedEmails` (type: `boolean`):

Read addresses stored base64-encoded in the page markup.

## `mergeAliasDuplicates` (type: `boolean`):

Collapse different spellings that reach the same inbox (e.g. j.o.h.n+news@gmail.com and john@gmail.com) into a single result, so you are not billed twice for one lead.

## `skipPreviousRuns` (type: `boolean`):

Do not return leads that an earlier run of this Actor already returned. Skipped leads are never charged.

## `duplicateHandling` (type: `string`):

What to do when several spellings reach the same inbox: merge them into one result, keep them apart but flag them, or keep everything as found.

## `skipDuplicateKeywords` (type: `boolean`):

Remember every keyword this actor completes and skip it next time. Ideal for a scheduled run over a fixed keyword list - you only pay for ground you have not covered. A keyword searched against a different set of email domains counts as new work, not a duplicate.

## `resetKeywordHistory` (type: `boolean`):

Clear the remembered keywords before this run starts, so everything is treated as new again. Use after changing your target list.

## `maxEmailsPerKeyword` (type: `integer`):

Stop collecting for a keyword once it has produced this many results, then move on to the next one. Keeps one broad term from consuming the whole run. Leave at 0 for no per-keyword limit.

## Actor input object example

```json
{
  "keywords": [
    "coach",
    "entrepreneur"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "decodeProtectedEmails": true,
  "decodeWrittenEmails": true,
  "decodeEncodedEmails": true,
  "mergeAliasDuplicates": true,
  "skipPreviousRuns": false,
  "duplicateHandling": "merge",
  "skipDuplicateKeywords": false,
  "resetKeywordHistory": false,
  "maxEmailsPerKeyword": 0
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "keywords": [
        "coach",
        "entrepreneur"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parse-point/hinge-email-scraper-lightning-fast-and-accurate").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 = {
    "keywords": [
        "coach",
        "entrepreneur",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("parse-point/hinge-email-scraper-lightning-fast-and-accurate").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 '{
  "keywords": [
    "coach",
    "entrepreneur"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call parse-point/hinge-email-scraper-lightning-fast-and-accurate --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parse-point/hinge-email-scraper-lightning-fast-and-accurate"
        }
    }
}

```

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/Sndi2SdsPia8GdPsj/builds/ck7ABmGKWC4BRIKUc/openapi.json