Implementing the Model-View-Controller (MVC) pattern along with SOLID principles on older monolithic code that only uses an API can be a challenging task, but it can greatly improve the maintainability and reduce technical debt. Here are some steps to follow:

1. Identify the Business Logic: Start by identifying the business logic in the codebase. This includes the rules, processes, and algorithms that govern the behavior of the application.
2. Define the Model: The Model represents the data and the state of the application. It should encapsulate the data structures, relationships, and validation rules required by the business logic. Ensure that the Model is designed following the SOLID principles of Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.
3. Define the API: The API acts as the View in this scenario, presenting the data to the client. It should be responsible for formatting the data, validating requests, and sending responses.
4. Define the Controller: The Controller acts as an intermediary between the Model and the API. It should handle user input, update the Model, and send data to the API. Ensure that the Controller follows the SOLID principles of Single Responsibility and Dependency Inversion.
5. Refactor the Code: Refactor the business logic code to implement the Model-Controller-API pattern. This may involve creating new classes for the Model, API, and Controller, and moving logic into these classes. Ensure that the code is refactored in a way that follows the SOLID principles.
6. Test the Changes: Test the changes thoroughly to ensure that the business logic is functioning correctly and that the separation of concerns is effective.
7. Document Changes: Document the changes made to the codebase and update the code documentation accordingly. This will help to ensure that the code remains maintainable and that other developers can understand the changes.

By following these steps, you can effectively implement the Model-View-Controller pattern along with SOLID principles on older monolithic code that only uses an API. This can significantly improve the maintainability of the code and reduce the risk of introducing technical debt.

It’s important to note that this process can be time-consuming and requires careful planning, testing, and documentation. It’s also important to consider the trade-offs between the benefits of refactoring and the potential costs in terms of time and resources. Nevertheless, the end result will be a more scalable, maintainable, and robust codebase that is easier to extend and modify in the future.