# Migrate from Findymail to Tomba Email Finder

Switch from Findymail to Tomba for better pricing, more features, and superior data enrichment.

---

## Why Switch from Findymail to Tomba?

| Feature                    | Findymail   | Tomba                 |
| -------------------------- | ----------- | --------------------- |
| **Database Size**          | 250M emails | 450M+ emails          |
| **Accuracy**               | 90-95%      | 98%+                  |
| **Email Verification**     | ✅ Included | ✅ FREE included      |
| **Data Attributes**        | 12 fields   | 20+ fields            |
| **Waterfall Enrichment**   | ✅          | API-based alternative |
| **Author Finder**          | ❌          | ✅                    |
| **Phone Finder**           | ⚠️ Limited  | ✅ Finder & Validator |
| **Technology Detection**   | ❌          | ✅ 6000+ techs        |
| **Similar Companies**      | ❌          | ✅                    |
| **LinkedIn Finder**        | ✅          | ✅ Better             |
| **Chrome Extension**       | ✅          | ✅ Enhanced           |
| **Google Sheets**          | ❌          | ✅                    |
| **Excel Integration**      | ❌          | ✅ Native add-in      |
| **Airtable Extension**     | ❌          | ✅ Native             |
| **MCP/AI Integration**     | ❌          | ✅ Claude, ChatGPT    |
| **Pricing (10k searches)** | $199/mo     | $119/mo (40% savings) |

---

## Migration Steps

### Step 1: Get Tomba Credentials

