ReadyAPI Reviews

My experience with Katalon Studio is that we used Katalon for one of our projects, and then I started leveraging Katalon by integrating it with AI tools, AP tools, and aptly tools. Aptly tool is an add-on which we can integrate with the existing Katalon. So we didn't have any licensed tool as such, but I integrated a tool to one of our case studies for our clients and made use of it. Predominantly, I used Katalon without using a license just to show our clients that we can use Katalon full-fledged for one of our automation scripts, which already existed for different tools. That is how I started with Katalon.

Beyond Katalon, I've also worked with other tools, including TestIM, which we used for automating mobile applications and APIs.

For payments, I worked predominantly in the ed-tech domain, enabling a student to select and enroll in courses. This required payment processing where we automated a dummy payment gateway using REST API. The entire enrollment process was seamless, ensuring smooth transitions from selecting courses to payment deductions.

For non-functional testing, I focus on performance and security. For performance and security tests, I used REST API, SoapUI, and JMeter. These tools help us conduct thorough testing across these dimensions.

I find ReadyAPI helpful especially in overcoming security issues, as we experienced slowness in the application after merging our JAR files. For instance, if a person wants to access a university database and encounters a timeout error, we learned through ReadyAPI that the issue was due to HTML protocol limits with the payload. We fine-tuned this process to display the expected data effectively.

I consider ReadyAPI a cost-effective solution because it covers three verticals without needing to purchase separate tools for security, performance, or functional testing. ReadyAPI is a versatile tool for creating multiple testing frameworks and validating various parameters seamlessly.

REST API is the tool I use to test all three types of articles, meaning I validate the APIs I send to my peers or clients for functional testing, and I also perform security testing to ensure the URL and data passed through multiple components adhere to policies and user privileges. This is done through functional security testing using the REST API tool, and for performance, I ensure that applications can be accessed simultaneously by multiple users without hindrance or slowness through thorough performance testing.

One issue I found with ReadyAPI is related to event listeners compared to JMeter or SoapUI. We created an in-house dashboard to display automation runs across projects, which required manual updating of event listeners for new project imports. This process could be improved for easier updates upon script changes.

My experience with SmartBear support was good and I was quite satisfied with their responsiveness and efficiency in addressing our needs.

I contacted SmartBear for support several years ago as a QA contact for my US client. SmartBear had an ALM tool that helped manage project documentation, including Jira-related specifications, test plans, and test cases. We reached out to integrate our test cases into the ALM.

Positive

There are other tools that may excel in specific aspects compared to ReadyAPI, but REST API serves our purpose well. Tools such as Postman help with API automation, but they aren't as efficient for comprehensive testing. SoapUI, JMeter, and LoadRunner are primarily focused on performance testing, but ReadyAPI remains the most cost-effective option, as it supports all types of testing without the need for multiple licenses.

I'm using Katalon Studio and TestIM. We need a license to use Katalon Studio, and the license enables multiple users on the same tool, allowing us to leverage full-fledged automation. There are key features that will be disabled if we're not using a licensed Katalon. The one I used did not require a license, but I automated one of the test cases without using the license through the Aptly tool available in the market. We did that for basic and critical features.

Katalon is the one I used full-fledged without needing a license as such, and it served our purpose. However, if there are multiple subordinates who want to use Katalon Studio and access the same automation script, then they probably need the license. In my case, I did not require a license but having one would allow leveraging additional features. For example, it can automatically create Jira bug reports when exceptions arise, and using licensed tools can help self-heal scripts if errors occur.

I have worked on multiple verticals, including functional testing, which doesn't require any automation. For functional testing, we did manual testing, including database validation using tools such as SQL Developer. We validated and wrote test cases, then executed them manually for our web-based, mobile-based, and desktop-based applications. In automation testing, there are two types: functional automation and non-functional automation.

To address the security issue found using REST API, we can tweak it by injecting queries that attempt to access an inbox directly. This showcases a critical issue that may arise when using Single Sign-On, allowing access to multiple applications using a single credential, as was the case with accessing both Confluence and Jira using an Atlassian account.

I primarily used CoPilot with ReadyAPI to accelerate groovy script creation, particularly when I needed to create multiple users with unique credentials. By utilizing CoPilot, I generated a script that facilitated the rapid implementation of different usernames and passwords, streamlining our productivity.

