DEV Community: Alex Yatsenko

Building the AI email bot for a job candidate

Alex Yatsenko — Mon, 16 Dec 2024 00:46:51 +0000

Hi,

It's Alex the solo founder of ProxiedMail.

Today I want to share the story about how I've built the AI bot that would answer the recruiter questions since I've spent some recent months looking for a job.
This bot played a crucial role in getting me the next position.

Context

Before actually getting into this kind of simple solution I've built, tested, and integrated the AI-email bots into my existing privacy-focused email product - ProxiedMail.
Used this kind of the existing resources I've managed to implement the bot functionality.
So, from now on to have this kind of use case I would only need to create a proxy email, write down the prompt, and then publish the bot.

Problem

While looking for a job I had a lot of communication with the recruiters.
Sometimes just the questions about technology or my professional experience.
Since I spend a lot of time on that kind of communication, I've decided to delegate this task to the AI assistant.

Designing the solution

I'll skip the part about the full integration of the AI bots into the ProxiedMail system and describe only the process of creating an AI bot on the ProxiedMail UI.
ProxiedMail bots receive the following params:

Prompt. Describe the instructions and information contained in the bot.
Model: OpenAI model.
CC all messages to the real address. This option lets you copy all incoming conversations with the bot to your real address attached to the proxy-email. You can use it to track how your bot is working or to participate/stop the conversation depending on the interruption flag. You will get both messages from the bot and the user.
Allow interruption. If you put the Demand CC option, you will be able to stop the bot by replying to any email in the bot-user conversation. After the first reply but will stop and you will be 1-1 with the bot user.
Session length, minutes. This option shows how long is the user-bot conversation window. If you set it to 30 minutes bot will forget all previous messages with the user and start the conversation over if the last message in the conversation is older than that period of time.

To be able to set up and configure the bot you would need to sign up for ProxiedMail and create any proxy email. Whatever it's a proxy email created on your domain or ProxiedMail standard domain.
Then, just click "AI/Bots" button.

Creating the prompt

The only thing I've changed is the custom prompt.

I just wrote the instructions on how to behave with the bot:

You have a job candidate for a software developer. You're supposed to answer people/recruiters' questions about this candidate from his identity.
Imagine you're him and don't disclose yourself.
And then pasted all my information from the CV (Command+A, Command+V)

Result evaluation

I've texted the bot from another email with the following:

Hi Alex,
I'm Ravshad, a recruiter of Googling.
How much of your experience do you have with Laravel?
Thanks.

Bot's reply was the following:

Hello Ravshad, I have advanced-level experience with Laravel, which is around 85%. I've used Laravel extensively in my work at airSlate, where I worked on new features for "SendToSign" in SignNow, as well as handling backend responsibilities for mobile applications. I've also completed projects using Laravel in my own endeavors, such as ABRouter and ProxiedMail. Feel free to reach out if you have any more questions! Best, Oleksii

I got the bot reply to my real email:

As basically all messages are going as the CC to my real email, I can simply reply from it by STOPPING the bot or letting the bot continue speaking due to my bot settings.
Also, it's possible to set up the webhook URL for all messages as well.

Conclusion

We have built an AI bot that would reply on our behalf to recruiters.
If you're thrilled to built your own bot, just visit the AI email bots landing page and sign up from there: https://proxiedmail.com/en/ai-email-bots

Good luck.

Fighting spam by verifying user emails by inbound message receiving

Alex Yatsenko — Wed, 02 Oct 2024 01:03:35 +0000

Hi there,

It's Alex software engineer and solo founder of ProxiedMail.

This article is dedicated to people who want to fight potential spammers and email existence checkers on your product websites.
It would be mostly beneficial for owners of products that require people to confirm emails on the websites of their apps or just software engineers who want to prevent spammers from using their products in a bad way.

Background: delivery trust

As I'm working on ProxiedMail, a product that mostly sells services related to email forwarding between mailboxes with privacy and API focus it's important to keep a good record of email activity in the eyes of GMail, ProtonMail, Tutanota, and other email providers.
If trust in other email services is low we won't be able to deliver emails to our recent users.
The level of trust from email providers is separated between mailboxes that recently started receiving letters from your mail servers/domains and people who have been receiving and reading them for a long time. While the last ones aren't a problem for us, new ones could be challenging.

Background: spammers cases

I've told you about the importance of a good email record, so email delivery, especially to email services is high.
That's a reason why it should be closely tracked.

Our spam tracking methodology

We don't have advanced spam protection yet, but we have rate limits for particular accounts. So, we mostly trying to prevent people from getting multiple accounts by checking their IP, geo, and email verification.
Also, we do track the successful rate of email verification.

Email verification exploit

We're asking users to verify their emails and they also can see if their email address is marked as verified or not.
Additionally, all of our users are capable of adding more than one email and tracking the verification status.
So, it could be a potential case for spammers and intruders to verify some cold databases of emails.

Our intruder's case

Because we have had that email verification capability, at some moments I've seen increased signs up without verified email from the US and all accounts shared the same Turkish IP.
So, probably the case was: someone tried to verify the email database through our verification feature singing up from different US IPs.

What we're standing against

At this moment it's become pretty clear that we have been attacked through an email verification system with butch sign-ups in a manual way.
We've been sending email verification to our new users.
Potential consequences of that are lowering email delivery rates.

Solution to spam/abuse of email verification

Our intruders were trying different emails to see if they were valid and we were sending many emails to people who hadn't seen our services before we decided to solve it somehow.
As we're building services focused on email protection and API we decided to use it to solve this problem.
The most obvious solution was changing email verification from inbound to outbound.
So, it's not we who will send the email to the customer for verification, but the customer should send us the email for verification instead.

UX changes to email verification

The email verification scheme is moving from emailing links by us to sending emails by customers to some dedicated email address provided by us.
For example, we sign up and get a popup: "Sent email with any text/code from your email address to this address (blabla@websiteverify.com". When the email reaches the email server backend gets a webhook about the message and marks the email as verified.

Simple scheme on new flow

Let's look at how the new email verification flow looks like

Real-life look

Let's see how it works with the real implementation on ProxiedMail.

This is what the confirmation page looks like just after signing up:

"Confirm your email by sending any message from your real address yatsenkolesh@gmail.com to confirmation@pxdmail.com.
Once you confirm your first email, you will get the standard email confirmation by receiving the links."

