API Testing Automation

API Testing Automation

API Testing Automation refers to the practice of using software tools and scripts to validate Application Programming Interfaces (APIs) automatically, ensuring they function correctly, reliably, and securely. APIs act as the backbone of modern applications, enabling communication between different systems, services, and components. As applications become more distributed—especially with microservices architectures—automating API testing has become essential for maintaining quality and accelerating development cycles.

At its core, API testing automation focuses on verifying endpoints by sending requests (such as GET, POST, PUT, DELETE) and evaluating responses based on expected outcomes. These validations include checking status codes, response times, data accuracy, schema compliance, and error handling. Automated API tests can be executed without a user interface, making them faster and more stable compared to UI-based testing.

One of the key benefits of API test automation is early defect detection. Since APIs can be tested independently of the front end, issues can be identified during the development phase, reducing the cost and complexity of fixing bugs later. Additionally, automated tests improve regression coverage, ensuring that new changes do not break existing functionality. This is particularly valuable in continuous integration and continuous delivery (CI/CD) pipelines, where frequent code updates require consistent validation.

Common tools used for API testing automation include Postman (https://www.postman.com/), REST Assured (https://rest-assured.io/), SoapUI (https://www.soapui.org/), and Karate DSL (https://karatelabs.github.io/karate/). These tools support scripting, test case management, and integration with CI/CD platforms such as Jenkins or GitHub Actions. They also allow testers to create reusable test suites and data-driven tests, which enhance scalability and maintainability.

Best practices for API testing automation include designing clear test cases based on API specifications (such as OpenAPI/Swagger), maintaining modular and reusable test scripts, and incorporating both positive and negative test scenarios. It is also important to validate security aspects like authentication, authorization, and data protection. Mocking and service virtualization can be used to simulate dependencies, enabling testing even when some services are unavailable.

Another important aspect is performance testing, where automated tools are used to measure how APIs behave under load. Tools like JMeter (https://jmeter.apache.org/) can simulate multiple users and help identify bottlenecks. Logging and reporting mechanisms should also be integrated to provide insights into test results and facilitate debugging.

In conclusion, API Testing Automation is a critical component of modern software quality assurance. It enhances efficiency, reliability, and scalability while supporting agile and DevOps practices. By adopting the right tools, frameworks, and best practices, organizations can ensure robust API performance and deliver high-quality software systems consistently.

#API Testing Automation in India

What is API Testing Automation?

API Testing Automation is the process of using specialized tools and scripts to automatically test the functionality, reliability, performance, and security of Application Programming Interfaces (APIs). APIs are intermediaries that allow software applications, services, and systems to communicate with each other. Unlike traditional user interface (UI) testing, API testing focuses directly on the backend logic, ensuring that requests sent to an API return the expected responses under various conditions.

Automating API testing provides several advantages over manual testing. First, it enables faster and more consistent testing, as automated scripts can be executed repeatedly with minimal human intervention. This is particularly important in modern software development environments, where frequent code updates and continuous integration/continuous delivery (CI/CD) pipelines demand rapid and reliable validation. Automated tests help catch defects early in the development lifecycle, reducing the cost and effort required to fix issues later.

API testing automation typically involves sending requests such as GET, POST, PUT, or DELETE to endpoints and validating responses based on status codes, response data, headers, and performance metrics. Automation frameworks and tools, such as Postman (https://www.postman.com/), REST Assured (https://rest-assured.io/), SoapUI (https://www.soapui.org/), and Karate DSL (https://karatelabs.github.io/karate/), provide the ability to design, execute, and manage automated API tests. These tools also support integration with CI/CD platforms like Jenkins, GitHub Actions, and GitLab, enabling tests to run automatically with every build or deployment.

Best practices for API testing automation include creating modular, reusable test scripts, covering both positive and negative scenarios, and validating security aspects such as authentication and authorization. Data-driven testing, where input data is varied systematically, helps ensure robustness across different use cases. Additionally, performance testing tools like Apache JMeter (https://jmeter.apache.org/) can be used to simulate high loads and identify bottlenecks in API performance.

In summary, API Testing Automation is essential for ensuring the correctness, reliability, and efficiency of APIs in modern software systems. It supports agile development practices, improves regression coverage, accelerates delivery cycles, and helps organizations maintain high-quality applications. By leveraging the right tools and following industry best practices, teams can ensure APIs function as intended, even as systems scale and evolve.

Here’s a reference for further reading:

• Postman API Testing Overview: https://www.postman.com/api-testing/
• REST Assured Documentation: https://rest-assured.io/
• SoapUI Official Site: https://www.soapui.org/

#API Testing Automation in Patna

Who is API Testing Automation required?

API Testing Automation is required by organizations and teams that develop, maintain, or rely on software systems with APIs to ensure quality, reliability, and efficiency in their applications. Its necessity arises due to the increasing complexity of modern software architectures, particularly in microservices, cloud-based systems, and distributed applications where multiple services interact through APIs. The following stakeholders and scenarios illustrate who needs API Testing Automation:

1. Software Development Teams – Developers require automated API testing to validate their code quickly during development. Automation allows them to catch errors early, verify new functionality, and ensure that code changes do not break existing API behavior. Continuous testing helps maintain consistent quality in agile development cycles.
2. Quality Assurance (QA) Teams – QA professionals use automated API testing to ensure that APIs meet functional, performance, and security requirements. Automation reduces repetitive manual testing, increases coverage across different endpoints, and allows QA teams to focus on exploratory and edge-case testing rather than routine validation.
3. DevOps and CI/CD Pipelines – Organizations implementing continuous integration and continuous delivery rely on automated API testing to maintain stability during frequent deployments. Automated tests run as part of the build pipeline, preventing faulty code from progressing to production and ensuring rapid release cycles without compromising quality.
4. Product Owners and Project Managers – Automation provides faster feedback on API functionality and performance, helping project stakeholders make informed decisions about release readiness. This is especially important for products with external API integrations, where reliability directly impacts end-user experience and business operations.
5. Organizations Using Third-Party Integrations – Companies that depend on external APIs for payment gateways, messaging, logistics, or analytics require automated testing to monitor and validate the behavior of these integrations. Automation ensures consistent interaction with external services even when updates occur outside the organization’s control.
6. Security Teams – Automated API testing is also crucial for testing authentication, authorization, and data security. Security teams can implement automated tests to detect vulnerabilities, ensure compliance with standards, and prevent unauthorized access or data breaches.

In essence, any team or organization that relies on APIs for communication between software components, internal services, or third-party systems can benefit from API Testing Automation. By automating these tests, businesses can reduce manual effort, accelerate delivery, improve reliability, and maintain high-quality software systems.

For further reading:

• Postman: https://www.postman.com/api-testing/
• REST Assured Documentation: https://rest-assured.io/
• SoapUI Official Site: https://www.soapui.org/

#API Testing Automation in Maharashtra

When is API Testing Automation required?

API Testing Automation is required in scenarios where manual testing becomes inefficient, error-prone, or unable to provide consistent validation for complex or frequently changing systems. Specifically, automation becomes necessary under the following conditions:

1. Frequent Releases and Continuous Integration/Delivery (CI/CD) – In agile and DevOps environments, applications are updated and deployed frequently. Automated API tests are essential to validate endpoints continuously with every build, ensuring that new changes do not break existing functionality. Tools like Jenkins (https://www.jenkins.io/) or GitHub Actions (https://github.com/features/actions) integrate automated API tests into pipelines to provide instant feedback.
2. Complex or Large-Scale Applications – Applications with multiple microservices, third-party integrations, or distributed systems often involve numerous API endpoints. Testing each endpoint manually is impractical. Automation ensures coverage across all endpoints efficiently, allowing developers and QA teams to validate functionality, error handling, and performance consistently.
3. Regression Testing – Whenever software undergoes updates or enhancements, regression testing ensures that existing functionality remains intact. Automated API tests are ideal for regression, as they can be executed repeatedly without additional manual effort, maintaining high test coverage while reducing time and cost.
4. Performance and Load Testing – When APIs are expected to handle high traffic or simultaneous requests, automated testing can simulate multiple users and measure response times, throughput, and scalability. Tools like Apache JMeter (https://jmeter.apache.org/) allow organizations to detect bottlenecks and optimize performance before production deployment.
5. Security and Compliance Verification – Automated API testing is required to validate security features such as authentication, authorization, encryption, and data validation. Regular automated tests can help detect vulnerabilities early, ensuring compliance with industry regulations and preventing potential breaches.
6. Data-Driven and Repetitive Scenarios – APIs often need to be tested with multiple input data sets to verify correctness under different conditions. Automation allows running these repetitive, data-driven tests efficiently, which would be time-consuming and prone to human error if done manually.
7. Third-Party API Integration – If an application depends on external APIs for critical functionality (e.g., payment gateways, messaging services, analytics), automated testing ensures that these integrations work reliably even when the third-party service updates or changes.

In summary, API Testing Automation is required whenever speed, consistency, scalability, and reliability are critical for software development and delivery. It is particularly necessary in agile, DevOps, and microservices-driven environments to maintain high quality, detect defects early, and reduce manual effort.

References:

• Postman API Testing: https://www.postman.com/api-testing/
• REST Assured: https://rest-assured.io/
• SoapUI: https://www.soapui.org/

#API Testing Automation in Ahemdabad

Where is API Testing Automation required?

API Testing Automation is required in environments where software systems rely on APIs for communication, integration, or functionality. It is particularly critical in areas where reliability, performance, and security of APIs directly impact application behavior, user experience, or business operations. The key domains where API Testing Automation is required include:

1. Microservices Architecture – In applications built with microservices, each service exposes multiple APIs to interact with other services. Automated API testing ensures that individual services work correctly and interact seamlessly without manual verification, which becomes difficult as the number of services grows.
2. Continuous Integration and Continuous Delivery (CI/CD) Pipelines – In agile and DevOps workflows, code changes are frequently integrated and deployed. Automated API testing is essential in CI/CD pipelines to verify that each deployment maintains API functionality and does not introduce regressions. Tools like Jenkins (https://www.jenkins.io/) and GitHub Actions (https://github.com/features/actions) allow API tests to run automatically at every stage.
3. Enterprise Applications – Large-scale enterprise systems often rely on multiple internal and external APIs for functions such as authentication, payment processing, messaging, or reporting. Automation ensures that all APIs are consistently validated, reducing the risk of downtime or incorrect data processing.
4. Third-Party API Integrations – Businesses that depend on external services—like payment gateways, social media APIs, or cloud services—require automated testing to validate these integrations reliably. Automation ensures that API changes by third parties do not break the application.
5. Performance-Critical Systems – Applications where response time and throughput are crucial, such as e-commerce platforms, financial systems, or streaming services, require automated API testing for load, stress, and performance evaluation. Tools like Apache JMeter (https://jmeter.apache.org/) can simulate thousands of requests to validate scalability.
6. Security-Sensitive Applications – Automated API tests are required in applications handling sensitive data (personal information, financial transactions, or healthcare records). Security testing, including authentication, authorization, and data validation, ensures compliance with industry standards like GDPR, HIPAA, or PCI DSS.
7. Regression Testing Environments – In any application where frequent updates or feature additions occur, automated API tests are required to quickly and reliably validate existing functionality, reducing manual effort and ensuring consistent behavior across releases.
8. Test Environments and Staging Systems – Before deploying to production, automated API testing is performed in staging or pre-production environments to verify that APIs function correctly under conditions that closely simulate real-world usage.

In essence, API Testing Automation is required wherever APIs are critical to application functionality, integrations, or performance. It is particularly vital in modern software ecosystems, including microservices, cloud platforms, and CI/CD workflows, to maintain quality, reliability, and scalability.

References:

• Postman API Testing Overview: https://www.postman.com/api-testing/
• REST Assured Documentation: https://rest-assured.io/
• SoapUI Official Site: https://www.soapui.org/

#API Testing Automation in Hyderabad

How is API Testing Automation required?

API Testing Automation is required through a structured approach that integrates testing into the software development lifecycle, ensuring APIs are reliable, functional, secure, and performant. It is not just about writing scripts—it involves selecting the right tools, defining test strategies, and embedding automated tests in development pipelines. The following outlines how API Testing Automation is implemented and required in practice:

1. Defining API Test Objectives and Scope – The first step is identifying what needs to be tested: endpoints, request/response validation, authentication, error handling, or performance. Automation is particularly required for repetitive or high-volume tests that would be time-consuming and error-prone if done manually.
2. Selecting Appropriate Automation Tools – Tools like Postman (https://www.postman.com/), REST Assured (https://rest-assured.io/), SoapUI (https://www.soapui.org/), and Karate DSL (https://karatelabs.github.io/karate/) provide frameworks to write, execute, and manage automated API tests. These tools support scripting, reusable test cases, and integration with CI/CD platforms, making automation scalable and maintainable.
3. Creating Automated Test Cases – Test cases are developed based on API specifications (like OpenAPI/Swagger). Automation is required to cover both positive scenarios (valid inputs producing expected outputs) and negative scenarios (invalid inputs producing appropriate errors), ensuring comprehensive validation. Data-driven testing is often implemented to validate APIs with multiple input variations efficiently.
4. Integration with CI/CD Pipelines – Automation becomes essential when APIs are frequently updated. Automated tests are integrated into CI/CD workflows using Jenkins, GitHub Actions, or GitLab pipelines. This ensures that tests run automatically on every code commit, pull request, or deployment, allowing immediate detection of defects and preventing faulty code from reaching production.
5. Performance and Load Testing – For high-traffic applications, automated API tests simulate multiple users and evaluate performance metrics like response time, throughput, and scalability. Tools like Apache JMeter (https://jmeter.apache.org/) allow continuous monitoring of performance under different load conditions.
6. Security and Compliance Verification – Automation is required to routinely validate authentication, authorization, encryption, and data validation. It ensures APIs comply with security standards (e.g., GDPR, HIPAA) and prevents vulnerabilities that could compromise sensitive data.
7. Reporting and Monitoring – Automated API tests generate logs and reports, providing insights into API behavior and facilitating debugging. Continuous monitoring ensures that any regression or failure is detected early.

In summary, API Testing Automation is required to accelerate development, reduce manual effort, improve test coverage, and ensure high-quality software delivery. It is implemented by defining test scope, selecting tools, creating reusable scripts, integrating with CI/CD, performing performance and security tests, and continuously monitoring results.

References:

• Postman API Testing: https://www.postman.com/api-testing/
• REST Assured Documentation: https://rest-assured.io/
• SoapUI Official Site: https://www.soapui.org/
• Apache JMeter: https://jmeter.apache.org/

#API Testing Automation in Banglore

Case Study of API Testing Automation

Background:
A global leader in cybersecurity needed to automate the testing of hundreds of REST API endpoints that integrated with multiple internal and third‑party systems. Manual testing was time‑intensive, inconsistent across environments, and unable to provide fast feedback necessary for frequent releases. Automation was required to support regression testing, schema validation, and integration checks across complex workflows.

Challenges:

• Over 100 interdependent APIs with diverse input and output scenarios.
• Need for robust regression and smoke testing suites that could be executed repeatedly.
• Integration of automated tests with CI/CD pipelines to enable continuous validation on every build.
• Maintaining reusable and maintainable scripts across the test suite.

Solution:
The testing team designed and developed a scalable API automation framework using Rest Assured (Java) integrated with Selenium for common utilities. Key components of the solution included:

• Modular and reusable test scripts that could run against multiple environments and data sets.
• Integration with CI/CD pipeline tools (e.g., Jenkins) so that automated tests executed on every build, enabling early defect detection.
• Custom utilities for handling authentication, dynamic data, and complex business logic within tests.
• Detailed reporting via tools such as Extent Reports or Allure to provide actionable insights for stakeholders.

Implementation Highlights:

• Test suites were created for functional validation, boundary testing, error response handling, and performance checks.
• Automation scripts were maintained in a version‑controlled repository to support collaboration and maintainability.
• Data‑driven testing was implemented to run the same test logic with multiple input combinations, increasing test coverage significantly.

Outcomes:
The automated API testing initiative delivered measurable operational improvements:

• 75% reduction in overall test cycle time, enabling faster verification with each build.
• Significant reduction in regression overhead, allowing QA teams to focus on high‑impact exploratory testing.
• Framework reusability reduced maintenance cost by approximately 50% compared to bespoke scripts for each test scenario.
• Faster stakeholder decision‑making with clear automation reports and reduced manual intervention during regression phases.

---

Additional Industry Example: E‑Commerce API Automation

In another documented case, an e‑commerce company engaged third‑party QA services to build an API test suite for its customer account management system. Using SoapUI, engineers developed over 2,000 automated API calls with more than 2,500 assertions to verify endpoint behavior against functional specifications. Load testing scenarios were deployed in a cloud environment to evaluate performance under stress. This approach not only exposed defects early but also reduced the overall testing timeline and helped meet throughput and response‑time goals before release.

---

These case studies illustrate how API Testing Automation can be architected and scaled for complex systems across industries. They highlight best practices for modular framework design, CI/CD integration, and measurable operational benefits in real‑world contexts.

#API Testing Automation in Singapore

White Paper of API Testing Automation

Executive Summary

API Testing Automation is the systematic use of software tools and automated scripts to validate Application Programming Interfaces (APIs). As APIs have become foundational to modern software ecosystems—enabling communication between microservices, web applications, mobile clients, and third‑party services—automated testing has emerged as a critical component of quality assurance. This white paper explores the need, methodologies, best practices, tool ecosystems, and business impacts of API Testing Automation.

Introduction

APIs serve as the connective tissue in distributed systems, facilitating data exchange and functional operations across components. Manual testing of APIs is time‑consuming, error‑prone, and inefficient, particularly in agile and DevOps environments where rapid deployment cycles prevail. API Testing Automation addresses these challenges by enabling rapid, repeatable, and reliable validation of API functionality, performance, security, and compliance.

Why API Testing Automation Matters

Several trends have driven the adoption of API Testing Automation:

• Distributed System Architectures: Microservices and service‑oriented architectures increase the number of API endpoints that require regular validation.
• CI/CD and DevOps Practices: Continuous integration and delivery depend on automated tests to provide instant feedback and maintain quality gates.
• Mobile and Web Ecosystems: APIs support diverse clients whose functionality cannot be reliably validated through UI testing alone.
• Third‑Party Dependencies: Many systems depend on external APIs (e.g., payment gateways, authentication services). Automation ensures that integrations remain functional even as dependencies evolve.

According to industry sources, automated API testing reduces defect leakage and accelerates release cycles while improving test coverage significantly compared to manual methods.

Core Components of API Testing Automation

API Testing Automation requires several key components:

1. API Specification and Documentation

A clear specification (such as OpenAPI/Swagger) is essential to define request/response schemas, parameters, headers, and expected behaviors. Tools like Swagger Editor and Redoc can assist developers and testers.
Reference: OpenAPI Initiative — https://www.openapis.org/

2. Automated Test Script Development

Scripts are written to automate test execution. These typically include:

• Functional Tests: Verify that API endpoints behave as expected.
• Schema Validation: Confirm that responses conform to defined JSON or XML schemas.
• Error Handling Tests: Validate negative scenarios and boundary conditions.

Popular frameworks for scripting include:

• Postman — capable of automated test collections and environment management. (https://www.postman.com/)
• REST Assured — a Java‑based library suited for REST API validation. (https://rest-assured.io/)
• SoapUI — supports both REST and SOAP protocols. (https://www.soapui.org/)
• Karate DSL — integrates API automation with BDD style testing. (https://karatelabs.github.io/karate/)

3. Integration with CI/CD Pipelines

Automated API tests must be integrated into the build and deployment workflow. Tools like Jenkins (https://www.jenkins.io/) and GitHub Actions (https://github.com/features/actions) enable tests to run at triggered events (code commits, pull requests, nightly builds), ensuring continuous validation.

4. Performance and Load Testing

Automated performance testing simulates load conditions to measure throughput, latency, and scalability constraints. Apache JMeter is frequently used for this purpose.
Reference: Apache JMeter — https://jmeter.apache.org/

5. Reporting and Analytics

Automation frameworks should generate reports that provide actionable insights, such as pass/fail rates, response time trends, and defect traces. Tools such as Allure and Extent Reports are commonly used for visualization.

Best Practices for API Testing Automation

1. Data‑Driven Testing: Separate test logic from test data to maximize coverage with diverse datasets.
2. Modular Framework Architecture: Create reusable components to reduce maintenance and improve scalability.
3. Comprehensive Security Checks: Automate validation of authentication, authorization, and data protection.
4. Service Virtualization: Simulate unavailable dependencies to enable early testing.
5. Version Control: Store scripts, test scenarios, and resources in source control systems.

Business Benefits

API Testing Automation yields measurable advantages:

1. Reduced Time to Market: Faster release cycles with automated validation checks.
2. Improved Quality and Reliability: Early detection of defects minimizes production failures.
3. Cost Efficiency: Automated tests reduce manual effort and long‑term testing expenses.
4. Scalability: Automation enables testing of large API suites that would be impossible manually.

Conclusion

API Testing Automation is a strategic requirement for modern software development. By integrating automated API tests into development lifecycles, organizations achieve greater reliability, higher test coverage, and efficient quality assurance processes. Combining the right tools, methodologies, and practices ensures that APIs meet functional, performance, and security expectations across deployment environments.

External References

• Postman API Testing Overview: https://www.postman.com/api-testing/
• REST Assured Documentation: https://rest-assured.io/
• SoapUI Official Site: https://www.soapui.org/
• OpenAPI Initiative: https://www.openapis.org/
• Apache JMeter: https://jmeter.apache.org/

#API Testing Automation in Pune

Industry Application of API Testing Automation

1. Banking and Financial Services

Banks, fintech platforms, and payment processors rely on APIs to handle transactions, authentication, account management, and third-party integrations. Automated API testing ensures:

• Secure handling of sensitive financial data.
• Compliance with regulatory standards like PCI DSS and GDPR.
• Accuracy of transaction processing and account balance updates.
• Reliability of mobile banking, payment gateways, and inter-bank API connections.

Example Tools: REST Assured, Postman, SoapUI.
Reference: https://rest-assured.io/

---

2. E-Commerce and Retail

E-commerce platforms integrate multiple APIs for inventory management, payment processing, shipping, and customer engagement. Automation is applied to:

• Validate product catalog APIs for consistency across channels.
• Test shopping cart, checkout, and order tracking endpoints.
• Ensure third-party integrations (payment gateways, logistics) work reliably.
• Perform load testing to handle high traffic during peak shopping seasons.

Example Tools: Postman, Karate DSL, Apache JMeter.
Reference: https://www.postman.com/api-testing/

---

3. Healthcare and Life Sciences

Healthcare systems rely on APIs for patient records, lab results, appointment scheduling, and telemedicine platforms. Automation ensures:

• Compliance with HIPAA and other healthcare regulations.
• Accurate exchange of patient data between EMR/EHR systems.
• Secure access control and data encryption.
• Performance validation of APIs during peak hospital operations.

Example Tools: SoapUI, Postman, REST Assured.
Reference: https://www.soapui.org/

---

4. Telecommunications

Telecom companies utilize APIs for billing, call management, messaging, and customer support services. Automated API testing is applied to:

• Validate integration between core network services and mobile applications.
• Monitor call routing, SMS, and data usage APIs.
• Test subscription and payment systems in real time.
• Ensure scalability for millions of concurrent users.

Example Tools: Postman, Apache JMeter, REST Assured.
Reference: https://jmeter.apache.org/

---

5. Travel, Transportation, and Logistics

Airlines, ride-sharing platforms, and logistics companies depend on APIs for booking, tracking, and payment services. Automation supports:

• Validation of booking and scheduling APIs.
• Integration testing with third-party partners (hotels, payment gateways).
• Performance testing under high-volume requests during peak travel seasons.
• Real-time tracking and notification APIs.

Example Tools: Postman, SoapUI, REST Assured.
Reference: https://www.postman.com/api-testing/

---

6. SaaS and Technology Platforms

Software-as-a-Service applications expose APIs to allow integrations, reporting, analytics, and automation for clients. Automation ensures:

• Functional correctness and reliability of APIs across multiple client environments.
• Regression testing after software updates or new feature deployment.
• Security and compliance verification for multi-tenant architectures.
• Load and performance testing for scaling to global users.

Example Tools: Karate DSL, REST Assured, Postman.
Reference: https://karatelabs.github.io/karate/

---

Conclusion:
API Testing Automation is essential across industries where digital services, integrations, and performance are critical. From banking and healthcare to e-commerce and SaaS platforms, automated API testing enables faster release cycles, improved reliability, and compliance, while reducing manual effort and risk. Properly implementing automation frameworks ensures consistent, high-quality API delivery across diverse industry scenarios.

#API Testing Automation in Mumbai

Ask FAQs

Source: Postman

Disclaimer:
The information provided in this document is for educational and informational purposes only. While every effort has been made to ensure accuracy, the author and affiliated sources make no warranties or representations regarding the completeness, reliability, or suitability of the content. Use of the information is at your own risk.