Proxy not working as supposed to?

[nikoladragic-haf]

hi everyone.
When I run the validation without using proxy, it returns correct results.
When I run the validation with valid proxy configuration, it doesn't return correct results.

When I use the same proxy with reacher open source email script, it works just fine.

So not sure what is the problem? This code not compatible with SMTP proxy?

proxyURI := fmt.Sprintf("socks5://%s:%s@%s:%s?timeout=%ds",
			encodedUser, encodedPassword, proxyHost, proxyPort, proxyTimeout)

		verifier = verifier.Proxy(proxyURI)

[nikoladragic-plassido]

@henhouse @carlosxl @iwinux @L42y

Apologise for tagging you all but this seems like the high priority one as 99% of people would use proxy for these kinds of stuff :)

[git-hulk]

@nikoladragic-plassido pls provide the version you're using and your error stack. It's hard to figure out what's going wrong with the present information.

[nikoladragic-plassido]

Hello,
I don't get any error, just that results is basically unknown or it says that the email address is invalid.

When I get off the proxy it says it's valid. Tried multiple email addresses.

github.com/AfterShip/email-verifier v1.4.1 h1:vDmnqq680siSLw8rtiAYaqgmqYeW+AUoMfEY1RjWK8k=
github.com/AfterShip/email-verifier v1.4.1/go.mod h1:AcFyA5b7X6L4l5dBuemWBSh8mq74nxkBTtoWgLOFrbw=

var verifier *emailverifier.Verifier

func initVerifier() {
	// Get proxy configuration from environment variables
	proxyUser := os.Getenv("PROXY_USER")
	proxyPassword := os.Getenv("PROXY_PASSWORD")
	proxyHost := os.Getenv("PROXY_HOST")
	proxyPort := os.Getenv("PROXY_PORT")

	// Get timeout configuration
	connectTimeout := getEnvAsInt("CONNECT_TIMEOUT", 30)
	operationTimeout := getEnvAsInt("OPERATION_TIMEOUT", 60)
	proxyTimeout := getEnvAsInt("PROXY_TIMEOUT", 60)

	// Get SMTP identification (even with proxy, these might matter)
	fromEmail := os.Getenv("FROM_EMAIL")
	helloName := os.Getenv("HELLO_NAME")

	// Initialize verifier with options and timeouts
	verifierBuilder := emailverifier.NewVerifier().
		EnableSMTPCheck().
		EnableDomainSuggest().
		ConnectTimeout(time.Duration(connectTimeout) * time.Second).
		OperationTimeout(time.Duration(operationTimeout) * time.Second)

	// Add FROM_EMAIL and HELLO_NAME if provided (may override proxy defaults)
	if fromEmail != "" {
		verifierBuilder = verifierBuilder.FromEmail(fromEmail)
		log.Printf("FROM_EMAIL set to: %s", fromEmail)
	}
	if helloName != "" {
		verifierBuilder = verifierBuilder.HelloName(helloName)
		log.Printf("HELLO_NAME set to: %s", helloName)
	}

	verifier = verifierBuilder

	// Configure proxy if credentials are provided
	if proxyUser != "" && proxyPassword != "" && proxyHost != "" && proxyPort != "" {
		// Check if we should skip URL encoding (for pre-encoded credentials)
		skipEncoding := os.Getenv("PROXY_SKIP_URL_ENCODING")

		var encodedUser, encodedPassword string
		if skipEncoding == "true" {
			// Use credentials as-is (already encoded or no special chars)
			encodedUser = proxyUser
			encodedPassword = proxyPassword
			log.Printf("⚠️  Using proxy credentials as-is (URL encoding disabled)")
		} else {
			// URL encode credentials to handle special characters
			encodedUser = url.QueryEscape(proxyUser)
			encodedPassword = url.QueryEscape(proxyPassword)
			if proxyUser != encodedUser || proxyPassword != url.QueryEscape(proxyPassword) {
				log.Printf("⚠️  Credentials were URL-encoded (contained special characters)")
			}
		}

		// Format: socks5://user:password@host:port?timeout=XXs
		// Some proxy implementations don't support the timeout parameter
		includeTimeout := os.Getenv("PROXY_INCLUDE_TIMEOUT")
		var proxyURI string
		if includeTimeout == "false" {
			proxyURI = fmt.Sprintf("socks5://%s:%s@%s:%s",
				encodedUser, encodedPassword, proxyHost, proxyPort)
			log.Printf("⚠️  Proxy timeout parameter excluded from URI")
		} else {
			proxyURI = fmt.Sprintf("socks5://%s:%s@%s:%s?timeout=%ds",
				encodedUser, encodedPassword, proxyHost, proxyPort, proxyTimeout)
		}

		verifier = verifier.Proxy(proxyURI)

		log.Printf("Proxy configured: socks5://%s:***@%s:%s?timeout=%ds", encodedUser, proxyHost, proxyPort, proxyTimeout)
	} else {
		log.Println("No proxy configured - set PROXY_USER, PROXY_PASSWORD, PROXY_HOST, and PROXY_PORT environment variables to use proxy")
	}

	log.Printf("Verifier configured with: SMTP Check, Domain Suggest (Catch-All: DISABLED)")
	log.Printf("Timeouts configured - Connect: %ds, Operation: %ds, Proxy: %ds", connectTimeout, operationTimeout, proxyTimeout)
}