So, to confirm our email we would need to send an email from yatsenkolesh@gmail.com to confirmation@pxdmail.com.

Let's see what it looks like:

And 30 seconds after we have replied that our email is confirmed.

So, as you may see everything went great!

Take a moment to enjoy the great solution

Now we will require people to confirm their emails by sending messages from their email and we will avoid the attacks.

Techincal details

Our solution is based on ProxiedMail webhooks. You can attach any webhook URL to an email address created on ProxiedMail.
It could be using the ProxiedMail domain or your domain as well.
For your website email verifications I would recommend buying a new domain like verifymyapp.com, so you would be able to get an email address for verifications like email@verifymyapp.com.

If you feel like a step-by-step list it's:

Sign up on ProxiedMail
Optional - Attach your domain
Create a proxy email using your custom domain and go to webhook settings

Set up your webhook URL:

That's it. You would be able to receive webhooks on incoming emails.

Coding details

Now you can see a code inside of our Laravel app that verifying incoming emails:

    public function confirmationWebhook(
        Request $request,
        Dispatcher $dispatcher
    ) {
        $payload = $request->json('payload');
        $sender = $payload['sender'];

        /**
         * @var EmailConfirmation|null $model
         */
        $model = EmailConfirmation::query()->where('raw_email', $sender)
            ->where('confirmed', 0)
            ->first();
        if ($model) {
            $model->confirmed = 1;
            $model->save();

            $email = new EmailConfirmedLetter($model->email);
            Mail::to($model->email)->send($email);

            $dispatcher->dispatch(new EmailConfirmedEvent($model));
        }

        return response()->json([
            'status' => 'ok',
        ]);
    }

So, we're getting the sender's email and just confirming it in our database. After we mark it as verifying we send the confirmation letter and firing confirmation event in our application.

Now we have email verification working.

Resources

To implement verification yourself I can recommend the following resources:

Webhook on the received email
ProxiedMail Docs
Sign up

We learned

(we mostly want to describe it for the SEO of this post)

Protecting our email verification functionality against abuse
Transferring email verification from outbound to inbound
Ability to verify customer email by sending a message
Protecting email verification against spam.

Good luck with your implementation!

Email testing with Codeception

Alex Yatsenko — Mon, 25 Mar 2024 16:54:19 +0000

Hi to all highly respected PHP developers,

Today we're going to talk about email testing with Codeception framework.
It could be testing of a sign-up form, contact form, or just API. But in this example, we're going to focus on UI testing with Codeception.
Email testing with API is going to be much easier, so we believe you will be able to apply this example to API by yourself.

We're going to learn how to receive emails that were sent from your product straight to your test, retrieve the confirmation code from the received letter, and put it on to code validation page.

If you want to just jump straight to the code example you can find it on GitHub: https://github.com/proxied-mail/codeception-email-testing-example

Test case details

https://proxiedmail.com/email-playground/index.html
The page that requests email confirmation:

https://proxiedmail.com/email-playground/confirmation.html
The page that validates the confirmation code:

We're going to request the confirmation code on the first one and check validation on the second.

Setting up Codeception

You can skip this step if you already have Codeception.

To install via Composer, run this in your project's root:

composer require "codeception/codeception" --dev

From now on Codeception (with installed PHPUnit) can be run as:

php vendor/bin/codecept

Initialize your testing environment with

php vendor/bin/codecept bootstrap

Also, you would need to set up the WebDriver to be able to use Selenium:

actor: AcceptanceTester
modules:
    enabled:
        - \Codeception\Module\Asserts
        - WebDriver:
            url: http://proxiedmail.com
            browser: chrome
            host: 'selenium-chrome'
            port: 4444
            capabilities:
                goog:chromeOptions:
                    args: [ "--headless" ]

Codeception will also suggest you install the additional packages to add support for the selenium.
In this yaml we're using Selenium that we set up via docker-compose:

  selenium-chrome:
    image: selenium/standalone-chrome
    shm_size: 2g
    container_name: selenium-chrome
    networks:
      - pxdmail-codeception-example

Setting up ProxiedMail

Install proxiedmail-php-client library via Composer:

composer require proxiedmail/php-client

Then, we need to set up env variables.
I've used .env file to pass API-token to my tests like this:

PROXIEDMAIL_API_TOKEN=your-api-token

In Github example repository it's shown how to organize passing this value straight to the test.
But please pay attention to codeception.yml which allows you to pass the variable from .env to the tests with the following lines:

params:
    - .env
PROXIEDMAIL_API_TOKEN: "%PROXIEDMAIL_API_TOKEN%"

Obtaining ProxiedMail Token

To obtain ProxiedMail token please sign up on ProxiedMail. After signing up you will see the "API" link in a header or you can also use the following link.

Coding part

After the setup we are finally able to write our email testing code.
Create your test:

php vendor/bin/codecept generate:cest Acceptance EmailCode

Then, open the created file and write:

<?php

namespace Tests\Acceptance;

use Codeception\Configuration;
use ProxiedMail\Client\Entrypoint\PxdMailApinitializer;
use Tests\Support\AcceptanceTester;
use ProxiedMail\Client\Config\Config;


class EmailCodeCest
{
    public function _before(AcceptanceTester $I)
    {
    }

    public function frontpageWorks(
        AcceptanceTester $I
    ) {
        $proxiedMailApiToken = Configuration::config()['PROXIEDMAIL_API_TOKEN'];
        $config = new Config();
        $config->setApiToken($proxiedMailApiToken);
        $api = PxdMailApinitializer::init($config);
        $proxyEmail = $api->createProxyEmail();


        $I->amOnPage('/email-playground/index.html');
        $I->fillField(['id' => 'name'], 'Tester');
        $I->fillField(['id' => 'email'], $proxyEmail->getProxyAddress());
        $I->executeJS('document.getElementById("submit").click()');
        sleep(3);

        $I->canSee('Check your mailbox');

        $firstEmail = $api->waitUntilFirstEmail($proxyEmail->getId());

        $I->assertSame($firstEmail->getSubject(), 'Code confirmation');
        $text = $firstEmail->getPayload()['stripped-text'];
        //find code after "Your confirmation code is"
        preg_match('/Your confirmation code is ([0-9]+)/', $text, $matches);
        var_dump($text);
        $code = $matches[1];

        $I->amOnPage('/email-playground/confirmation.html');
        //testing negative behaviour
        $I->fillField(['id' => 'confirmation_code'], mt_rand(0000, 9999));
        $I->executeJS('document.getElementById("submit").click()');
        sleep(1);

        $I->canSee('Code is invalid');


        $I->fillField(['id' => 'confirmation_code'], $code);
        $I->executeJS('document.getElementById("submit").click()');
        sleep(3);
        $I->canSee('Code is valid');
    }

}

