Skip to main content

History

Keep track of all your API requests with Quetzly's history feature. The history system automatically logs every request you make, providing valuable insights into your testing patterns and making it easy to repeat or modify previous tests.

Accessing Request History​

  1. Click the history History icon in the left sidebar
  2. The history panel will display a table of all your previous requests
  3. View requests in chronological order (newest first)

History Table Overview​

The history table contains the following columns:

Open Open Action​

  • Icon: Click to load the request back into the API testing interface
  • Functionality: Restores all request parameters, headers, and body content
  • Use case: Quickly repeat or modify a previous request

URL​

  • Display: Shows the full endpoint URL that was tested

Method​

  • Values: GET, POST, PUT, PATCH, DELETE
  • Quick identification: Easily see what type of request was made

Date​

  • Format: MM/DD/YYYY format
  • Chronological order (newest first)
  • Navigation: Quickly find requests from specific time periods

Time​

  • Format: HH:MM AM/PM format
  • Precision: Shows exact time the request was initiated
  • Sequencing: Helps identify request order within the same day

Status​

  • HTTP codes: 200, 404, 500, etc.
  • Quick assessment: Instantly see which requests succeeded or failed

Using History Effectively​

Rerunning Previous Requests​

  1. Locate the request you want to repeat in the history table
  2. Click the 🔗 open icon in the first column
  3. The request will be loaded into the API interface with:
    • Original URL
    • HTTP method
    • Service type
    • All query parameters
    • Headers
    • Request body (if applicable)
  4. Modify any parameters as needed
  5. Click Send to execute the updated request

Analyzing Request Patterns​

Success Rate Analysis​

  • Scan the Status column for patterns
  • Identify frequently failing endpoints
  • Track improvements after API fixes
  • Monitor service stability over time

Performance Tracking​

  • Review response times for similar requests
  • Compare performance across different time periods
  • Identify performance bottlenecks
  • Track API optimization results

Usage Patterns​

  • See which endpoints you test most frequently
  • Identify common parameter combinations
  • Track your testing workflow evolution
  • Plan future testing strategies

History Management​

Automatic Logging​

Quetzly automatically logs:

  • ✅ All sent requests: Every request you execute
  • ✅ Request details: Complete parameter and header information
  • ✅ Response metadata: Status codes, timing, and size information
  • ✅ Timestamps: Precise timing for each request
  • ✅ Service types: What type of service was tested

Data Persistence​

  • Local storage: History is stored locally on your machine
  • Session persistence: History survives application restarts
  • Privacy: No request data is sent to external servers
  • Security: Sensitive data remains on your local system

History Limitations​

  • Storage capacity: History has a practical limit based on available disk space
  • Performance: Very large histories may affect application performance

Troubleshooting History Issues​

History Not Appearing​

  1. Verify you've made requests in the current session
  2. Check that requests completed (weren't cancelled)
  3. Restart the application if history seems stuck

Missing Request Details​

  1. Ensure the request completed successfully
  2. Check for any error messages during the request
  3. Verify the application has write permissions for local storage

Performance Issues with Large History​

  1. Consider the number of stored requests
  2. Restart the application to refresh memory usage
  3. Report performance issues for future optimization

Best Practices​

Effective History Usage​

Regular Review​

  • Weekly review: Check your testing patterns
  • Identify trends: See which tests you repeat often
  • Optimize workflows: Streamline frequently used requests
  • Document insights: Note important findings

Request Organization​

  • Use descriptive URLs: Make history entries meaningful
  • Test systematically: Follow consistent testing patterns
  • Group related tests: Test similar functionality together
  • Document complex tests: Add comments about test purposes

Workflow Integration​

  • History → Sets: Convert frequent requests to saved sets
  • History → Documentation: Use history to document API behavior
  • History → Monitoring: Set up monitoring for critical endpoints
  • History → Troubleshooting: Reference history during debugging

Development Workflows​

API Development​

  1. Test new endpoints: Send initial requests to new APIs
  2. Review history: Analyze what worked and what didn't
  3. Refine requests: Use history to improve request parameters
  4. Document findings: Note successful patterns for future use

Debugging Issues​

  1. Check recent history: Review recent requests for patterns
  2. Compare working vs. failing: Identify what changed
  3. Test variations: Use history as a baseline for new tests
  4. Track resolution: Monitor if fixes resolve historical issues

Quality Assurance​

  1. Regression testing: Repeat historical tests after changes
  2. Stability monitoring: Track error rates over time
  3. Documentation: Use history to document test coverage

Integration with Other Features​

History to Sets​

  • Save frequent requests: Convert commonly used requests to Sets after adding them to the map viewer.
  • Build test suites: Create collections from successful history items
  • Share workflows: Export Sets based on proven history patterns

History to Monitoring​

  • Monitor critical endpoints: Set up monitoring for important APIs
  • Use proven parameters: Base monitoring on successful historical requests
  • Track uptime: Monitor endpoints that were previously working

History to Documentation​

  • Example requests: Use history to create API documentation examples
  • Testing guides: Document successful testing patterns
  • Troubleshooting: Reference common issues found in history

What's Next?​

Now that you understand request history:

  • Learn about Sets to organize and save your most important requests
  • Explore Monitoring to continuously track your critical endpoints
  • Return to Send Requests to continue testing with history insights

Ready to organize your requests? Continue to Sets to learn about saving and managing request collections.