REST API is a smart tool compared to others I've used. While LoadRunner excels specifically in performance testing, ReadyAPI covers various reporting and validations seamlessly. Changes made in the tool seamlessly update to repositories without lagging or exceptions.

On a scale of 1-10, I rate ReadyAPI a 7.

My primary use case for ReadyAPI is for companies dealing more with backend services. ReadyAPI provides services for accessing these services, conducting testing, generating test data, and offers Docker containers for cloud integration. This capability makes it feasible to integrate ReadyAPI right out of the box into any cloud environment, including private and public cloud environments.

ReadyAPI enhances my workflows by allowing us to use Docker containers based on the ReadyAPI test runner. It helps extend our functional tests, even though we are not heavily using performance testing. It supports a wide range of protocols such as Kafka and GRPC, depending on the project. It also aids in faster feedback to developers, allowing them to implement developments in a sprint without the need for extensive testing afterwards, thus improving our time to market metrics.

In native teams and cloud environments, there is room for improvement. I'm considering the use of AWS and its Lambda functionalities prepared by the vendor. These are more so points from my wishlist and are not fundamental changes needed. Advanced functionalities could be improved.

ReadyAPI's performance testing capabilities can impact API scalability assessments, although we do not use performance testing for a running API. It's possible to extend our functional tests.

Currently, we don't extensively use the performance testing due to license costs. License prices can be a factor in considering which technologies to adopt.

I would rate ReadyAPI seven out of ten from my perspective. We use ReadyAPI for backend projects without UI interfaces, as it offers quality assurance.

I use ReadyAPI for API testing and functional testing. We have transitioned from using SoapUI to using ReadyAPI, and we utilize it for verifying request and response from the backend. We also use ReadyAPI to generate data based on responses, storing it in our internally-created database.

ReadyAPI is valuable for web service automation and allowing us to generate test cases and automate processes. We use it to verify request and response from the backend and to generate and store data in the database. The Groovy scripting feature is essential, although sparingly complex compared to other tools.

Based on my experience, ReadyAPI could improve by simplifying the process of scripting. The automation features require extensive Groovy scripting, which is cumbersome compared to JMeter's regular expression handling. Additionally, the sequence running and enabling/disabling API endpoints are not as precise and necessitate more scripting to achieve efficiently. This could be improved.

I have been working with ReadyAPI for about three to four years.

The stability of ReadyAPI is good. Once all configurations and preparations are done, it is very stable. However, one noticeable issue is its heaviness as a tool, making it slower to open compared to other tools like JMeter that are Java-based.

I rate ReadyAPI between five to six for scalability due to complexities associated with scripting.

Technical support from SmartBear is commendable. With a licensed version, they are very responsive, especially when dealing with offline license activation and deactivation during upgrades.

Positive

I previously used SoapUI and JMeter. We switched to ReadyAPI from SoapUI for more advanced functionality. However, we still use JMeter for performance testing due to its simplicity and cost-effectiveness in scripting.

The initial setup of ReadyAPI is simple and not overly complex. I was able to do it myself without needing any consultants or integrators.

The pricing of ReadyAPI is reasonable, considering its functionality compared to other tools in the market. However, I recommend open-source solutions for small-scale industries due to lower costs.

I rate ReadyAPI eight out of ten. For others considering ReadyAPI, I recommend based on their specific needs. It's more suitable for medium to large companies rather than small scale industries. The solution should be chosen based on the specific requirements of the organization.

Our use case for ReadyAPI is REST API Testing. We essentially test student data because we're working for a school domain that can have different ReadyAPI test cases.

We have the positive test scenario where we collect real-time data and they pass through ReadyAPI, then post different data types for students, such as the school students enrolled in, whether students are full-time or part-time, what courses the students took, etc. There are positive scenarios and negative scenarios that we try to create in the system, including some junk data, then we'll see how ReadyAPI will behave.

ReadyAPI being a tool, means that you can also feed it any junk data, and it's going to post that data, but what we'll be looking forward to is the HTTP code generated towards the end of the day, to see whether it's valid or not.

If there are irrelevant data, for example, there's an address field that can accept any characters, that should be fine, but if we have a name that we need to find and we provide some special characters, then ReadyAPI will give an error message similar to this "Hey, it looks like you're using special characters, so that won't work for me."