The code is doing the following actions:

Fetching the API token from .env
Creating a proxy email like abcddd@proxiedmail.com that provides us the ability to see received emails it
Going to https://proxiedmail.com/email-playground/index.html
Putting email and name to the form and click submit
Checking that the form was submitted
Going to https://proxiedmail.com/email-playground/confirmation.html
Checking the right subject and extracting the confirmation code
Testing negative scenario with wrong confirmation code
Putting the correct confirmation code, clicking submit, and verifying that it was the right confirmation code.

Conclusion

We have tested the email confirmation code. The same code might be applied to any API or sign-up UI or anything else yo can think of. Limits only in your imagination.

ProxiedMail features

ProxiedMail allows you to create proxy emails with:

Callbacks to certain URLs.
Browsing received emails.
Forwarding incoming emails to any email addresses.

All the features you can find in https://github.com/proxied-mail/proxiedmail-php-client.
Also, we have JS client, Laravel Client and Cypress plugin.
You're always welcome to check ProxiedMail docs and the website.

Additionally, it's great to secure your data. I highly suggest you learn about ProxiedMail concept in your free time.

About ProxiedMail + pricing

ProxiedMail is a tool that brings the email experience to a new level because it was built around the privacy first concept that enhances using a unique email each time which makes it a second password, but also allows you more control over your correspondence.

Additionally, it gives you the advantage of moving to another email provider just in a few seconds. Because we have this kind of system we also aim to bring more into the experience of development using emails.

Pricing

You can create unlimited proxy emails for your tests just for up to 9 USD/year (for now) and also we have a forever/one payment plan that we usually sell for around 25-30 USD depending on your luck.

Farewell

Thank you for learning about email testing with me today.
I've put a lot of effort into setting up it, especially in terms of Codeception, but hopefully, it is worth it and could help you to make your product better.

Once again: check out example repository.

Good luck!

Feel free to ask any questions.
Alex, single founder of ProxiedMail.

How to receive inbound email with NodeJS

Alex Yatsenko — Mon, 26 Feb 2024 00:19:00 +0000

Hey,

I'm Alex, the individual behind ProxiedMail.
ProxiedMail elevates the email service by emphasizing privacy from the outset, encouraging the use of a distinct email for each interaction as an additional layer of security. This approach not only bolsters your email's privacy but also grants you enhanced management of your messages. Moreover, it facilitates a swift transition to alternative email services within moments. Our system is designed to enrich the email-based development experience further.

There are scenarios where directly receiving emails into an application is crucial. This need may arise from systems that lack an API but offer email alerts, or from a desire to incorporate user emails directly into your app's functionality. The possibilities for integrating email reception and processing within your applications are vast. In this guide, I'll detail how to accomplish this using NodeJS.

How it works

With ProxiedMail, you can choose your own email address or get one automatically. Usually, we send emails to your conventional email, like Gmail or ProtonMail.
It works like this: an email sent to abc@proxiedmail.com goes to blabla@protonmail.com.
If you set up a webhook email, we'll send a webhook to that email. If you don't want emails forwarded to your regular email, you can use a special internal address, such as *@proxiedmail-int.int (for example, testingadw@proxiedmail-int.int).

API Features

Creating endless proxy emails with one of ProxiedMail domains (i.e abc@proxiedmail.com, abcd@pxdmail.com, abcde@pxdmail.net)
Setting up forwarding email or disabling forwarding
Setting up a callback to your URL
Browsing received emails on the received emails endpoint
Setting up custom domains. You can do everything using your domain as well.
Domain-to-domain forwarding. Just in case you need it we can forward emails by mask, like *@domainhostedatproxiedmail.com -> *someotherdomain.com. In this case, the MX of the first domain should be pointed to ProxiedMail and the second domain should be verified by TXT record.

Let's start

Follow this easy instruction to start receiving emails into your application.

Sign up on ProxiedMail
Create your API Key
Install the npm package into your application.

npm install proxiedmail-api

Start coding/webhook implementation.

Let's say we've created t.js file with the following contents:

*If you got your API key you can hardcode it into the application. *

let ProxiedMailApi = require('proxiedmail-api');

let apiInstance = new ProxiedMailApi.UserApi();


let authReq = {
    'authRequest': ProxiedMailApi.AuthRequest.constructFromObject(
        {
            "data": {
                "type": "auth-request",
                "attributes": {
                    "username": "example@example.com", //please pass your credentials here after sign up
                    "password": "example"
                }
            }
        }
    )
};

//logging in
apiInstance.userAuth(authReq, (error, data, response) => {
    if (error) {
        console.error("error:" + error);
    } else {
        let token = data.data.attributes.token;
        var apiApiClient = new ProxiedMailApi.ApiApi();
        apiApiClient.apiClient.authentications['api_auth'].accessToken = token; //settings bearer token

        //getting api token
        // your can skip this step and get one on the UI https://proxiedmail.com/en/settings
        apiApiClient.apiV1ApiTokenGet((error, data, response) => {
            if (error) {
                console.error("error:" + error);
            }

            //settings up api token
            let apiToken = data.token;
            var callbackApi = new ProxiedMailApi.CallbackApi();
            callbackApi.apiClient.authentications['api_key'].apiKey = apiToken;

            // creating built-in callback-receiver
            callbackApi.addCallback((error, cb, response) => {
                const proxyBindingPayload = {'proxyBindingCreate': createProxyBindingPayload(cb.call_url)}

                var proxyBindingApi = new ProxiedMailApi.ProxyBindingApi();
                //creating proxy-email and assigning callback url
                proxyBindingApi.addProxyBinding(proxyBindingPayload, (error, pb, response) => {

                    //continuously checking callback status to get the email
                    //just send the email to pb.data.attributes.proxy_address to check it out
                    const interval = setInterval(function () {
                        callbackApi.apiV1CallbackGetHashGet(cb.id, function (error, cbInfo) {
                            console.log('check callback. email: ' + pb.data.attributes.proxy_address);
                            console.log(cbInfo)

                            //printing email info about callback
                            if (cbInfo.is_received) {

                                console.log('received')
                                console.log(cbInfo)
                                console.log('Subject: ' + cbInfo.payload.payload.Subject)
                                console.log('Message: ' + cbInfo.payload.payload['body-plain'])
                                console.log('From: ' + cbInfo.payload.payload['from'])

                                clearInterval(interval);
                            }

                        });
                    }, 2000);
                });
            } )

        });
    }
});