1. Sign up at [app.tomba.io](https://app.tomba.io)
2. Get your **API Key** and **Secret Key**

### Step 2: Update API Endpoints

**Findymail:**

```
POST https://api.findymail.com/v1/search/name
```

**Tomba:**

```
GET https://api.tomba.io/v1/email-finder
```

### Step 3: Update Authentication

**Findymail:**

```javascript
{
  headers: {
    'Authorization': `Bearer ${FINDYMAIL_KEY}`
  }
}
```

**Tomba:**

```javascript
{
  headers: {
    'X-Tomba-Key': TOMBA_KEY,
    'X-Tomba-Secret': TOMBA_SECRET
  }
}
```

---

## Code Examples

### Node.js

**Before (Findymail):**

```javascript
const axios = require("axios");

async function findEmail(domain, firstName, lastName) {
    const response = await axios.post(
        "https://api.findymail.com/v1/search/name",
        {
            domain: domain,
            first_name: firstName,
            last_name: lastName,
        },
        {
            headers: { Authorization: `Bearer ${process.env.FINDYMAIL_KEY}` },
        },
    );

    return response.data;
}
```

**After (Tomba):**

```javascript
const axios = require("axios");

async function findEmail(domain, firstName, lastName) {
    const response = await axios.get("https://api.tomba.io/v1/email-finder", {
        params: {
            domain: domain,
            first_name: firstName,
            last_name: lastName,
        },
        headers: {
            "X-Tomba-Key": process.env.TOMBA_KEY,
            "X-Tomba-Secret": process.env.TOMBA_SECRET,
        },
    });

    const data = response.data.data;
    console.log(`Email: ${data.email}`);
    console.log(`Verified: ${data.verification.status}`);
    console.log(`Score: ${data.score}`);
    console.log(`Phone: ${data.phone_number}`);
    console.log(`LinkedIn: ${data.linkedin}`);
    console.log(`Company Size: ${data.company.size}`);

    return data;
}
```

**Using Tomba SDK:**

```javascript {4-5}
const Tomba = require("tomba");

const client = new Tomba.Client()
    .setKey(process.env.TOMBA_KEY)
    .setSecret(process.env.TOMBA_SECRET);

const finder = new Tomba.Finder(client);

async function findEmail(domain, firstName, lastName) {
    const result = await finder.emailFinder({
        domain: domain,
        first_name: firstName,
        last_name: lastName,
    });

    return result.data;
}
```

### Python

**Before (Findymail):**

```python
import requests

def find_email(domain, first_name, last_name):
    response = requests.post(
        'https://api.findymail.com/v1/search/name',
        json={
            'domain': domain,
            'first_name': first_name,
            'last_name': last_name
        },
        headers={'Authorization': f'Bearer {os.environ["FINDYMAIL_KEY"]}'}
    )
    return response.json()
```

**After (Tomba):**

```python
import requests

def find_email(domain, first_name, last_name):
    response = requests.get(
        'https://api.tomba.io/v1/email-finder',
        params={
            'domain': domain,
            'first_name': first_name,
            'last_name': last_name
        },
        headers={
            'X-Tomba-Key': os.environ['TOMBA_KEY'],
            'X-Tomba-Secret': os.environ['TOMBA_SECRET']
        }
    )

    data = response.json()['data']
    print(f"Email: {data['email']}")
    print(f"Verified: {data['verification']['status']}")
    print(f"Phone: {data.get('phone_number', 'N/A')}")

    return data
```

**Using Tomba SDK:**

```python
from tomba import Client, Finder

client = Client()
client.set_key(os.environ['TOMBA_KEY'])
client.set_secret(os.environ['TOMBA_SECRET'])

finder = Finder(client)

def find_email(domain, first_name, last_name):
    result = finder.email_finder(
        domain=domain,
        first_name=first_name,
        last_name=last_name
    )
    return result['data']
```

---

## Waterfall Enrichment Alternative

Findymail's waterfall enrichment can be replicated with Tomba's API:

```javascript
const axios = require("axios");

async function waterfallEnrichment(domain, firstName, lastName, linkedinUrl) {
    const headers = {
        "X-Tomba-Key": process.env.TOMBA_KEY,
        "X-Tomba-Secret": process.env.TOMBA_SECRET,
    };

    // Try 1: Email Finder
    try {
        const emailResult = await axios.get(
            "https://api.tomba.io/v1/email-finder",
            {
                params: { domain, first_name: firstName, last_name: lastName },
                headers,
            },
        );

        if (emailResult.data.data.email) {
            return enrichData(emailResult.data.data);
        }
    } catch (e) {}

    // Try 2: LinkedIn Finder
    if (linkedinUrl) {
        try {
            const linkedinResult = await axios.get(
                "https://api.tomba.io/v1/linkedin",
                {
                    params: { url: linkedinUrl },
                    headers,
                },
            );

            if (linkedinResult.data.data.email) {
                return enrichData(linkedinResult.data.data);
            }
        } catch (e) {}
    }

    // Try 3: Domain Search (find similar contacts)
    try {
        const domainResult = await axios.get(
            "https://api.tomba.io/v1/domain-search",
            {
                params: { domain },
                headers,
            },
        );

        // Find best match
        const match = findBestMatch(
            domainResult.data.data.emails,
            firstName,
            lastName,
        );
        if (match) {
            return enrichData(match);
        }
    } catch (e) {}

    return null;
}

function enrichData(data) {
    return {
        email: data.email,
        verified: data.verification?.status === "valid",
        phone: data.phone_number,
        linkedin: data.linkedin,
        position: data.position,
        company: data.company,
        score: data.score,
    };
}
```

---

## Cost Comparison

### 10,000 Emails/Month

**Findymail:**

- Growth Plan: $199/month (10,000 credits)
- Verification: Included
- **Total: $199/month**

**Tomba:**

- Growth Plan: $119/month (10,000 searches)
- Verification: FREE included
- **Total: $119/month**

**💰 Savings: $80/month = $960/year (40% cheaper!)**

### 50,000 Emails/Month

**Findymail:**

- Scale Plan: $999/month (50,000 credits)
- **Total: $999/month**

**Tomba:**

- Enterprise Plan: $599/month (50,000 searches)
- **Total: $599/month**

**💰 Savings: $400/month = $4,800/year (40% cheaper!)**

---

## Unique Tomba Features

### Author Finder

```javascript
// Find email from article URL
const author = await axios.get("https://api.tomba.io/v1/author-finder", {
    params: { url: "https://example.com/blog/article" },
    headers: { "X-Tomba-Key": KEY, "X-Tomba-Secret": SECRET },
});

console.log(`Author: ${author.data.data.email}`);
```

### Technology Detection

```javascript
// Detect tech stack for targeting
const tech = await axios.get("https://api.tomba.io/v1/technology", {
    params: { domain: "stripe.com" },
    headers: { "X-Tomba-Key": KEY, "X-Tomba-Secret": SECRET },
});

console.log(`Technologies: ${tech.data.data.technologies.length}`);
// Returns: React, Node.js, AWS, etc.
```

### Similar Companies

```javascript
// Find lookalike companies
const similar = await axios.get("https://api.tomba.io/v1/similar", {
    params: { domain: "stripe.com" },
    headers: { "X-Tomba-Key": KEY, "X-Tomba-Secret": SECRET },
});

console.log(`Similar companies: ${similar.data.data.companies.length}`);
```

### Enhanced Phone Finder

```javascript
// Find verified phone numbers
const phone = await axios.get("https://api.tomba.io/v1/phone-finder", {
    params: {
        full_name: "John Doe",
        domain: "stripe.com",
    },
    headers: { "X-Tomba-Key": KEY, "X-Tomba-Secret": SECRET },
});

console.log(`Phone: ${phone.data.data.phone_number}`);
```

---

## Bulk Operations

```javascript
// Bulk email finding
const axios = require("axios");

async function bulkFind(contacts) {
    const response = await axios.post(
        "https://api.tomba.io/v1/bulk/email-finder",
        { contacts: contacts },
        {
            headers: {
                "X-Tomba-Key": process.env.TOMBA_KEY,
                "X-Tomba-Secret": process.env.TOMBA_SECRET,
            },
        },
    );

    const taskId = response.data.task_id;

    // Poll for results or use webhook
    return taskId;
}

// Process thousands
const contacts = [
    { domain: "stripe.com", first_name: "John", last_name: "Doe" },
    { domain: "shopify.com", first_name: "Jane", last_name: "Smith" },
    // ... more
];

const taskId = await bulkFind(contacts);
```

---

## Migration Checklist

- [ ] Sign up for Tomba
- [ ] Get API credentials
- [ ] Update API endpoints
- [ ] Update authentication
- [ ] Test email finding
- [ ] Migrate waterfall logic
- [ ] Update bulk operations
- [ ] Install Chrome extension
- [ ] Setup Google Sheets/Excel
- [ ] Train team
- [ ] Cancel Findymail subscription

---

## Support

- [API Documentation](https://docs.tomba.io)
- [Email Finder API](https://docs.tomba.io/api#tag/Email-Finder)
- [Bulk Operations](https://docs.tomba.io/bulks/email-finder)
- [Support Portal](https://help.tomba.io)

Need help? [Contact us](https://app.tomba.io/contact) for migration assistance.

---

## FAQ

**Q: What about waterfall enrichment?**
A: Replicate it using Tomba's Email Finder → LinkedIn Finder → Domain Search cascade (see code example above).

**Q: Will I save money?**
A: Yes! Tomba is 40% cheaper than Findymail at all volume tiers.

**Q: Is accuracy comparable?**
A: Tomba's accuracy is higher (98%+ vs 90-95%) thanks to our larger database and built-in verification.

**Q: Can I test before migrating?**
A: Yes! Sign up for a free account with 25 searches to compare results.

**Q: How long does migration take?**
A: Most teams complete migration in 1-2 days with our code examples and SDK support.