There are multiple edge cases, but it isn't about the tool. It's about the applications being used, and there may be some loose ends within the applications. Edge case scenarios could come up, such as the positive scenario and the X, Y, and Z scenario, and ReadyAPI helps us and makes it easy for us by allowing us to post the data. It lets us create multiple test cases, for example, if we have fifteen resources for a test case, we can tightly bundle those resources under one test case, then execute the test case, then ReadyAPI will run everything under that particular test case.

ReadyAPI solves different business problems, and I've seen that, particularly in the education sector where I worked. One is that because ReadyAPI is a licensed tool and it's deployed on-premises, you can host multiple data sets on it. You can host more than a million records on ReadyAPI, and it will still be able to run because it's deployed on an on-premise server. It essentially runs on the CPU, and you don't need to consider resource utilization as much, compared to other tools that depend on memory space, so those tools are unable to run more than fifteen thousand or twenty thousand data, while ReadyAPI is very helpful in that area. The tool is also more user-friendly than other tools.

One of the features of ReadyAPI that's worth mentioning is that it allows you to parameterize. I'm working with more than two hundred resources, so I don't have to go and make a small change at each point every time. I have the option to just parameterize in one place for the changes to reflect everywhere.

Another valuable feature of ReadyAPI is that it provides a customized environment. In my company, you work in different environments, such as QA, UAT, and LT, so the URLs for every environment are different. In ReadyAPI, you can customize your environment, set it up, then start working on it.

Another feature worth mentioning that's offered in ReadyAPI is automating your test value as the tool allows Groovy scripting. In your test case, you can use a Groovy script that says that in a particular test case, you have ten resources, but you just want to exhibit five and that you don't want to exhibit the remaining five. You can write a small Groovy script that lets you execute just five resources out of the ten resources.

I also like that ReadyAPI allows you to read the data from CFC and Excel. It also allows you to create or customize your data, but that only works at a certain point because every application has its specific data. ReadyAPI cannot generate every data, but when I'm posting and I want to generate a random name, such as a first name, I can do it in ReadyAPI.

The tool also has many different features which I find valuable, including Git integration.

What needs improvement in ReadyAPI is its load testing feature because there was a hiccup when my team performed some load testing on the tool. My team had meetings with the ReadyAPI team and tried to get that issue fixed, but it still hasn't improved. This is a shortcoming of the tool, especially when you compare it with HP LoadRunner.

I've been using ReadyAPI for the past five years.

ReadyAPI has pretty good stability because if there's a bug, the ReadyAPI team releases a new update every two weeks. I've never faced any issues in terms of stability. The tool has good performance because I didn't see any major hiccups from it. ReadyAPI performs as smoothly as possible, and it's quite reliable as a product.

ReadyAPI is a scalable tool. In terms of performance testing, you can scale it, but scaling it requires a different license. For example, the basic license allows up to one hundred users, while the advanced license allows up to five thousand users, but if you want to scale to more users, you have to purchase another license. ReadyAPI has different modules of license for performance testing, so you can scale it up based on the number of users you require.

The technical support team for ReadyAPI has been very prompt in replying to my concerns. Usually, when you send out the email in the morning, by the end of the day, the team will get back to you and when needed, will get on a call with you to discuss the issue. If your issue can be fixed online immediately, then support will fix it. If not, the team will schedule a call or meeting with you, and you just need to explain the situation, and within a day or two, you'll see that the issue has been fixed.

The initial deployment for ReadyAPI was pretty straightforward. The tool has a good setup if you have your own kit. You can just integrate ReadyAPI with the kit, and once that's done, the deployment is pretty smooth.

The deployment of ReadyAPI didn't take more than ten to fifteen minutes.

My team implemented ReadyAPI.

The ROI from ReadyAPI, particularly for functional testing, is pretty good. The tool is simple, convenient, and integrates with many other languages. You can also work on Python and Java when you use ReadyAPI, though I've not explored that field yet because it wasn't a requirement in my projects. The tool is worth your money because of the ROI.

If I remember correctly, ReadyAPI costs between $5,000 to $7,000 for five thousand virtual users running it at a given point in time. Other tools, for example, Apache JMeter, can run millions of users at a given time. ReadyAPI is a tool that requires you to pay more money if you want more users to run it for performance testing.

For functional testing, each ReadyAPI license costs $1,000, and you do get basic testing, and it's inclusive of one hundred users. In my company, if there's a need for more than one hundred users, my team uses Apache JMeter because it's futile to end up paying $5,000 or $6,000 annually just for performance testing, which can be done in Apache JMeter as well.