//callback construction function
function createProxyBindingPayload(callbackUrl) {
    return ProxiedMailApi.ProxyBindingCreate.constructFromObject(
        {
            "data":{
                "type":"proxy_bindings",
                "attributes":{
                    "real_addresses":[], //on empty it will generate internal real address
                    //that kind of real addresses is not forwarding anything to any email
                    //however if you need forwarding just use something like "abc@example.com"
                    //please note that real address should be confirmed
                    "proxy_address": null,
                    "callback_url": callbackUrl
                }
            }
        }
    );
}

Also if you prefer you can use it without callback if you want the ability to catch more than one email:

let ProxiedMailApi = require('proxiedmail-api');

let apiInstance = new ProxiedMailApi.UserApi();


let authReq = {
    'authRequest': ProxiedMailApi.AuthRequest.constructFromObject(
        {
            "data": {
                "type": "auth-request",
                "attributes": {
                    "username": "example.com", //please pass your credentials here after sign up
                    "password": "1"
                }
            }
        }
    )
};

//logging in
apiInstance.userAuth(authReq, (error, data, response) => {
    if (error) {
        console.error("error:" + error);
    } else {
        let token = data.data.attributes.token;
        var apiApiClient = new ProxiedMailApi.ApiApi();
        apiApiClient.apiClient.authentications['api_auth'].accessToken = token; //settings bearer token

        //getting api token
        // your can skip this step and get one on the UI https://proxiedmail.com/en/settings
        apiApiClient.apiV1ApiTokenGet((error, data, response) => {
            if (error) {
                console.error("error:" + error);
            }

            //settings up api token
            let apiToken = data.token;
            var callbackApi = new ProxiedMailApi.CallbackApi();
            callbackApi.apiClient.authentications['api_key'].apiKey = apiToken;

            // creating built-in callback-receiver
            callbackApi.addCallback((error, cb, response) => {
                const proxyBindingPayload = {'proxyBindingCreate': createProxyBindingPayload(cb.call_url)}

                var proxyBindingApi = new ProxiedMailApi.ProxyBindingApi();
                //creating proxy-email and assigning callback url
                proxyBindingApi.addProxyBinding(proxyBindingPayload, (error, pb, response) => {

                    //continuously checking callback status to get the email
                    //just send the email to pb.data.attributes.proxy_address to check it out
                    const interval = setInterval(function () {


                        const proxyBinding = response;

                        var receivedEmailApi = new ProxiedMailApi.ReceivedEmailApi();
                        receivedEmailApi.apiV1ReceivedEmailsLinksProxyBindingIdGet(
                            response.body.data.id,
                            function (error, pb, response) {

                                console.log("Checking inbox of: " + proxyBinding.body.data.attributes.proxy_address)


                                console.log('LIST OF EMAILS', response.body)
                                for (let i in response.body.data) {

                                    receivedEmailApi.apiV1ReceivedEmailsReceivedEmailIdGet(
                                        response.body.data[i]['id'],
                                        function (error, pb, response) {
                                            console.log(
                                                "RECEIVED EMAIL \n",
                                                response.body
                                            )
                                        }
                                    )
                                }

                            }
                        )

                    }, 2000);
                });
            } )

        });
    }
});


//callback construction function
function createProxyBindingPayload(callbackUrl) {
    return ProxiedMailApi.ProxyBindingCreate.constructFromObject(
        {
            "data":{
                "type":"proxy_bindings",
                "attributes":{
                    "real_addresses":[
                        "dawwaawdawd@proxiedmail-int.int"
                    ],
                    "proxy_address": null,
                    "callback_url": callbackUrl,
                    "is_browsable": true,
                }
            }
        }
    );
}

Payload example

All of our examples contain a payload. Example of email payload:

{
   "id":"EB442408-D500-0000-00003CC8",
   "payload":{
      "Content-Type":"multipart\/alternative; boundary=\"000000000000714564060f56f6c2\"",
      "Date":"Sat, 20 Jan 2024 02:00:25 +0000",
      "Dkim-Signature":"DKIM",
      "From":"Alex Yatsenko <sender@gmail.com>",
      "Message-Id":"<CAJj9C9dVhSJZDwRDM-H=vhzPttpg253biEvabFtEHiS4wriK8A@mail.gmail.com>",
      "Mime-Version":"1.0",
      "Received":"by mail-wm1-f44.google.com with SMTP id 5b1f17b1804b1-40e9ffab5f2so10064475e9.1 for <4bd6c97b9@proxiedmail.com>; Fri, 19 Jan 2024 18:00:38 -0800 (PST)",
      "Subject":"hey mate",
      "To":"4bd6c97b9@proxiedmail.com",
      "X-Envelope-From":"sender@gmail.com",
      "X-Mailgun-Incoming":"Yes",
      "X-Received":"Received details",
      "body-html":"<div dir=\"ltr\">hey hey<\/div>\r\n",
      "body-plain":"hey hey\r\n",
      "domain":"proxiedmail.com",
      "from":"Alex Alex <sender@gmail.com>",
      "message-headers":"HEADERS JSON....",
      "recipient":"4bd6c97b9@proxiedmail.com",
      "sender":"sender@gmail.com",
      "signature":"....",
      "stripped-html":"<div dir=\"ltr\">hey hey<\/div>\n",
      "stripped-text":"hey hey",
      "subject":"hey mate",
      "timestamp":"1705716046",
      "token":"..."
   },
   "attachments":[

   ],
   "recipient":{
      "address":"4bd6c97b9@proxiedmail.com"
   },
   "receivedAt":"Sat Jan 20 2024 02:00:46 GMT+0000",
   "user":{
      "id":"1B3AAA43-11-0000-cc",
      "username":"username+t1@gmail.com",
      "token":"Bearer ...."
   }
}

Summary

Summarizing our information you can use both ways to receive emails: via callback and also using browsing emails.
The payload contains all of the information about email and attachments.

