Recommendations

A recommendation is one pending savings opportunity LevelFour found in your cloud accounts. Each one carries the affected service, the estimated monthly and annual savings, and the actions available on it: accept, reject, execute.

Pagination has the defaults, the page-size cap, and the auto-paginating iterators the examples below rely on.

Methods

Get savings by provider

Returns a summary of potential savings grouped by cloud provider (AWS, GCP, Azure, K8s).

summary = client.recommendations.get_savings_by_provider()

Get potential savings

Returns a potential savings summary grouped by provider.

potential = client.recommendations.get_potential_savings()

Get overview

Returns overview metrics across all providers: total spend, available savings, pending savings, and saved-to-date.

overview = client.recommendations.get_overview()

List recommendations

Returns a paginated list of every recommendation.

page = client.recommendations.list(
    page=1,
    page_size=50,
    sort_by="monthly_savings",
    sort_order="desc",
)

for rec in page:
    print(f"{rec.service}: ${rec.monthly_savings}/mo")

Parameters

Get recommendation

Returns the full detail for one recommendation.

detail = client.recommendations.get("rec_123")

Get provider overview

Returns the same metrics as Get overview, scoped to a single provider: total spend, available savings, pending savings, and saved-to-date. Use it for a per-provider dashboard header.

overview = client.recommendations.get_provider_overview("aws")

List by provider

Returns a paginated per-provider recommendations list, filtered by service, environment, account, tag, and display status. Each row includes monthly and annual savings, current spend, and a savings percentage.

page = client.recommendations.list_by_provider(
    "aws",
    page=1,
    page_size=20,
    service=["EC2", "RDS"],
    environment=["production"],
    display_status=["available"],
    sort_by="monthly_savings",
    sort_order="desc",
)

for rec in page:
    print(f"{rec.service}: ${rec.monthly_savings}/mo")

Parameters

Filtering and sorting has recipes built on these parameters: the "RDS delete candidates" pattern, top-N-by-savings ranking, and CSV export.

List in-progress

Returns every recommendation currently in processing status.

processing = client.recommendations.list_in_progress()

Acting on a recommendation

These calls change one recommendation, or read who did what to it. Accepting or rejecting one happens in the dashboard, with l4 recommendations, or through the MCP server. Choosing resources, adding rejection feedback, requesting execution and reading the approval queue take a read-write key. The activity timeline and the Automated Savings check work with any key. The examples show the Go SDK and plain HTTP; SDK Overview lists which languages carry each namespace.

Choose the resources

Limits a recommendation to the resources you keep. Any resource you leave out is removed from it, and the savings figure follows. The list must be a non-empty subset of the resources the recommendation carries.

_, err := client.Recommendations.UpdateResourceSelection(ctx, "REC-1234",
    &levelfour.ResourceSelectionRequest{
        SelectedResources: []string{"vol-0abc1234def567890", "vol-0def5678abc123456"},
    },
)

Say why it was rejected

Adds a reason to a recommendation that is already rejected. reason is one of operational, strategy, not_applicable or other, and explanation is optional free text.

_, err := client.Recommendations.AddRejectionFeedback(ctx, "REC-1234",
    &levelfour.RejectionFeedbackRequest{
        Reason:      "not_applicable",
        Explanation: levelfour.String("This volume backs a disaster recovery test."),
    },
)

Read the activity timeline

Returns the recommendation's events in order: who viewed it and every decision taken on it.

activity, err := client.Recommendations.GetRecommendationActivity(ctx, "REC-1234")

Request execution

Puts an accepted recommendation in front of an admin to release. It moves to pending_approval until an admin approves it in the dashboard. implementation_method picks how the change is delivered:

approval, err := client.Recommendations.RequestExecution(ctx, "REC-1234",
    &levelfour.RequestExecutionBody{
        ImplementationMethod: levelfour.String("iac"),
    },
)

A pull request needs a repository to land in. Repository binding chooses it, and Automated Savings needs a grant first.

List what is waiting for approval

Returns every recommendation a member has submitted for execution that still needs an admin's release.

waiting, err := client.Recommendations.ListPendingApprovals(ctx)

Check Automated Savings access

Returns whether the access Automated Savings needs is in place for this recommendation's account, and the link that sets it up when it is not.

access, err := client.Recommendations.GetAutomatedSavings(ctx, "REC-1234")

Automated Savings covers the access itself.

RecommendationItem

Returned in paginated list responses.

Find high-value AWS recommendations

from levelfour import LevelFour

client = LevelFour()

for rec in client.recommendations.list_by_provider(
    "aws",
    page_size=20,
    sort_by="monthly_savings",
    sort_order="desc",
    display_status=["available"],
):
    if rec.monthly_savings > 100:
        print(f"{rec.recommendation_id}: ${rec.monthly_savings}/mo")

Next

• Savings is the realized side: what was accepted, implemented and measured
• Providers is the providers namespace: provider-scoped recommendations, realized savings, costs and the filter values you can pass
• Pagination has the iterators, the defaults and the page-size cap
• Error handling has the codes these methods raise