Given the circumstances, my team does performance testing only towards the end of the fiscal year when the regulatory testing of applications takes place. If I have to run ReadyAPI just for two days or just for ten or fifteen odd days, then it's not worth paying $5,000 for the license with the small number of users provided by ReadyAPI.

Apart from ReadyAPI, my company used Apache JMeter and HP LoadRunner which are licensed tools. The company only had to pay a one-time license fee for HP LoadRunner for a million users, and that wasn't the case with ReadyAPI.

ReadyAPI was just an extension of SoapUI which was essentially used for functional testing, but nowadays, ReadyAPI is in the market for performance testing. It's a platform that can do both functional and non-functional testing, but the non-functional testing feature still needs a lot of improvement, particularly cost-wise. For example, if I want fifteen thousand users on ReadyAPI, I don't want to be paying $10,000 annually for the license. The tool is getting better, but in terms of performance testing, it's still being worked on. Apart from that, I didn't see any other issues.

ReadyAPI is deployed on-premises. My company bought five licenses, and my team uses three licenses while the other team uses two licenses.

My company uses the latest version of ReadyAPI. Every time there's a new release, it's downloaded, then that new version is used within the company.

I belong to a team of five that deployed ReadyAPI, but two members took care of implementing the changes after it's been reviewed by peers because that's taken into consideration before going ahead and deploying the changes to the next environment.

As ReadyAPI is a paid tool, it doesn't require any maintenance from my company's end.

Five people work on ReadyAPI within my company.

My advice to anyone looking into implementing the tool is to go ahead and try and test it to see how ReadyAPI can help you with your project and application, but I'm sure it's worth a try. Essentially, the ReadyAPI team does offer a trial period as well, up to fourteen days, from what I remember. You can just reach out to customer care and see if you could get a trial for a month or so because that would give you hands-on experience with ReadyAPI. That can give you an ample amount of time to figure out how the software works for your application.

I would rate ReadyAPI as seven out of ten for now.

My company is a customer of ReadyAPI.

I use ReadyAPI for all things API testing – functional, migration, and security testing. It helps me automate tests, ensure reliability, and spot performance issues. The tool offers versatility, especially in virtualizing APIs and integrating with CI/CD.

The most valuable features of ReadyAPI are its robust functionality and collaboration capabilities. It excels in collaborating with tools like Jira, and its reporting capabilities are a game-changer for me. 

There is room for improvement in ReadyAPI, particularly in the user interface. I prefer working with multiple windows or tabs, like in SoapUI, rather than the current single-window setup. It becomes challenging to switch between tasks seamlessly.

I have been using ReadyAPI for almost two years.

My experience with ReadyAPI's stability has been less than ideal. The tool performs well for routine tasks but struggles when exploring new features. 

The solution is fairly scalable.

I have encountered numerous issues, and reaching out for support for resolution takes considerable time, sometimes more than a month. Considering the high cost of the license, it is frustrating not to receive the expected support. At times, I find myself turning to SoapUI tools because they provide quicker solutions.

I initially used SoapUI for its specialization, but the switch to ReadyAPI was driven by its broader range of features.

The initial setup of ReadyAPI can be challenging. The web pages lack comprehensive information, which makes tasks like configuring keys for a bucket difficult. Even with admin profiles, permission issues can arise during the transition from SoapUI to ReadyAPI. Additionally, dealing with XML configuration files can be problematic, and sometimes they get corrupted, requiring a fresh start with projects.

The cost of the license is quite high. The licensing cost for ReadyAPI, at least for the current license I have, covers both general and security testing.

I would recommend ReadyAPI for users who need a tool for daily API testing, especially for organizations with frequent API deliveries. While it can be challenging to manage, especially with daily testing requirements, it is essential for maintaining version control and handling various data scenarios. Additionally, ReadyAPI integrates well with tools like Jenkins for automation, making it a valuable choice in a continuous integration environment. Overall, I would rate ReadyAPI as a five out of ten.

Our company uses the solution's SaaS to provide API testing for customers. 

Our quality and automation engineers use the solution. Senior directors randomly open it to ensure that it is working fine. Everyone thinks the solution is convenient to use. 

Most scripts are developed by automation engineers and used by different groups of people who are only comfortable with manual testing. They run scripts but some have challenges with the solution's Groovy programming at first because they are completely new to programming. Other than that, running scripts and using the tool is quite simple. 