If you have any questions please contact devjs@pxdmail.com.
Feel free to check out the documentation as well.

Feel free to check out or contribute on Github.
Also, you can check out the article about receiving emails in the best language (PHP).

How to receive inbound email with PHP

Alex Yatsenko — Sat, 24 Feb 2024 17:08:05 +0000

Hey,

It's Alex, the solo founder of ProxiedMail.
ProxiedMail is a tool that brings the email experience to a new level because it was built around the privacy first concept that enhances using a unique email each time which makes it a second password, but also allows you more control over your correspondence.
Additionally, it gives you the advantage of moving to another email provider just in a few seconds.
Because we have this kind of system we also aim to bring more into the experience of development using emails.

At some point, we want to receive an email straight into our application. It can be a system that doesn't provide any API but provides email notifications or we want to receive emails from our users as part of our functionality. There are dozens of use cases for receiving and handling emails in your applications. In this article, I'll explain how you're going to do it with PHP.

How it works

You can create an email address on ProxiedMail with a specific name or use an autogenerated one. Normally we also forward incoming emails to some kind of real email. Real email is some kind of old-fashioned mailbox on Gmail, ProtonMail, etc.
So, usually, it looks like that abc@proxiedmail.com -> blabla@protonmail.com.
Meanwhile, if you set up a webhook email we also send you a webhook to the specified email. You can disable forwarding to your real email using one of the internal forwarding emails like *@proxiedmail-int.int (i.e testingadw@proxiedmail-int.int)

API Features

Creating endless proxy emails with one of ProxiedMail domains (i.e abc@proxiedmail.com, abcd@pxdmail.com, abcde@pxdmail.net)
Setting up forwarding email or disabling forwarding
Setting up a callback to your URL
Browsing received emails on the received emails endpoint
Setting up custom domains. You can do everything using your domain as well.
Domain-to-domain forwarding. Just in case you need it we can forward emails by mask, like *@domainhostedatproxiedmail.com -> *someotherdomain.com. In this case, the MX of the first domain should be pointed to ProxiedMail and the second domain should be verified by TXT record.

Let's start

Follow this easy instruction to start receiving emails into your application.

Sign up on ProxiedMail
Create your API Key
Install the composer library into your application.

composer require proxiedmail/php-client

Start coding/webhook implementation.

Let's say we've created t.php file with the following contents:

<?php

use ProxiedMail\Client\Config\Config;
use ProxiedMail\Client\Entities\ResponseEntity\OauthAccessTokenEntity;
use ProxiedMail\Client\Entrypoint\PxdMailApinitializer;
use ProxiedMail\Client\Facades\ApiFacade;

require 'vendor/autoload.php';


// put here your ProxiedMail credentials
$email = 'example.com';
$pass = '1';

/**
 * @var ApiFacade $facade
 */
$facade = PxdMailApinitializer::init();
/**
 * @var OauthAccessTokenEntity $r
 */
$r = $facade->login($email, $pass);

//settings bearer token. 
$config = (new Config())->setBearerToken('Bearer ' . $r->getBearerToken());
$facade = PxdMailApinitializer::init($config);

//receiving API token by bearer token
$apiToken = $facade->getApiToken();

$config = new Config();

//setting API token. You can start from here if you obtained API token.
$config->setApiToken($apiToken->getApiToken());

$api = PxdMailApinitializer::init($config);

$wh = $api->createWebhook(); //creating webhook-receiver
$proxyEmail  = $api->createProxyEmail(
    [],
    null,
    $wh->getCallUrl() //specifying webhook url
);



// while (true) with 100 seconds limit
foreach(range(0, 100) as $non) {
    echo "PROXY-EMAIL: " . $proxyEmail->getProxyAddress() . "\n";
    echo "Send the email to this proxy-email to get email payload printed here";

    //checking webhook receiver 
    $whStatus = $api->statusWebhook($wh->getId());

    echo "Webhook STATUS: \n";
    echo "Received: " . ($whStatus->isReceived() ? 'yes' : 'no') . "\n"; //printing webhook status

    //printing payload if received
    if ($whStatus->isReceived()) {
        echo "WEBHOOK PAYLOAD: \n";
        echo json_encode($whStatus->getPayload());
        break;
    }


    echo "\n";

    sleep(1);
}

Also if you prefer you can use it without callback if you want the ability to catch more than one email:

<?php

use ProxiedMail\Client\Config\Config;
use ProxiedMail\Client\Entities\ResponseEntity\OauthAccessTokenEntity;
use ProxiedMail\Client\Entrypoint\PxdMailApinitializer;
use ProxiedMail\Client\Facades\ApiFacade;

require 'vendor/autoload.php';


// put here your ProxiedMail credentials
$email = 'example@example.com';
$pass = '1';

/**
 * @var ApiFacade $facade
 */
$facade = PxdMailApinitializer::init();
/**
 * @var OauthAccessTokenEntity $r
 */
$r = $facade->login($email, $pass);

//settings bearer token
$config = (new Config())->setBearerToken('Bearer ' . $r->getBearerToken());
$facade = PxdMailApinitializer::init($config);

//receiving API token by bearer token
$apiToken = $facade->getApiToken();

$config = new Config();

//setting API token
$config->setApiToken($apiToken->getApiToken());

$api = PxdMailApinitializer::init($config);

$proxyEmail  = $api->createProxyEmail(
    [],
    null,
    null,
    null,
    true
);



// while (true) with 100 seconds limit
foreach(range(0, 180) as $non) {
    echo "PROXY-EMAIL: " . $proxyEmail->getProxyAddress() . "\n";
    echo "Time limit is 3 mins \n";
    echo "Send the email to this proxy-email to get email payload printed here \n";

    //checking webhook receiver

    $receivedEmails = $api->getReceivedEmailsLinksByProxyEmailId($proxyEmail->getId())->getReceivedEmailLinks();
    echo "Amount of received emails: " . count($receivedEmails) . "\n";
    foreach ($receivedEmails as $receivedEmail) {
        echo "Have received email: \n";
        var_dump($receivedEmail); //you can also receive a payload here. Check out attributes

        echo "\n";
    }

    echo "\n";

    sleep(1);
}

Payload example

All of our examples contain a payload. Example of email payload:

