Skip to main content

Support Resources

Documentation

Comprehensive guides and API reference

Console

Manage API keys and monitor usage

Platform

Web interface for document processing

Status Page

Check service status and incidents

Contact Support

Email Support

General Support

hello@trypulse.ai
  • Technical questions
  • Integration help
  • Bug reports
  • Feature requests

Founders Direct

founders@trypulse.ai
  • Strategic partnerships
  • Enterprise inquiries
  • Product feedback
  • Special requests

Common Issues

Problem: Getting AUTH_002 Invalid API key errorSolutions:
  1. Verify your API key in the Console
  2. Check you’re using the correct environment (production vs test)
  3. Ensure the x-api-key header is properly formatted
  4. Regenerate your API key if needed
# Correct header format
curl -H "x-api-key: YOUR_API_KEY" https://api.runpulse.com/extract
Problem: FILE_001 Invalid file typeSolutions:
  1. Check supported formats: PDF, JPG/JPEG, PNG, DOCX, PPTX, XLSX, HTML
  2. Verify file extension matches content
  3. Ensure file isn’t corrupted
Problem: FILE_002 File too largeSolutions:
  1. Contact support for large files
  2. Consider using async processing
  3. Split very large documents if needed
Problem: Job timing out or failingSolutions:
  1. Use smaller page ranges for complex documents
  2. Check job status regularly
  3. Implement proper error handling
# Robust job polling
while status == 'processing':
    time.sleep(5)
    status = check_job_status(job_id)
Problem: Missing or incorrect data in schema extractionSolutions:
  1. Use descriptive field names matching document terminology
  2. Provide schema prompts for context
  3. Start with simple schemas and add complexity
  4. Make optional fields nullable
schema = {
    "invoice_number": "string",
    "optional_field": "string|null"  # Nullable field
}
Problem: Getting rate limited or BILLING_001 errorsSolutions:
  1. Check current usage in Console
  2. Implement client-side rate limiting
  3. Use caching to avoid reprocessing
  4. Upgrade plan for higher limits

Best Practices

Before Contacting Support

1

Check Documentation

Review relevant documentation sections for your issue
2

Verify Error Details

Note the exact error code and message
3

Test with Simple Case

Try a basic example to isolate the issue
4

Gather Information

Collect request/response details, file samples, and code snippets

What to Include in Support Requests

## Support Request Template

**Issue Description**: 
[Clear description of the problem]

**Expected Behavior**: 
[What should happen]

**Actual Behavior**: 
[What actually happens]

**Error Details**:
- Error Code: [e.g., FILE_001]
- Error Message: [Full error message]
- Timestamp: [When it occurred]

**Environment**:
- API Endpoint: [e.g., /extract]
- File Type: [e.g., PDF]
- File Size: [e.g., 5MB]
- Programming Language: [e.g., Python 3.9]

**Code Sample**:
```python
# Minimal code to reproduce
Additional Context: [Any other relevant information]

## Developer Resources

### Code Examples

<CardGroup cols={2}>
  <Card title="Python Client" icon="python" href="/quickstart#step-5-production-ready-client">
    Production-ready Python implementation
  </Card>
  <Card title="Error Handling" icon="shield" href="/advanced/error-handling">
    Comprehensive error handling guide
  </Card>
  <Card title="Schema Examples" icon="code" href="/api-reference/structured-output-guidelines#schema-examples">
    Real-world schema patterns
  </Card>
  <Card title="Large Documents" icon="file-lines" href="/api-reference/large-documents">
    Best practices for big files
  </Card>
</CardGroup>

### Integration Guides

Coming soon:
- Node.js/TypeScript SDK
- Java Client Library
- .NET Integration Guide
- Ruby Gem
- Go Package

## Community

### Stay Updated

- **Status Page**: Monitor [status.runpulse.com](https://status.runpulse.com)
- **LinkedIn**: Follow us on [LinkedIn](https://www.linkedin.com/company/pulse-ai-corp/)
- **Twitter/X**: Follow [@Pulse__AI](https://x.com/Pulse__AI)

### Feature Requests

We actively consider feature requests from our users. When submitting a request:

1. **Check existing features** - Review docs to ensure it doesn't exist
2. **Describe use case** - Explain the problem you're solving
3. **Provide examples** - Show how you'd use the feature
4. **Email details** - Send to hello@trypulse.ai

## Enterprise Support

### Premium Support Benefits

<CardGroup cols={2}>
  <Card title="Dedicated Slack Channel" icon="slack">
    Direct access to engineering team
  </Card>
  <Card title="Priority Queue" icon="bolt">
    Fast-track processing for urgent requests
  </Card>
  <Card title="Custom Solutions" icon="wand-magic-sparkles">
    Tailored features for your use case
  </Card>
  <Card title="Training Sessions" icon="graduation-cap">
    Onboarding and best practices training
  </Card>
</CardGroup>

### Support Plans

**Standard Plan**:
- Email support
- Business hours response
- Access to documentation and resources

**Pro Plan**:
- Priority email support
- Dedicated Slack channel
- Custom solutions available
- Direct access to engineering team


## Troubleshooting Tools

### API Health Check

```python
def check_api_health():
    """Verify API connectivity and authentication."""
    
    try:
        response = requests.get(
            "https://api.runpulse.com/health",
            headers={"x-api-key": API_KEY},
            timeout=5
        )
        
        if response.status_code == 200:
            print("✅ API is healthy")
            print(f"✅ API key is valid")
            return True
        else:
            print(f"❌ API returned status {response.status_code}")
            return False
            
    except requests.exceptions.RequestException as e:
        print(f"❌ Connection failed: {e}")
        return False

# Run health check
check_api_health()

Debug Mode

Enable detailed logging for troubleshooting:
import logging

# Configure debug logging
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

# Log all requests/responses
def debug_extract(file_path):
    logging.debug(f"Extracting from: {file_path}")
    
    try:
        result = client.extract(file_url=file_url)
        logging.debug(f"Success: {len(result)} characters extracted")
        return result
    except Exception as e:
        logging.error(f"Extraction failed: {e}")
        raise

FAQ

  1. Sign up at console.runpulse.com/
  2. Generate an API key
  3. Follow the Quickstart Guide
  4. Start with simple extractions before adding complexity
/extract supports both synchronous and asynchronous modes:
  • Sync (default): Best for documents under 50 pages. Returns the result directly.
  • Async (async: true): Returns a job_id for polling via GET /job/{jobId}. Recommended for large documents.
  • The deprecated /extract_async endpoint still works but redirects to /extract with async: true.
See Async Processing for full details.
Accuracy depends on:
  • Document quality (resolution, clarity)
  • Content type (typed vs handwritten)
  • Schema complexity
Typical accuracy: 95-99% for high-quality documents
Yes! Pulse API supports 100+ languages including:
  • European languages (Spanish, French, German, etc.)
  • Asian languages (Chinese, Japanese, Korean, etc.)
  • RTL languages (Arabic, Hebrew)
  • And many more
Yes, we take security seriously:
  • ISO 27001 certified
  • SOC 2 Type II certified
  • GDPR compliant
  • HIPAA compliant
  • Data encrypted in transit and at rest
  • Automatic deletion after 48 hours
  • No data used for training
For more details, visit our security page.