The solution offers a wide range of API testing capabilities. 

The built-in Smart Assertion capability allows us to validate API responses quite easily without additional data inputs. You can easily add a table with unlimited rows and columns to pass line input. In contrast, Parasoft SOAtest sometimes requires an Excel document as input. 

Reporting is more robust than other products because test reports can be exported in multiple ways such as JUnit, Excel, or Azure. The most surprising thing is the built-in Azure capabilities because Azure uses a different framework. Previously when we worked on Java or Selenium projects, we used Azure as a dependency and imported that utility. Now, we can complete these projects within the solution's built in functionality.

The integration with GitHup and HTML is very good. 

The backward capability ensures scripts developed in very old versions also run on new versions. 

The Property Transfer capability could be more user friendly because it is a bit difficult to understand. It works pretty well, but took multiple documentation reviews with some trial and error before getting it right. 

I have been using the solution for almost two years. 

The stability is good. 

In an effort to constantly improve the solution, updates are pushed every week or two. They might be based on feedback received from users. We do not update every time but rather wait for major updates or new features like the Smart Assertions rollout. 

The solution is scalable. 

I have not spoken with technical support directly.

A couple of new users couldn't install a license server properly so I reached out to support via email and they fixed it right away.

I use the ReadyAPI community to find solutions. In every scenario, issues have already been discussed. If a question is posted, someone responds quickly with the most viable solution. 

We previously used Parasoft SOAtest. 

The setup was straightforward and the transition was smooth. 

Migrating scripts from existing systems took some time but was healthy. We had dedicated SMEs who operated the other systems so there was a lot of dependency that was eliminated. 

The solution is an easy tool to learn. Once scripting and everything is completed, anybody with installation knowledge can run it. 

Two of our team members handled implementation. Ongoing maintenance is handled by our automation engineers. 

In the beginning, some effort went into deployment because we had a different tool and framework so migrating was a challenge.

With the solution, we run 1,500 to 2,000 scripts every month and that hardly takes 20 minutes. A manual effort would cost $60 per hour and take a week. 

The solution saves a lot of time and manual effort so there is an obvious cost savings. Now, one person develops scripts and anyone can run them. 

We have a floating license that is shared by multiple users. 

The solution is dynamically priced so you only pay for what you use. For example, I do API testing and service virtualization in the solution. If someone does not want service virtualization, they are not charged for it. 

Pricing based on use is a very good thing because products offer a wide range of capabilities but 60-70% of them rarely get used. For the solution, you simply add whatever you want to use and are billed accordingly. 

I rate pricing an eight out of ten. 

Before we migrated to the solution, we went through the official documentation and determined it was very convenient to use in comparison to Parasoft SOAtest. It offers a wide range of API testing capabilities that Parasoft didn't provide. 

The solution also includes its own programming language called Groovy that is similar but not exactly like Java. Groovy is unique to the solution and other SmartBear products like SoapUI. It is quite simple to learn and understand. 

We obtained a fourteen-day trial version of the solution and, over the course of ten days, determined it was more suitable for our needs so purchased a license. We chose it because of its ease of use, capabilities, and cost effectiveness. 

When we first switched to the solution, the Smart Assertion capability was not included but there were massive, built-in content assertions that handled our jobs. The addition of Smart Assertion in the latest release takes usability one step ahead and makes our work very simple.  

In my opinion, the only reason people aren't switching to the solution is because there is a lack of knowledge. The solution has its own programming language and that might be a red flag for some people because they find it difficult to change to something new. If you get your hands on the solution and spend time with it, then you will align toward it. If you are in the early stages of setup, you should definitely look at it. 

Try the solution before buying it. Download the free version and use it for 14 days. Try to move some of your scripts there, run them, and see the difference. It is a very good tool but you need to ensure it is a good match for your requirements. 

I rate the solution a nine out of ten. 

ReadyAPI is where I've created the test tools I've used. I use it for functional testing.

I've used it for testing my code, as in for the unit testing basically, and also the functional tests. We had to perform all types of unit tests. 

We could test all the scenarios of the code, all possible scenarios before it goes to QA. We used Excel files to import the data so that we could test the majority of the data.

The Excel sheet feature is good. It allows for data-driven testing, basically the testing where I can load an Excel file. This was the most useful since, if we had to create a test suite every time for new data, that would typically be a lot of work to fill in the data. When we did it in the Excel sheet, in each row, we could put the data in each and then just copy and paste and simply change whichever column we wanted to change. This helps us test a lot of data at one particular point in time.