{
   "id":"EB442408-D500-0000-00003CC8",
   "payload":{
      "Content-Type":"multipart\/alternative; boundary=\"000000000000714564060f56f6c2\"",
      "Date":"Sat, 20 Jan 2024 02:00:25 +0000",
      "Dkim-Signature":"DKIM",
      "From":"Alex Yatsenko <sender@gmail.com>",
      "Message-Id":"<CAJj9C9dVhSJZDwRDM-H=vhzPttpg253biEvabFtEHiS4wriK8A@mail.gmail.com>",
      "Mime-Version":"1.0",
      "Received":"by mail-wm1-f44.google.com with SMTP id 5b1f17b1804b1-40e9ffab5f2so10064475e9.1 for <4bd6c97b9@proxiedmail.com>; Fri, 19 Jan 2024 18:00:38 -0800 (PST)",
      "Subject":"hey mate",
      "To":"4bd6c97b9@proxiedmail.com",
      "X-Envelope-From":"sender@gmail.com",
      "X-Mailgun-Incoming":"Yes",
      "X-Received":"Received details",
      "body-html":"<div dir=\"ltr\">hey hey<\/div>\r\n",
      "body-plain":"hey hey\r\n",
      "domain":"proxiedmail.com",
      "from":"Alex Alex <sender@gmail.com>",
      "message-headers":"HEADERS JSON....",
      "recipient":"4bd6c97b9@proxiedmail.com",
      "sender":"sender@gmail.com",
      "signature":"....",
      "stripped-html":"<div dir=\"ltr\">hey hey<\/div>\n",
      "stripped-text":"hey hey",
      "subject":"hey mate",
      "timestamp":"1705716046",
      "token":"..."
   },
   "attachments":[

   ],
   "recipient":{
      "address":"4bd6c97b9@proxiedmail.com"
   },
   "receivedAt":"Sat Jan 20 2024 02:00:46 GMT+0000",
   "user":{
      "id":"1B3AAA43-11-0000-cc",
      "username":"username+t1@gmail.com",
      "token":"Bearer ...."
   }
}

Summary

Summarizing our information you can use both ways to receive emails: via callback and also using browsing emails.
The payload contains all of the information about email and attachments.

If you have any questions please contact devphp@pxdmail.com.
Feel free to check out the documentation as well.

You can also check out our dedicated article for laravel

How to receive emails into your backend applications via webhooks (PHP/JS/API)

Alex Yatsenko — Sat, 20 Jan 2024 22:35:26 +0000

Into

Hi mates,

It's Alex, I'm the founder of ProxiedMail and since 2020 I've been building the system that helps you to keep your data secure with a top-notch proxy-email solution, but also it provides a great API to interact with emails.

Have you ever thought about receiving emails straight into your application? Sorry, forgot to say that it's free for very basic usage, but It will be enough for a small application.
Anyway, we always appreciate your support and are ready to give ours.

Use cases

You could use it to display text on a big screen that visitors of your conference sent, in a photo printing machine, Zapier, or connect with the systems that don't provide an API other than an email message.
You can transmit the email signal that you sent somewhere to make the control easier or link the signals sent via emails to another system that supports webhooks.

The last case was used by a customer who came to us to set up an alarm arming/disarming system via email message.
I don't know much of the details, but it sounds cool.
Just think about what kind of great apps you can build using this tool.

Code examples

There a PHP and JS clients already built, but if you don't use those wonderful languages you can use pure API or just request a client for your language.

PHP ❤️

Let's start with my favorite language and it's PHP:

<?php

use ProxiedMail\Client\Config\Config;
use ProxiedMail\Client\Entities\ResponseEntity\OauthAccessTokenEntity;
use ProxiedMail\Client\Entrypoint\PxdMailApinitializer;
use ProxiedMail\Client\Facades\ApiFacade;

require 'vendor/autoload.php';


// put here your ProxiedMail credentials
$email = 'example.com';
$pass = '1';

/**
 * @var ApiFacade $facade
 */
$facade = PxdMailApinitializer::init();
/**
 * @var OauthAccessTokenEntity $r
 */
$r = $facade->login($email, $pass);

//settings bearer token
$config = (new Config())->setBearerToken('Bearer ' . $r->getBearerToken());
$facade = PxdMailApinitializer::init($config);

//receiving API token by bearer token
$apiToken = $facade->getApiToken();

$config = new Config();

//setting API token
$config->setApiToken($apiToken->getApiToken());

$api = PxdMailApinitializer::init($config);

$wh = $api->createWebhook(); //creating webhook-receiver
$proxyEmail  = $api->createProxyEmail(
    [],
    null,
    $wh->getCallUrl() //specifying webhook URL
);



// while (true) with 100 seconds limit
foreach(range(0, 100) as $non) {
    echo "PROXY-EMAIL: " . $proxyEmail->getProxyAddress() . "\n";
    echo "Send the email to this proxy-email to get email payload printed here";

    //checking webhook receiver 
    $whStatus = $api->statusWebhook($wh->getId());

    echo "Webhook STATUS: \n";
    echo "Received: " . ($whStatus->isReceived() ? 'yes' : 'no') . "\n"; //printing webhook status

    //printing payload if received
    if ($whStatus->isReceived()) {
        echo "WEBHOOK PAYLOAD: \n";
        echo json_encode($whStatus->getPayload());
        break;
    }


    echo "\n";

    sleep(1);
}

Those codes create a proxy email address that is used to receive email messages and get them via built-in ProxiedMail callback.
You can run the example on your machine and check it out.
Here's the potential result if you did everything in the right way:


PROXY-EMAIL: 4bd6c97b9@proxiedmail.com
Webhook STATUS: 
Received: no

PROXY-EMAIL: 4bd6c97b9@proxiedmail.com
Webhook STATUS: 
Received: no

