Support

Get help with StreetVerify API integration and troubleshooting

We’re here to help you succeed with StreetVerify. This page provides resources and contact information for getting the assistance you need.

Getting Help

1. Documentation

Start with our comprehensive documentation:

2. Dashboard Resources

Access helpful resources in your dashboard:

  • API Logs - View recent API requests and responses
  • Usage Analytics - Monitor your API usage patterns
  • API Keys - Manage your authentication credentials
  • Code Examples - Copy ready-to-use code snippets

Contact Support

Email Support

General Support: support@streetverify.com

  • Response time: Within 48 hours maximum (based on urgency)
  • Available 24/7 - We’re always here to help

Reporting Issues

When reporting an issue, please include:

Subject: [Issue Type] Brief Description

Account Email: your-email@example.com
API Key (last 4 digits): ...abcd
Endpoint: /api/v1/verify-address
Request ID: req_abc123def456

Issue Description:
[Detailed description of the problem]

Steps to Reproduce:
1. [First step]
2. [Second step]
3. [Expected vs actual result]

Code Sample:
[Include relevant code snippet]

Error Response:
[Include full error response]

Common Issues

Authentication Errors

Invalid API Key

{
  "error": "Invalid API key",
  "code": "INVALID_API_KEY"
}

Solution: Verify your API key in the dashboard and ensure it’s correctly included in the Authorization header.

Rate Limiting

Rate Limit Exceeded

{
  "error": "Rate limit exceeded",
  "code": "RATE_LIMIT_EXCEEDED",
  "details": {
    "retry_after": 45
  }
}

Solution: Implement exponential backoff and retry after the specified time.

Address Verification Issues

Invalid Address Format

{
  "error": "Missing required parameter: address",
  "code": "MISSING_PARAMETER"
}

Solution: Ensure you’re sending the address parameter correctly encoded.

Address Not Found

{
  "verified_address": "Unable to verify address",
  "status": "invalid"
}

Solution: Check the address spelling or try the autocomplete endpoint for suggestions.

Debugging Tools

1. API Request Logger

Enable detailed logging in your integration:

class DebugClient extends StreetVerifyClient {
  async request(endpoint, options) {
    console.log('🔵 API Request:', {
      endpoint,
      method: options.method || 'GET',
      headers: this.maskSensitive(options.headers),
      params: options.params
    });
    
    try {
      const response = await super.request(endpoint, options);
      console.log('🟢 API Response:', {
        status: response.status,
        data: response.data
      });
      return response;
    } catch (error) {
      console.error('🔴 API Error:', {
        message: error.message,
        response: error.response?.data
      });
      throw error;
    }
  }
  
  maskSensitive(headers) {
    const masked = { ...headers };
    if (masked.Authorization) {
      masked.Authorization = masked.Authorization.substring(0, 20) + '...';
    }
    return masked;
  }
}

2. Request ID Tracking

Track requests for support inquiries:

// Include request ID in logs
const response = await api.verifyAddress(address);
console.log(`Request ID: ${response.headers['x-request-id']}`);

3. Health Check Endpoint

Monitor API availability:

curl https://core.streetverify.com/health

Response:

{
  "status": "healthy",
  "version": "1.0.0",
  "timestamp": "2025-01-18T10:30:00Z"
}

Service Status

Current Status

Check the API health endpoint for real-time status:

  • Endpoint: https://core.streetverify.com/health
  • Dashboard: View status in your account dashboard

Status Indicators

  • 🟢 Operational - All systems functioning normally
  • 🟡 Degraded Performance - Slower response times
  • 🟠 Partial Outage - Some features unavailable
  • 🔴 Major Outage - Service unavailable

Best Practices for Reliability

Error Handling

Implement robust error handling:

  • Check the success field in all responses
  • Handle different error codes appropriately
  • Implement retry logic with exponential backoff
  • Log errors for debugging

Performance Optimization

Optimize your integration:

  • Cache results when appropriate
  • Use autocomplete to reduce verification calls
  • Monitor your usage patterns
  • Implement request queuing for high volume

Integration Examples

Basic Error Handling

async function verifyAddressWithRetry(address, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await api.verifyAddress(address);
      
      if (!response.success) {
        console.error('Verification failed:', response.error);
        return null;
      }
      
      return response.data;
    } catch (error) {
      if (error.code === 'RATE_LIMIT_EXCEEDED' && i < maxRetries - 1) {
        const waitTime = error.details?.retry_after || 60;
        console.log(`Rate limited. Waiting ${waitTime} seconds...`);
        await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
        continue;
      }
      
      if (i === maxRetries - 1) {
        throw error;
      }
    }
  }
}

Response Validation

def validate_response(response):
    """Validate API response structure"""
    if not isinstance(response, dict):
        raise ValueError("Invalid response format")
    
    if 'success' not in response:
        raise ValueError("Missing success field")
    
    if not response['success'] and 'error' not in response:
        raise ValueError("Error response missing error field")
    
    if response['success'] and 'data' not in response:
        raise ValueError("Success response missing data field")
    
    return response

Frequently Asked Questions

API Keys

Q: How many API keys can I create? A: You can create multiple API keys for different environments or applications.

Q: Can I regenerate an API key? A: No, but you can revoke the old key and create a new one.

Q: Are API keys environment-specific? A: No, API keys work in all environments. Use different keys for production and development.

Rate Limits

Q: What are the default rate limits? A: 100 requests per minute per API key. Some endpoints have stricter limits.

Q: Can I increase my rate limits? A: Contact support to discuss your needs and potential solutions.

Q: How are rate limits calculated? A: Rate limits use a sliding window algorithm and are applied per API key.

Billing

Q: How is usage calculated? A: You’re charged $0.01 per successful API request. Failed requests are not charged.

Q: How do I add credits? A: StreetVerify uses a prepaid credit system with crypto payments. Send USDT on the Ethereum network to add funds (minimum $50).

Q: Can I set usage alerts? A: Yes, configure usage alerts in your dashboard settings.

Feedback

We value your feedback! Help us improve StreetVerify:

Report Issues

If you encounter bugs or issues:

  1. Document the problem with reproduction steps
  2. Include error messages and request IDs
  3. Email support@streetverify.com with details

Feature Requests

Have ideas for new features?

  • Email your suggestions to support@streetverify.com
  • Include use cases and expected benefits
  • We review all requests and prioritize based on user needs

Additional Resources

API Versioning

  • Current version: v1
  • Version information included in API responses
  • No breaking changes without advance notice

Security

For security-related questions:

  • Email: support@streetverify.com
  • Include “SECURITY” in the subject line
  • We take security seriously and respond promptly

Support Availability

24/7 Support

  • Our support team is available around the clock
  • Response times based on issue urgency
  • Critical issues prioritized for immediate attention

Thank you for choosing StreetVerify! We’re committed to providing reliable geocoding and address verification services for your applications.