The initial setup is easy.

The solution can scale. 

Many times, when I'm testing the code, and it is deployed at a particular server when using ReadyAPI, and I'm getting an error. However, it's actually not an error in the code. For example, sometimes, if I changed something in ReadyAPI, it would not quickly pick up the change. It used to give me the same error repeatedly, and when I closed the application completely and restarted it, it would pick up that change. There was a lag for me while using ReadyAPI.

I don't know as to how it works at the backend, how it picks up the changes, and what functionality or code they use at their end; however, I would want it to be more functional to take in the changes. If I've made a request and I change something in it, it should not lag. It should be able to recognize that this is a change and should be able to pick that change up so that it does not give me the same error over and over again.

The solution does not notify you that you are about to lose your license. They need to give you some small timeframe so you can finish what you are doing and restart without losing work.

I work as an integration developer, so for testing my code and my web services, in the beginning, I used SoapUI, and then I moved to ReadyAPI. I've used it for almost five to six years.

The solution is stable. I don't know if it's a business perspective or something since it was a little difficult for us only when we had to get the licenses, so we used to face problems when our organization bought only so many licenses.

I don't know if they could make licensing more flexible. Since it was difficult to obtain a license, that was a shortcoming with the solution. Sometimes it would time out if I left my system for some time and came back. The work I was doing, if the license is lost, meant I had to set it up all over again, put the license back, and then start testing again.

There have been some bugs occasionally.

The solution scales well.

There were codes and services that were very complex or lengthy, so we created test suites for one code, which made everything easier.

I'd use the tool, as well as the test team. We'd do all kinds of testing, and it could handle it all. 

Between 200 and 300 people are using the solution. Almost all of the developers would use it for testing. 

I haven't used technical support or know of anyone who has. 

I've also used SoapUI. I use SoapUI now. 

ReadyAPI has much more functionalities and is more scalable. Smaller organizations maybe with small budgets or less services, use SoapUI. When companies need more scalability and functionality, they use ReadyAPI.

The implementation process is very straightforward. You just install it from an installer, and you could go on and start working on it from there. It's not very messy, and it's not very lengthy. You could just simply install and start.

I'd rate the ease of implementation 4.5 or five out of five.

I was not involved with the licensing aspect of the solution. I'm not sure what the pricing is. However, it's my understanding that the solution isn't too flexible in terms of licensing, and people sometimes struggle with that aspect of the product. 

I'm a customer and end-user.

I'm using somewhere near the latest version of the solution. 

ReadyAPI it's pretty straightforward and offers many helpful features. Also, many things automatically get integrated into ReadyAPI. It's quite a useful tool.

I'd rate the solution nine out of ten.

We have a product, a financial application, that uses a lot of services to connect to our backend systems, so we use ReadyAPI to test those services. Primarily, we use it to build out or mimic the exact services that the development team uses. Second, we use it to build out scripts in Groovy to automate certain scenarios and verify without any manual intervention.

The feature that allows you to import an API collection or a project is valuable. It reduces a lot of manual effort to give the endpoint and the parameters, etc. If the development team gives me the collection, I can directly import it into  ReadyAPI and it maps the entire project so that I can start hitting the APIs directly.

There is a lot of room for improvement, mainly from the point of view of integrating ReadyAPI into the CI pipelines, and also the scripting aspect into Bitbucket. ReadyAPI is an extremely good and efficient standalone tool, but if you're collaborating on a project, it kind of becomes like a bottleneck. For use as a tool for group collaboration, there is some room for improvement.

I would like to see two new features. Number one is version control with Bitbucket or Git, where we can actually see the scripts and have meaningful pull requests. Right now, everything sits inside an XML file, so it's very hard to review the code that anybody writes. If I have a ReadyAPI project, I want to not only have it on my local machine, but also in a version control system like Git or Bitbucket. At this time I can put the project there, but it's very hard to decipher the files that ReadyAPI exposes. It would be nice for them to have it more like a .gui file where the formatting of the file and the readability of the code is easier for other individuals.

Second, is integration into a continuous integration pipeline, like a CI pipeline, where we can easily trigger, via Bamboo or Jenkins, and execute the scripts and maybe get the response of the results via an email or notification. Maybe it also needs integration into tools like Microsoft Teams or Slack, to get immediate feedback about the results of our execution. Those would be the new improvements I would like to see in their upcoming versions.

