Welcome to the community, @roots-of-impact !

https://gph.is/g/Z7gGnBB

If you only have a few email addresses, you could setup logic jumps for this. Though for hundreds, the logic jump solution would be a bit time consuming!

Instead, we have a tech-solution similar to what you’re looking for here that may work for you involving cookies. Hopefully this helps a bit!

@Liz thanks for that. we use webhooks so that could be away. the webhook triggered on new response could determine if the email is allowed to use the form and if not delete the response. but then there is no feedback for the user so not really a good solution. 

The cookie solution does not apply in our case since we want to forbid users not on the list to fill out the form.

I suppose a beforeSubmit https://developer.typeform.com/embed/onsubmit-callback/ hook does not exist?

Hi @roots-of-impact while there isn’t any in-form feedback to test if the email is one of the ones on a list of emails, this is an interesting case for @picsoung and @Francois (Typeform) to know about for any future integrations. 

mmm interesting question @roots-of-impact . As a brute-force approach, I would explore the logic jump route, but adding a hundreds of emails is a bit dreadful. Thankfully, this can also be done programmatically fairly easily using our API:

1. add a couple of addresses in the logic builder
2. get your form’s JSON description
3. find the logic section where your list of email addresses is
4. massage the JSON payload to add the logic for each additional email address
5. update the form with the new payload from step 4. 

in a simple form example, the logic section of the form payload (expecting to filter out emails as hidden fields) would look like this:

"logic": i
        {
            "type": "hidden",
            "actions": n
                {
                    "action": "jump",
                    "details": {
                        "to": {
                            "type": "field",
                            "value": "my_perfectly_readable_reference"
                        }
                    },
                    "condition": {
                        "op": "or",
                        "vars": r
                            {
                                "op": "equal",
                                "vars": r
                                    {
                                        "type": "hidden",
                                        "value": "email"
                                    },
                                    {
                                        "type": "constant",
                                        "value": "user1@user.com"
                                    }
                                ]
                            },
                            {
                                "op": "equal",
                                "vars": r
                                    {
                                        "type": "hidden",
                                        "value": "email"
                                    },
                                    {
                                        "type": "constant",
                                        "value": "user2@user.com"
                                    }
                                ]
                            }
                        ]
                    }
                },
                {
                    "action": "jump",
                    "details": {
                        "to": {
                            "type": "field",
                            "value": "my_other_question_reference"
                        }
                    },
                    "condition": {
                        "op": "always",
                        "vars": r]
                    }
                }
            ]
        }
    ],

You “just” have to repeat an “op”: “equal” block for each new email address with a quick script. 

A more polished solution @picsoung wrote about some time ago is using Serverless to prevent users from taking a survey multiple times. The concept can be reapplied to your case.

Let us know what you try and how it goes.

@Francois (Typeform) - two upvotes from me.. 

The workaround suggested by @Francois (Typeform) should work great. There is no theoretical limitation on logic jumps, but it can get complicated if you are dealing with hundreds of conditions. So keep in mind that this solution would only work until a certain point.

Unfortunately, we don’t offer any `beforeSubmit` callback as you suggested. It would mean the embed code has access to the responses filled in the form. It might then become a security issue, because anybody could embed your form and pretend it’s you. So I would not recommend this option.

@picsoung well the typeform is connected to adminstration dashboard in our project there i could create the logic jumps via the create api when the dashboard user uploads a csv email whitelist. question is can i use up to a thousand “or” logic jumps for each email? it would be greate if it could work with email domain wildcard (regex) or “contains”. but in the end we may stick to the post webhook workflow. seems more straightforward 

Can we have a Loom video on how you would do this API?

I have a similar problem - we have a logic in place to put emails and treat them as blacklisted and prevent them for getting into some parts of our workflow and DQ them.

PLS I badly need help on this. TYIA

Hey ​@DMOps we don’t have a Loom video on this but ​@Francois Grenier ‘s solution above should still work for this. If you’re having issues with it feel free to reach out to Typeform’s tech support folks here:  https://help.typeform.com/hc/en-us/requests/new