func verifyEmailHandler(w http.ResponseWriter, r *http.Request) {
	// Set response header
	w.Header().Set("Content-Type", "application/json")

	// Only allow GET and POST methods
	if r.Method != http.MethodGet && r.Method != http.MethodPost {
		w.WriteHeader(http.StatusMethodNotAllowed)
		json.NewEncoder(w).Encode(ErrorResponse{Error: "Method not allowed. Use GET or POST"})
		return
	}

	var email string

	if r.Method == http.MethodGet {
		// Get email from query parameter
		email = r.URL.Query().Get("email")
	} else {
		// Parse JSON body for POST request
		var req VerificationRequest
		err := json.NewDecoder(r.Body).Decode(&req)
		if err != nil {
			w.WriteHeader(http.StatusBadRequest)
			json.NewEncoder(w).Encode(ErrorResponse{Error: "Invalid JSON body"})
			return
		}
		email = req.Email
	}

	if email == "" {
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(ErrorResponse{Error: "Email parameter is required"})
		return
	}

	log.Printf("Verifying email: %s", email)
	startTime := time.Now()

	// Verify the email
	ret, err := verifier.Verify(email)

	duration := time.Since(startTime)
	log.Printf("Verification completed for %s in %.2f seconds", email, duration.Seconds())

	if err != nil {
		log.Printf("Verification error for %s: %v", email, err)
		w.WriteHeader(http.StatusInternalServerError)
		json.NewEncoder(w).Encode(ErrorResponse{Error: fmt.Sprintf("Verification failed: %s", err.Error())})
		return
	}

	// Log key metrics
	log.Printf("Result summary - Reachable: %s, Deliverable: %v, Has MX: %v",
		ret.Reachable,
		ret.SMTP != nil && ret.SMTP.Deliverable,
		ret.HasMxRecords)

	// Log SMTP details if present (critical for debugging proxy issues)
	if ret.SMTP != nil {
		log.Printf("SMTP Details - Host Exists: %v, Catch-All: %v, Full Inbox: %v, Disabled: %v, Deliverable: %v",
			ret.SMTP.HostExists, ret.SMTP.CatchAll, ret.SMTP.FullInbox, ret.SMTP.Disabled, ret.SMTP.Deliverable)
	} else {
		log.Printf("⚠️  WARNING: SMTP is nil - SMTP check may have failed completely")
	}

	// Log the full result as JSON for debugging
	resultJSON, _ := json.MarshalIndent(ret, "", "  ")
	log.Printf("Full Result for %s:\n%s", email, string(resultJSON))

	// Prepare response
	response := VerificationResponse{
		Email:        email,
		Reachable:    ret.Reachable,
		Syntax:       ret.Syntax,
		SMTP:         ret.SMTP,
		Gravatar:     ret.Gravatar,
		Suggestion:   ret.Suggestion,
		Disposable:   ret.Disposable,
		RoleAccount:  ret.RoleAccount,
		Free:         ret.Free,
		HasMxRecords: ret.HasMxRecords,
	}

	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(response)
}

[proxy4smtp]

If you use your server IPs for SMTP email verification you will get blocked really fast. Proxies like proxy25.com are the only solution, unless you have the knowledge and time to implement a high reputation set of domains and IPs yourself.

[nikoladragic-plassido]

Hello @proxy4smtp
I do use a proxy provider but it doesn't use the proxy provided.
It works fine without proxy, but when I add proxy setup, it stops working completely.

For record, this same proxy works with other email validation scripts.

[proxy4smtp]

Hmm, something for Aftership to fix I guess ;-)