I have been using ReadyAPI for the past four and a half years.

I think ReadyAPI is very stable as a standalone tool. I haven't had much experience with using it with cloud or CI, but overall, my impressions are that it is a very solid and stable tool. There's no flakiness in it. As long as you have the right licenses and internet, it's pretty solid. It doesn't hang or crash. The time it takes to hit the API responses and process data is pretty much seamless.

I think there is a lot of improvement required from the scalability point of view. 

Anywhere between 20-50 people use the solution at the moment, but that can go up to around 100 users. 

One time I got help from the technical support team, and they were good. They were able to understand my issue and resolve it within a couple of days. 

As long as you have access to the right licenses, it's a very straightforward setup. 

I deployed the solution in-house and it was up and ready within a few hours. ReadyAPI already has documentation, so I made use of that to set up the project on my machine. Installation was pretty easy and straightforward since I had the right licenses and followed along with the documentation.

We have a team who handles the maintenance. We have at least three people on that team who work in DevOps, but their time is not required every single day. I would say minimal time and effort is needed for maintenance. It's mainly to check to see if a new version of ReadyAPI is out there, and see if it works with our internal company systems. Are there any restrictions? Are there any firewall rules that need to be opened or any IT support required? Maintenance is needed just to check those things. I've never heard anybody complaining or having any issues with it.

I don't have a quantification metric, but I would say there is a lot of return on investment. That's the reason we keep on renewing the licenses even though it's maybe slightly on the expensive side. It allows us to identify a lot of issues by just using the tool, and as long as we use the tool appropriately, there is a lot of value in it for us. 

I'm not familiar with the pricing specifics, but I would say it's somewhere in the middle. I don't think it's too expensive. I would give the pricing a three out of five. 

The thing with ReadyAPI is that you have to buy different licenses for different purposes. The license that we have is mainly for functional testing, but if you want to run security tests or scans, you need to purchase a separate license. If you want to run performance tests, you need a separate license. I am not aware of one single license available for all the features of ReadyAPI, but it would be nice for them to have one license for everything rather than having individual separate licenses.

We didn't switch from another tool, but the other solution or alternative that we use is called Postman. Postman doesn't entirely replace ReadyAPI because ReadyAPI has many other features that make it stand out on its own merit. It has options to perform load testing and security testing, not just functional API services testing.

At the moment, we are mainly focused on functional API services testing, so there are some teams who use Postman, but I think it's mainly due to convenience and the level of comfort that each engineer has with ReadyAPI. Many prefer to use ReadyAPI as compared to Postman.

I would say that it's a very strong tool by itself. I haven't seen any other tool that matches the capabilities from a standalone point of view. If your goal is, "Hey, I have a bunch of services I want to test and play around with and even automate some testing around on a standalone machine," ReadyAPI is very powerful and capable and has a lot of benefits. 

It saves a lot of time for future testing, so if I want to repeat a test over and over again every single day, it saves time. It has good source connections, such as a database or an Excel or adjacent file. It can take the source input in various formats, and it can give the output in various formats, like Excel, or it can also write it into a database. It has that integration available with other technologies.

I think it is trying to improve itself by having integrations into Bamboo, Jenkins and Jira, but it's bit late in the game there. I think there's still a lot of work to do on the CI.

I would rate this solution as a seven out of ten. 

We use the solution for performance testing tools.

I am satisfied with the product. Importing documentation is easy. It is also easy to import Postman collections and create an environment in the API. It is easy to work with the tool and get started with testing. The performance testing capabilities are very good. We can catch potential problems with the APIs. The tool has scaled up its performance testing and reporting. It provides comprehensive and detailed reports. We can see at which point the system starts to deteriorate under the load.

The vendor conducts webinars. They must do it more, though. The solution must update SmartBear Academy. The content on ReadyAPI in SmartBear Academy is outdated.

I have been using the solution for around eight months.

The product is stable.

The product is scalable.

The support team provides comprehensive support. The support persons are always willing to jump on a call to assist us.

Positive

We used Postman before. We switched to ReadyAPI because of its loop-testing features.

The initial setup is straightforward.

The pricing is very competitive. It has a good impact on our time-to-market metrics. We have the complete SmartBear environment. The single cost for all the services makes it easier.