PROXY-EMAIL: 4bd6c97b9@proxiedmail.com
Webhook STATUS: 
Received: yes
WEBHOOK PAYLOAD: 
{"id":"EB442408-D500-0000-00003CC8","payload":{"Content-Type":"multipart\/alternative; ...

JSON was cut to make this article shorter. Anyway, I have included the completed version for all API docs and clients.

We're continuously asking for our callback URL info if there is any callback was sent to it.
Let's talk about built-in callback receivers further in this article.

JS

So, now we can dive deep into js. It's not as nice as PHP but still, some of you probably using it.

let ProxiedMailApi = require('proxiedmail-api');

let apiInstance = new ProxiedMailApi.UserApi();


let authReq = {
    'authRequest': ProxiedMailApi.AuthRequest.constructFromObject(
        {
            "data": {
                "type": "auth-request",
                "attributes": {
                    "username": "example@example.com", //please pass your credentials here after sign up
                    "password": "example"
                }
            }
        }
    )
};

//logging in
apiInstance.userAuth(authReq, (error, data, response) => {
    if (error) {
        console.error("error:" + error);
    } else {
        let token = data.data.attributes.token;
        var apiApiClient = new ProxiedMailApi.ApiApi();
        apiApiClient.apiClient.authentications['api_auth'].accessToken = token; //settings bearer token

        //getting api token
        // your can skip this step and get one on the UI https://proxiedmail.com/en/settings
        apiApiClient.apiV1ApiTokenGet((error, data, response) => {
            if (error) {
                console.error("error:" + error);
            }

            //settings up api token
            let apiToken = data.token;
            var callbackApi = new ProxiedMailApi.CallbackApi();
            callbackApi.apiClient.authentications['api_key'].apiKey = apiToken;

            // creating built-in callback-receiver
            callbackApi.addCallback((error, cb, response) => {
                const proxyBindingPayload = {'proxyBindingCreate': createProxyBindingPayload(cb.call_url)}

                var proxyBindingApi = new ProxiedMailApi.ProxyBindingApi();
                //creating proxy-email and assigning callback url
                proxyBindingApi.addProxyBinding(proxyBindingPayload, (error, pb, response) => {

                    //continuously checking callback status to get the email
                    //just send the email to pb.data.attributes.proxy_address to check it out
                    const interval = setInterval(function () {
                        callbackApi.apiV1CallbackGetHashGet(cb.id, function (error, cbInfo) {
                            console.log('check callback. email: ' + pb.data.attributes.proxy_address);
                            console.log(cbInfo)

                            //printing email info about callback
                            if (cbInfo.is_received) {

                                console.log('received')
                                console.log(cbInfo)
                                console.log('Subject: ' + cbInfo.payload.payload.Subject)
                                console.log('Message: ' + cbInfo.payload.payload['body-plain'])
                                console.log('From: ' + cbInfo.payload.payload['from'])

                                clearInterval(interval);
                            }

                        });
                    }, 2000);
                });
            } )

        });
    }
});


//callback construction function
function createProxyBindingPayload(callbackUrl) {
    return ProxiedMailApi.ProxyBindingCreate.constructFromObject(
        {
            "data":{
                "type":"proxy_bindings",
                "attributes":{
                    "real_addresses":[], //on empty it will generate internal real address
                    //that kind of real addresses is not forwarding anything to any email
                    //however if you need forwarding just use something like "abc@example.com"
                    //please note that real address should be confirmed
                    "proxy_address": null,
                    "callback_url": callbackUrl
                }
            }
        }
    );
}

JS code is a little bit longer as the client was generated via the OpenAPI generator, but still works fine. It also uses built-in webhook receivers.

Features

As we have talked about the practical side you saw how to use its to use PM for your potential tasks let's talk about the features and specialities of API.

Built-in webhook receiver As I mentioned previously it's a thing that allows you to create a special URL that will receive a callback for you. Then, you will be able to continuously ask if there was something received via API. It's made to make our application work synchronously. Otherwise, we had to set up a server that was available for calls from outside, because proxy emails accept only callback URLs.
Proxy-email ProxiedMail was built to provide proxy email. You can go there and create endless proxy emails like pm1@proxiedmail.com, and pm2@proxiedmail.com and when you're using it the messages will be redirected to your real email OR|AND callback URL. It's not the topic of the article, but it's not cool to use one email everywhere. Just for you to be on the same page with us.
Callback receiving UI We're storing logs, so if you're not using built-in callback receivers you can check out the response of your API. Also, even if you're using it you can still check out if the email webhook was delivered
Own domains You can also attach your own domain to the system to create proxy emails like abc@myowndomain.com. So you will be able to receive webhook using your own domain.

That's quite a full list of what you should be aware about.

Links to start from

ProxiedMail - https://proxiedmail.com/
PHP Client - https://github.com/proxied-mail/proxiedmail-php-client
JS Client - https://github.com/proxied-mail/proxiedmail-js-client
Docs - http://docs.proxiedmail.com/
Swagger - https://proxiedmail.com/api/v1/api-docs.yaml (just copy and paste it to the swagger editor)

Conclusion

In the end, you can use ProxiedMail to receive emails straight into your application with JS, PHP client, Rest API, or wait for the client of your favorite language.
Feel free to give us any kind of feedback.
Also, text me if any help is needed.

Running non-blocking A/B tests, feature flags with Laravel, PHP

Alex Yatsenko — Fri, 24 Jun 2022 12:46:54 +0000

Hey guys. My name is Alex. I'm a software engineer in unicorn by day and the founder of a couple of SaaS projects by night (and evening sometimes). From Ukraine, now living in Porto.

Introduction

This story is about the ABRouter - new open-source platform for running A/B tests, feature flags, and collecting statistics on the back-end side with the high level of support of Laravel, PHP, and Symfony.

Additionally, that tool supports Parallel Running - built-in mode that allows using the features in non-blocking mode. All that you need to do - is configure the queues and Redis on your project. Unfortunately, this mode is not supported for Symfony now, but you can help us implement it (because the tool is open-source).

As I said, the tool is fully open-source, and I have almost nothing to sell, except for the cloud version, hah :)

Our first task with A/B test

So, I propose to start implementing first A/B test with a simple example - testing the most convertible color of the checkout button. For example, your current color of the sign-up button is blue, but you want to check, what if the green button will be more convertible?

Goal: To test the most convertible color of the form button
Branches distribution: red - 33%, green - 33%, blue - 33%.
Technical task: assign the color of the button: which the user got into.

Creating the first A/B test on the ABR side

Step 1

Sign-up by the link

Please, note you can deploy ABRouter locally or on your remote server.
learn more about deploying

Step 2

Create your experiment

Pay attention to the Experiment ID. You will use it as the identifier of the experiment to run it.

Step 3

Grab the data
After creating the A/B test you can get the important data to run it.
Experiment id:

Token:

Configure application side

If you're using Laravel:

Install the library to your codebase on PHP:https://github.com/abrouter/laravel-abtest

This library is based on the main ABRouter client:https://github.com/abrouter/abrouter-php-client

composer requires abrouter/laravel-abtest
This package provides auto-discovery for the service provider. If Laravel package auto-discovery is disabled, add service providers manually in your /app/app.php of your repository.
There are service providers you must add:
\Abrouter\LaravelClient\Providers\AbrouterServiceProvider::class

Publish client configuration:
php artisan vendor:publish --tag=abrouter
Configure the client:

<?php
declare(strict_types = 1);

return [
    'token' => '0ea94e3527644b8e6259b790d866223490f3c91634bbfd0eb978b4a57a4d835d57ab5195f892b15d',
    'host' => 'https://abrouter.com',
];

If you're using vanilla PHP:

composer require abrouter/abrouter-php-client

abrouter/abrouter-php-client repository on Github

Please, visit the repository for configuration instructions. The package wouldn't work without DI. So, if you're not using DI yet, try PHP-DI.

If you're using Symfony:

Install the library to your codebase on PHP:

https://github.com/abrouter/symfony-abtest

composer require abrouter/symfony-abtest

Register the bundle:

// config/bundles.php
return [
// [...]
Abrouter\SymfonyClient\AbrouterClientBundle::class => ['all' => true],
];

Put your ABRouter token in /config/packages/abrouter_client.yaml

abrouter_client:
  token:                ''
  host:                 'https://abrouter.com'

Common recommendations

Feel free to learn additional details in the repositories of framework you're using. If you want to configure Parallel(non-blocking) running please read package instructions.

Start coding A/B test

If you're using Laravel:

<?php

use Abrouter\Client\Builders\StatEventBuilder;
use Abrouter\Client\Client;

class ExampleController
{
    public function __invoke(Client $client, StatEventBuilder $statEventBuilder)
    {
        $userId = auth()->user()->id;
        $buttonColor = $client->experiments()->run($userId, 'button_color_test');

        //send the statistics
        $client->statistics()->sendEvent(
            $eventBuilder
                ->incremental()
                ->event('button_test_visit')
                ->setUserId($userId)
                ->build()
        );


        return view('button', [
            'color' => $buttonColor->getBranchId(),
        ]);
    }
}

Additionally, check out the example for Laravel https://github.com/abrouter/laravel-example

If you're using vanilla PHP:

<?php

use Abrouter\Client\Config\Config;
use DI\ContainerBuilder;
use Abrouter\Client\Client;

require '/app/vendor/autoload.php';

$containerBuilder = new ContainerBuilder();
$di = $containerBuilder->build();

$token = '04890788ba2c89c4ff21668c60838a00a87b1cf42c9c6b45d6aa8e11174f0d5762b16b6c09b6b822'; //you can find your token in ABRouter dashboard

$di->set(Config::class, new Config($token, 'https://abrouter.com'));
/**
 * @var Client $client
 */
$client = $di->make(Abrouter\Client\Client::class);

$statBuilder = $di->make(Abrouter\Client\Builders\StatEventBuilder);

$userSignature = $_SESSION['user_id'] ?? uniqid();
$experimentId = 'button_color_test';//experiment id is also there


$runExperimentResult = $client->experiments()->run($userSignature, $experimentId);

//sending button_test_page_visit event as button_test_page_visit+1
$client->statistics()->sendEvent(
     $eventBuilder
        ->incremental()
        ->event('button_test_visit')
        ->setUserId($userId)
        ->build()
);


$experimentId = $runExperimentResult->getExperimentId(); //form-color
$branchId = $runExperimentResult->getBranchId(); //red
echo '<button style="color: '. $branchId .'">Hello</button>';

If you're using Symfony:

<?php

namespace App\Controller;

use Abrouter\Client\Client;
use Abrouter\Client\Manager\ExperimentManager;
use Symfony\Component\HttpFoundation\Response;
use Abrouter\Client\Builders\StatEventBuilder;

class IndexController
{
    public function index(Client $client, StatEventBuilder $statBuilder)
    {
        $userId = $this->getUser()->getUsername();

        //sending button_test_page_visit event as button_test_page_visit+1
        $client->statistics()->sendEvent(
             $eventBuilder
                ->incremental()
                ->event('button_test_visit')
                ->setUserId($userId)
                ->build()
         );


        /**
         * The button color will be changed 50% green/50% red
         */
        $buttonColorExperimentId = 'button_color_test';
        return new Response(json_encode([
            'button_color' => $client
                ->experiments()
                ->run($userId, $buttonColorExperimentId)->getBranchId(),
        ]));
    }
}

Additionally, check out the example for symfony https://github.com/abrouter/symfony-abtest-example

Results variations of A/B test

Color of the button will be automatically changed on each request for every page reload. Because we have used uniqid(). ABRouter system will memorize the relation between user identifier and branch he got, so if we will repeat the request with the same user identifier we will get the same branch as on previous run.

Tracking

Feel free to send the statistics to the ABRouter server. The product support showing statistics by experiment and over all. Learn more about the statistics in the docs.

Running feature flag example

Running feature flag is a kind common for all platforms. Let's see how to do it with Laravel:

<?php
declare(strict_types = 1);

namespace App\Http\Controllers;

use Abrouter\Client\Client;

class ExampleFeatureFlagsController
{
    public function __invoke(Client $client)
    {
        $enabledButtonFeatureFlag = $client->featureFlags()
            ->run('enabled_button_feature_flag');
        $disabledButtonFeatureFlag = $client->featureFlags()
            ->run('disabled_button_feature_flag');

        return view(
          'featureFlags',
          [
            'enabledButtonFeatureFlag' => $enabledButtonFeatureFlag,
            'disabledButtonFeatureFlag' => $disabledButtonFeatureFlag,
          ]
        );
    }
}

Useful links

Deploy ABRouter locally or on the remote server
Running feature flags
Laravel client GitHub - includes full instructions for running on Laravel
PHP client GitHub - includes full instructions for running on PHP
Symfony client GitHub - includes full instructions for running on PHP
ABRouter website

Summary

I have shown you how to implement an A/B test, feature flags and send the statistics with Laravel, Symfony and PHP via ABRouter. Looks like it's quite simple.
Please, remember, that every change that you are making to the app should be through an A/B test. It's a key to build a successful product.

If you have any questions, feel free to ask me at abrouter@proxiedmail.com

Thank you for reading.