How to Test 554 Error in API When Domain Rejects Non-Verified IP 2026
Learn how to test 554 errors in your API when a domain blocks mail from non-verified IPs. Use real-time verification and deliverability testing to fix.
What does a 554 error mean when your API sends mail?
You send a message via your API, the system confirms delivery — then, hours later, you check your logs and find a 554 error. Not a timeout. Not a transient issue. A hard rejection.
That code means the recipient’s server is saying “no” with finality. It’s not a temporary hiccup. It’s a firewall. If your API is sending from a non-verified IP, the domain is likely rejecting you based on sender reputation, IP allowlisting, or strict anti-spam rules.
Understanding this isn’t just technical trivia. It’s about fixing delivery before your automation fails silently. When your API sends mail to a domain that blocks unknown IPs, you’re not just losing a single email — you’re risking reputation, deliverability, and automation reliability across entire campaigns.
Key takeaways
- 554 errors indicate permanent SMTP rejection, not temporary failure—your message won't be retried automatically.
- Domains use 554 responses to enforce IP-based access control, such as requiring pre-registered IPs or strict SPF/DKIM alignment.
- Testing this error in your API workflow means validating IPs against recipient policies before sending, not after.
Why does your domain reject mail from non-verified IPs?
When your domain rejects mail from non-verified IPs, it's usually because the recipient’s email server enforces strict sender policies—most commonly SPF (Sender Policy Framework)—which only allows messages from IP addresses explicitly listed in their domain’s DNS record. If your sending IP isn’t on that list, the server responds with a 554 error, rejecting the message before it even arrives.
SPF is the primary gatekeeper
SPF is an email authentication method that lets domain owners specify which IP addresses are authorized to send emails on their behalf. If your sending IP isn’t included in the recipient’s SPF record, their server blocks your message. This is not a flaw—it’s standard email hygiene. According to RFC 7208, SPF is one of the core mechanisms used to prevent email spoofing.
Let’s say you send from a third-party service or a custom server. If that IP isn’t explicitly allowed in the recipient’s SPF policy, the server will return a 554 error with a message like "554 5.7.1 Sender denied by policy." This doesn’t mean your message is malicious—it just means it didn’t pass that domain’s sender validation rules.
Advanced checks often follow
Some domains go beyond SPF. They use IP reputation systems—like those from Spamhaus or Google’s Safe Browsing—to block messages from known spam sources, regardless of SPF. Others enforce DMARC policies, which require alignment between the From domain and the SPF or DKIM authentication results. Even if SPF passes, failing DMARC can still result in rejection.
These mechanisms work together: SPF verifies the sender’s IP, DKIM checks message integrity, and DMARC decides what to do with messages that fail either. A 554 error may reflect failure in any of these layers. The most common case remains SPF, especially with enterprise or security-conscious domains.
You can prevent 554 errors from non-verified IPs by proactively checking your sender IP against recipient domains. Tools like bulk verification can test whether a list of emails is valid and whether their domains likely reject unverified senders based on DNS-level checks. For automated workflows, our real-time verification API checks email validity, MX records, and basic SPF alignment before sending. This reduces bounce rates and inbox placement issues long before they hit your outbound system.
Can a 554 error happen even if the email is valid?
Yes—valid email addresses can still trigger a 554 error, even when the recipient's inbox exists and is correctly formatted. The 554 error indicates the receiving mail server rejected the message based on sender policy, not the address itself. This means your email might be perfectly valid, but your IP address isn’t trusted by the recipient’s domain.
Why the 554 error isn't about the email address
When you see a 554 error during an API send, it’s a delivery rejection, not a validation failure. The server is saying: "I know your address is real, but I don’t accept mail from you." This is common when a domain restricts inbound mail to only specific IPs or requires strict authentication like SPF, DKIM, or DMARC. These policies are often enforced through blacklists or access controls tied to the sender’s IP.
For example, a company might set up their mail server to only accept messages from known office IPs or their managed email service. If your API sends from a different IP—say, a public cloud instance—you’ll get a 554 even if the email is valid. This isn’t a flaw in the address; it’s a deliberate policy decision by the destination domain.
How this exposes a gap in email validation
Many tools only check if an email follows the correct format and exists on the receiving server. They don’t verify whether the sending IP is allowed. That’s why a perfect “valid” email can still fail in real-world delivery. The 554 error shows that delivery isn’t just about the recipient—it’s about the sender’s reputation, domain policies, and technical setup.
According to RFC 5321 (SMTP), the 554 response code means “Transaction failed” due to policy reasons—commonly seen when the sender doesn’t meet requirements like sender authentication or IP reputation thresholds. This is widely documented across email infrastructure guides, including those from RFC 5321 and IETF.
Even if you’ve verified the email at scale, this gap means you must test delivery separately. That’s where inbox placement testing comes in. It simulates real sends from real IPs and checks not just validity—but whether your message actually lands in the inbox. For teams building APIs or managing bulk sends, testing with real delivery scenarios is more reliable than static verification alone.
You can test this by using a service like inbox placement testing, which evaluates how your emails perform across different providers under real-world conditions. It helps you catch 554-level issues before sending to real users.
How to verify if your API’s sending IP is blocked by a domain
If your API receives a 554 error when sending to a domain, it means the recipient server explicitly rejected your message, often due to IP reputation, missing SPF, or active blocking. To confirm whether your sending IP is blocked, run real-time SMTP checks that simulate a send and capture the exact response code, then validate your domain’s SPF record against your actual outbound IP. Use tools that test from multiple IPs to rule out isolated issues.
Test SMTP responses with real-time verification tools
Let’s be clear: a 554 error doesn’t always mean your IP is blocked—it could be a misconfigured server, greylisting, or a catch-all policy. The only way to know is to test directly. Use a real-time verification tool that connects to the recipient’s mail server via SMTP and reads the exact response code returned during the handshake. This reveals whether the rejection is due to IP blacklisting, SPF failure, or server-level block rules.
These tools don’t just guess—they send actual SMTP probes and return the real server response. Some services simulate the entire send process, including HELO, MAIL FROM, and RCPT TO commands, so you get data that matches what your API sees in production.
For instance, email verification via our API lets you test individual emails in real time, returning exact SMTP responses like 554 (reject) or 250 (accept), along with detailed diagnostics. This is the closest you can get to mimicking your API’s actual outbound behavior without sending actual mail.
Check DNS configurations against your actual sending IP
Even if your IP isn’t blacklisted, it can still be rejected due to SPF policy violations. SPF (Sender Policy Framework) is a DNS record that lists authorized sending IPs for a domain. If your outbound IP doesn’t appear in that record, the server may reject your messages with a 554 error—even if the IP is reputable.
You can check a domain’s SPF record using tools like MXToolbox or RFC 7208, which defines SPF behavior. Compare the IP in the record to your actual sending IP. If your IP isn’t listed, that’s why the recipient rejected you.
Also consider DMARC and DKIM—they don’t cause 554 errors directly, but weak alignment can lead to filtering. If a domain enforces strict DMARC policies, failing alignment may result in rejection, even if SPF passes. This is common with enterprise email systems and shared hosting setups.
How to test 554 errors in API when domain rejects mail from non-verified IP
You can test 554 errors caused by domain-level IP rejection by sending a real email via your API to a known valid address on the target domain. Monitor the SMTP response for a 554 code with a rejection message like "Relay denied" or "Blocked by policy." Use a tool that simulates full SMTP handshake and logs the full transaction, including remote server decisions. Confirm whether the error happens only with your IP or across all external IPs. Cross-reference your sending IP against the domain's SPF record to verify if it’s authorized or excluded.
Diagnose the 554 error using a real SMTP simulation
Let’s walk through the steps to isolate and confirm the root cause. Start by sending a test email through your API to a known working address on the domain (e.g., [email protected], assuming you know it's valid).
- Send via your API to a known valid inbox. Use a test address you’ve confirmed receives mail from third parties. This eliminates false positives from invalid addresses.
- Inspect the SMTP return response. Check the exact 554 error code and message. For example, "554 5.7.1 Unable to relay for..." indicates the domain is not accepting mail from your IP.
- Use an SMTP simulator to capture the full handshake. Tools like MxToolbox or Anti-Spam.org can run a real SMTP session and show you the exact point of rejection. This helps you see if it's a policy, a missing SPF, or a blocked IP.
- Test from a different IP. Repeat the test from a known reputable IP (e.g., a shared SendGrid or Amazon SES IP). If the 554 error disappears, your original IP is blocked or misconfigured.
- Verify SPF alignment. Check the target domain’s SPF record using RFC 7208. If your IP isn’t listed, the domain will reject your mail. You can also use bulk email verification to test multiple addresses and validate deliverability patterns ahead of sending.
When the issue is policy-based or IP-restricted
Some domains only accept mail from whitelisted IPs or require specific authentication. If your IP isn’t in the SPF record or the domain uses a sender whitelist (like a customer-only portal), you’ll hit a 554 error. The fix may require using a verified sending service, signing up through a partner program, or setting up dedicated infrastructure. Always test deliverability in staging before full rollout.
How Emaillistchecker.io helps test 554 errors and sender IP trust
You can test 554 errors and sender IP trust by using Emaillistchecker.io’s real-time API to simulate outgoing mail from specific IPs against target domains. It checks the actual SMTP response for rejection codes like 554 and returns detailed context—such as whether the block is due to SPF, sender reputation, or a hard blocklist—so you know if your IP is blocked before sending at scale. This avoids surprise bounces and protects your sender reputation.
Real-time API checks SMTP responses, not just syntax
Unlike tools that only check email format or basic syntax, Emaillistchecker.io’s API performs actual SMTP handshakes with recipient domains. It connects from your IP address, sends a test HELO, and reads the server’s response—exactly how real email delivery works. This reveals whether a domain actively rejects mail from your IP, returning accurate 554 responses when policy or blocklist rules are triggered.
When a 554 error occurs, the API doesn’t just say "rejected"—it tells you why. Common reasons include sender IP blacklisting, lack of DMARC policy, or explicit filtering rules. This context is critical to diagnose sender trust issues in real time, not after a delivery failure.
Simulate real mail flows to uncover hidden blocks
Deliverability tests with Emaillistchecker.io go beyond single checks. You can run bulk delivery simulations from different IPs across various networks to uncover if a domain rejects mail based on geography, IP reputation, or sending history. These tests mimic how real email providers evaluate senders, helping you spot policy blockers before they impact your campaign performance.
For instance, if your IP is on a shared proxy range or has been flagged by Spamhaus, you’ll see 554 errors during simulation. The system flags these patterns and tells you exactly what’s blocking you. This level of insight is standard in enterprise deliverability testing but often requires tools costing thousands. Emaillistchecker.io delivers this capability at scale with a transparent, pay-as-you-go model.
Use the real-time verification API to test how a domain responds to mail from your IP, or run inbox placement tests with your actual content to confirm your message lands in inboxes—and not the junk folder.
What happens when you send from a non-verified IP?
You send mail from an IP address not authorized by the recipient domain’s SPF record, and the receiving server rejects the message at the SMTP handshake stage with a 554 error—before it ever gets delivered. There’s no bounce-back notification, so you don’t know the message failed. This silent rejection harms your sender reputation over time, especially if repeated.
Why 554 errors happen at the SMTP level
When your server tries to deliver an email, the receiving mail server checks the sender’s IP against the domain’s SPF policy. If your IP isn’t listed as authorized, the server declines the connection immediately with a 554 error code. This is a hard rejection—no delivery, no delay, no delivery log. It happens before the message body is even processed.
According to RFC 7208, SPF is designed to prevent email spoofing by validating the sending IP against published policies. If the check fails, the server is free to reject the message outright. That’s why failing SPF leads directly to a 554, not a soft bounce or quarantine.
Because the rejection occurs before message acceptance, the sending server receives no delivery status notification. You get no “undeliverable” report, no failure event, and no auto-retry. This makes it easy to miss—and dangerous to ignore.
Reputation damage from repeated 554 failures
When your IP repeatedly attempts to send from unauthorized domains, especially with high volume, receiving servers begin to track that pattern. If a domain consistently sends from unverified IPs, it gets flagged as non-compliant. This can lead to your IP being added to blocklists or marked as suspicious by major email providers.
Even if your emails are otherwise well-formed and targeted, repeated 554 errors from an unverified IP signal poor sender hygiene. Over time, this reduces inbox placement across platforms—your mail lands in spam, junk, or isn’t delivered at all.
Let’s be clear: a 554 error is not about content. It’s about authentication. The recipient server isn’t rejecting your email because of a subject line or click rate. It’s rejecting you because you didn’t prove your IP was allowed to send.
Testing your IP validation setup beforehand avoids this. Use real-time email verification tools to validate sender domains and IPs before sending. At EmailListChecker’s API, you can verify list quality and test deliverability early—even before your campaign launches.
How to fix a 554 error in your API delivery flow
If your API encounters a 554 error when sending to a domain, it typically means the recipient’s mail server is rejecting your message because your IP isn’t authorized. You need to either authorize your sending IP via SPF records, use a trusted SMTP relay, or validate your IP against the domain’s policies before sending at scale. Let’s walk through the steps.
Fix the root cause before sending
- Update your domain’s SPF record to include your sending IP address. If you control the domain, use SPF's include mechanism to add your IP or IP range, then test with an SPF validator.
- If you don’t control the domain or can’t modify SPF records, use a third-party SMTP relay service like SendGrid, Mailgun, or Amazon SES. These services maintain verified IPs and are widely accepted by receiving mail servers.
- Before deploying your API at scale, test your sending IP against domains using a real-time verification tool—this catches issues like 554 rejections early.
- Enable logging in your API delivery stack to capture 554 errors. Analyze patterns to identify domains consistently blocking your IP or domain.
Proactively detect and prevent failures
- Use domain reputation services to check if a recipient’s domain maintains strict inbound policies. Some domains block traffic unless the sender’s IP is on a whitelist or has DMARC alignment.
- Monitor your API logs for recurring 554 errors. If you see consistent rejections from a specific domain, flag it and avoid sending to that domain until resolved.
- Validate email addresses and domains before adding them to your send list. This prevents sending to known bad domains or those with high rejection rates.
- Consider integrating with a service like bulk email verification, which can flag domains likely to trigger 554 errors based on historical rejection data.
554 errors are policy-based rejections — not technical failures. Fixing them requires aligning your sending method with the recipient's inbound rules.
Why real-time verification beats guesswork for 554 errors
You can’t reliably diagnose why a domain rejects mail from a non-verified IP by testing a few addresses manually. Real-time verification using an API checks thousands of emails instantly, revealing policy-driven rejections like 554 errors caused by IP reputation, missing authentication, or blocked sender domains — not just invalid syntax. This allows you to isolate IP-level issues before sending campaigns, reducing bounces and protecting sender reputation.
Manual tests miss the full picture
Testing individual addresses one by one gives you a narrow view. You might see a 554 error on one address, but not know if it’s because the email is invalid, the domain blocks your IP, or your sender reputation is poor. Manual testing can’t scale to reveal patterns across hundreds or thousands of recipients. Real-time API verification does — in minutes, not days.
It finds the root cause, not just symptoms
Many 554 errors aren't about bad emails — they’re about policy. Domains use SPF, DKIM, and DMARC to block unverified senders. Some also use reputation-based filtering or greylisting. Real-time verification checks more than syntax; it simulates the full SMTP exchange to detect if a rejection is due to missing authentication, sender reputation, or IP blacklisting. This is how you distinguish a bad email from a blocked IP.
Tools like Emaillistchecker.io’s real-time verification API check against known blocklists, verify domain configuration, and classify errors with high precision — giving you confidence in your data. With 98.9% accuracy, you act on results that reflect real deliverability conditions, not guesswork.
According to RFC 5321, SMTP 554 responses indicate a permanent failure, often tied to policy. A real-time system helps you confirm whether the issue lies with the recipient, your infrastructure, or your sender reputation — before you send a single campaign.
How to use inbox-placement testing to validate 554 fixes
You can validate that 554 errors caused by domain rejections from non-verified IPs are fixed by running inbox-placement tests. Send messages from your updated infrastructure to real inboxes across Gmail, Outlook, Yahoo, and others. Monitor whether emails arrive and where they land—inbox, spam, or quarantine. This confirms that SPF/DKIM alignment and IP reputation changes fixed the rejection.
Step-by-step inbox-placement validation process
- Send test messages after updating SPF or switching IPs Once you’ve reconfigured your email authentication or rolled out a new sending IP, wait at least 15 minutes for DNS changes to propagate. Then send test messages to a controlled set of real, known inboxes from your new configuration. This establishes a baseline for post-fix behavior.
- Use a dedicated inbox-placement service to send across providers Platforms like inbox-placement testing simulate delivery to real user inboxes at Gmail, Outlook, Yahoo, Apple Mail, and others. This is more reliable than internal tools because they use actual user account data, avoiding black-hole testing traps.
- Check delivery and filter placement across each email provider A successful test means the email reaches the inbox. If it lands in spam, it suggests content, sender reputation, or authentication issues remain. The 554 error should no longer appear if your domain's policy only allows verified IPs. Tracking where emails land gives you the real delivery score.
- Compare results before and after SPF/IP changes Run a test before applying fixes, then again after. If delivery rates to Gmail or Outlook improve significantly—especially in inbox placement—your 554 issue is likely resolved. For example, RFC 5321 and RFC 5322 define how receiving servers handle rejection codes like 554; if the domain’s policy now matches your sending IP, the rejection should stop.
- Use data to validate and iterate If some emails still get rejected, check the full delivery report. It may show that the domain's policy still blocks certain IPs or that DKIM signing isn’t consistent. Use this insight to fine-tune your setup. Continuous testing ensures reliability at scale.
You’re not alone: 554 errors are common in production APIs
High-volume API senders frequently hit 554 errors when domain policies block mail from unverified IPs. This is a deliberate security measure, not a sign of invalid data.
The error originates in sender configuration—specifically, the lack of proper SMTP authentication and IP reputation alignment—not the recipient’s email address. Ignoring this leads to blocked deliveries and degraded sender reputation.
Proactive SMTP-level verification catches these issues before sending. It prevents wasted volume and protects domain reputation by filtering out domains that reject non-verified IPs.
Sources
- By early 2026, 937,931 of 1.8 million analyzed domains had valid DMARC records — up 79% in three years — but about 56% of them still sit at monitoring-only p=none. — DMARC Report (EasyDMARC 2026 data) (2026)
Keep reading
- Email Verification API & SDKs: the complete developer guide (complete guide)
- SMTP 554 Error Due to Sender IP Policy? Fix with Email Verification API
- Trace 554 Error Troubleshooting in API Email Flow for Size Overflow
- How to Analyze 554 Error Response in Email API Payload with Detailed Explanation
- Debugging SMTP 220 Timeout Errors in API-Integrated Deliverability Testing
Ready to put this into practice? Emaillistchecker.io verifies emails with 98.9% accuracy — start with 100 free verifications.
Frequently asked questions
What does SMTP error 554 mean?
A 554 error means the receiving server permanently rejected your email. It usually indicates policy enforcement, such as IP-based blocking or strict SPF/DKIM rules.
Can a valid email cause a 554 error?
Yes—valid addresses can still be rejected if the sending IP is not authorized by the domain’s SPF or other access policies.
How do I test if my IP is blocked by a domain?
Use real-time SMTP verification tools to send test messages and inspect the response code. Emaillistchecker.io returns exact 554 details and rejection context.
Does SPF affect API email delivery?
Yes—SPF defines which IPs can send on behalf of a domain. If your API uses an unlisted IP, the recipient may reject the message with a 554 error.
How can I fix a 554 error in my API?
Update SPF records if you control the domain. Otherwise, use a verified SMTP relay service. Test IP trust before full deployment.
Why does my API send fail with 554 but not my email client?
Email clients use predefined, trusted IPs or authenticated sessions. APIs sending from unverified or new IPs may trigger stricter rejection rules.
Is 554 a temporary or permanent error?
554 is a permanent error. The server will not accept the message again unless the policy change is resolved.
How accurate is Emaillistchecker.io for catching 554 errors?
Emaillistchecker.io’s real-time API returns accurate SMTP-level responses, including 554 codes and rejection reasons, with 98.9% accuracy on verification.
What’s the difference between a 554 error and a bounce?
554 is a server-level SMTP rejection—no bounce is generated. It happens during message submission, not after delivery, making it invisible in bounce logs.
Can 554 errors harm my sender reputation?
Repeated 554 errors from unverified IPs without proper recovery can degrade sender reputation by signaling unreliable or untrusted sourcing.
Should I worry if only some domains return 554 errors?
Yes—this indicates a mismatch between your sending IP and the domain’s access policy. It may require IP warming, whitelisting, or relay use.
Do IP-based rejections mean my email is spam?
Not necessarily. A 554 error means the domain blocks unapproved senders. It’s a policy issue, not an indication that your content is spam.