ReadyAPI enables users to import Postman collections easily. The load testing capabilities, ability to integrate with Azure DevOps quicker, and ability to predefine SLA to test the suite based on the predefined SLAs are valuable. The tool enables us to find bugs and defects faster.

We have mostly tested REST APIs. We haven't tested SOAP-based APIs. I have more than 100 Microservices automated with ReadyAPI. They are integrated into CI/CD and are running on Azure DevOps on a daily basis. We get a comprehensive report on it. It is also faster to integrate and create a pipeline for ReadyAPI. We just have to point Azure DevOps to the XML file we generate when the project runs locally. It's quite fast. I will recommend the tool to others. Overall, I rate the product a ten out of ten.

Our web application is completely dependent on backend APIs. Instead of automating all the clients' use cases, we make sure that all the backend APIs are automated and are false-proof so that any issues can be tackled upfront. 

On the client side, we have a UI where a user will interact with the application. On that end, it's simply the API that is being called and is fished through the UI that is getting rendered. We capture all those APIs and connect them using ReadyAPI.

We use ReadyAPI to automate our APIs and make sure that all the individual APIs are automated with different possible positive cases and negative cases. Then, we use an end-to-end test where we used to have multiple APIs. In the past, we used to combine all the APIs for a scenario, whereby a particular API would get a value that we would pass to other APIs. In the final result, we have assertions, the Groovy script, which is in ReadyAPI.

For anyone who does not have experience with automation, ReadyAPI provides a sense of comfort, especially for testers who find it hard to go directly into coding. It is a good solution to start with.

ReadyAPI has a cool feature called Smart Assertion. This feature lets you add different values to your response which can be asserted, and you'll be able to modify that. It requires a click of a button and the assertion will get added. 

The assertion which is currently built into the tool would be more than enough in 95% of the scenarios. In less than 5% of the scenarios would you need to write a code to make sure something needs to be really asserted. 

ReadyAPI has been around for a while, it's stable, and it's from a strong brand, SmartBear.

The solution is not user-friendly. It is a difficult tool to use. ReadyAPI is slow, taking two to three minutes to start and launch. As your project gets bigger, the time to load takes even longer.

ReadyAPI is not lightweight, it is a heavy tool. There are lots of options within the solution, however, they are not upfront or user-friendly. 

The solution's UI has a clumsy setup. On the left side, you have a list of all the test sites, followed by the test cases and the test steps. On the right side, there are two levels of division. Shown at the top is everything and at the bottom, the values you are passing will be shown. The variables that are getting passed globally within the test suite level will hide somewhere. Even after using the tool for a while, you need to click on a specific button to know that the value is being passed. I would like a UI that shows everything that is important upfront to avoid unnecessary clicks.

If performance improved with the UI changes, I would prefer this solution, as it achieves everything other products and tools offer.

I have been using ReadyAPI for two years.

The solution is stable. I have not faced a situation where ReadyAPI was down. It is always running. It runs slow, but it is always running.

ReadyAPI is scalable. At one point in time, we had eight people working with the product. Each of us would add our test and add to our repository. We also added it to our nightly run, on the weekly and daily runs.

We had to connect with technical support at ReadyAPI one time. We could not get the Bitbucket repository to ReadyAPI. The installation was correct and successful, but we were not able to import the repository to ReadyAPI even after providing the GitHub key. We sent customer service an email and got a response with steps on how to resolve the issue. 

Most of our concerns are dealt with in the online community. SmartBear has been around for a while, so many issues are already answered online in the frequently asked questions section.

Overall, I would rate their customer service and support a four out of five.

Positive

Prior to using ReadyAPI we used Jira. The decision to switch was made at the leadership level.

The initial setup of ReadyAPI is not too tough. It is important to make sure that the executable file has all the correct options. 

After installing ReadyAPI, you need to point it to your repository, either GitHub or Bitbucket, where your code resides. Then it will take about two hours  to initialize and to get the test loaded.

If somebody really wants to use ReadyAPI to implement API automation, I would suggest different tools rather than ReadyAPI. 

If they have already chosen to implement ReadyAPI, I would recommend that they have a mentor and a proper training plan in place. Even someone who has experience working with API automation will not be able to start immediately and use the solution. My advice is to learn the tool perfectly because there is a good chance that they will miss some of the key features which will definitely ease their work. Once they know all the small tricks and tips, it's really an easy tool.

Overall, I would rate this product a six out of ten.