Modal Team plan: how do I enable rollbacks and the static IP proxy, and does it include $100/month free credits?

Quick Answer: On the Modal Team plan, rollbacks and the static IP proxy are account-level features that Modal can enable for your organization. The plan itself does not automatically include $100/month in free credits; instead, usage is billed according to the pricing on modal.com, with credits coming from separate programs (like startups or academic credits) if you’re approved.

Why This Matters

If you’re running production AI workloads—LLM inference endpoints, batch evals across hundreds of GPUs, or MCP servers handling spiky traffic—you need two things: safe deploys and predictable networking. Rollbacks let you instantly revert a bad deploy without re-plumbing infrastructure, and the static IP proxy gives you a stable egress IP for talking to third-party APIs with IP allowlists. Understanding what’s included in the Modal Team plan (and how credits actually work) helps you design systems you can trust under real load.

Key Benefits:

Safer deploys with rollbacks: Quickly revert to a known-good app version if a deployment introduces regressions, latency spikes, or bad configuration.
Stable outbound networking via static IP: Use a fixed egress IP to integrate with vendors that require IP allowlists, firewalls, or strict compliance controls.
Clear cost expectations: Know that Team plan usage is pay-as-you-go, and that credits (when you have them) come from specific credit programs rather than being bundled by default.

Core Concepts & Key Points

Concept	Definition	Why it's important
Team plan	A paid Modal plan for organizations that need multi-user controls, higher limits, and production-ready features.	Gives your team a shared, governed environment for running training, inference, and batch workloads at scale.
Rollbacks	Mechanism to revert a deployed Modal app or endpoint to a previous version that was already running in production.	Reduces risk from deploys: if a change breaks latency or functionality, you can quickly go back to a stable version.
Static IP proxy	A Modal-managed proxy that routes outbound traffic from your containers through a fixed IP address.	Lets you whitelist a single IP with external vendors and meet network security or compliance requirements.

How It Works (Step-by-Step)

At a high level, you’ll (1) get on the Team plan, (2) work with Modal to turn on rollbacks and the static IP proxy, and (3) wire those primitives into your code-defined infrastructure.

1. Get on the Modal Team plan

Create or use an existing Modal account.
Sign up at modal.com and create your workspace.
Upgrade to the Team plan.
From the dashboard, go to Billing or Plans and select the Team plan. You’ll need to:
- Add your organization details.
- Add a payment method (required even if you expect to use credits from a separate program).
- Confirm the plan and limits.
Invite your team.
Use Team controls to invite collaborators, align permissions, and keep production apps under a shared organization rather than personal accounts.

Note: Pricing and exact plan structure can evolve. Always verify the current Team plan details on https://modal.com/pricing.

2. Enabling rollbacks on the Team plan

Rollbacks are an operational safety net on top of Modal’s code-first deploy flow (modal deploy). The exact UI/CLI surface may evolve, but the enablement pattern is:

Contact Modal to enable rollbacks.
- Reach out via your Modal account channel (support, sales, or your Modal contact).
- Specify that you’re on the Team plan and want deployment rollbacks enabled.
- This is typically an account-level configuration, not a per-app toggle.

Deploy apps in a rollback-friendly way.
Use modal deploy with a stable app name so Modal can track versions. For example:

modal deploy my_app.py

In my_app.py:

import modal

app = modal.App("my-production-llm")

@app.cls()
class LLMServer:
    @modal.enter()
    def load_model(self):
        # Load weights once per container
        ...

    @modal.method()
    def generate(self, prompt: str) -> str:
        ...

Each modal deploy my_app.py becomes a new version of my-production-llm that can be rolled back.

Use the rollback surface when needed.
Once enabled, you’ll typically have either:
- A UI-based rollback in the Modal apps dashboard (select the prior version, press “Rollback” or “Promote”), or
- A CLI/API-based rollback that targets a previous deployment.
Operationally, the flow looks like:
```
# Deploy a new version
modal deploy my_app.py

# If you detect a problem (e.g., latency jump, 5xx spikes),
# use the dashboard or CLI to rollback to version N-1.
```
Because Modal endpoints are defined in code (@modal.fastapi_endpoint, @modal.web_server, @modal.asgi_app), the rollback is effectively a controlled switch of the active version, not a re-creation of the infrastructure.

3. Enabling and using the static IP proxy

The static IP proxy is about egress control: Modal containers will still autoscale across a multi-cloud capacity pool, but outbound traffic to the internet will appear from a fixed IP.

Request static IP proxy enablement.
- As with rollbacks, this is an account-level feature.
- Contact Modal and ask for static IP proxy on your Team plan workspace.
- You’ll typically get documentation containing:
  - The static IP address (or range) you should whitelist.
  - How to route traffic through the proxy (environment variables or code changes).
Configure your external vendor.
- Give your vendor the static IP from Modal.
- Ask them to allowlist this IP for their API or firewall.
- This is common for:
  - Financial/healthcare APIs
  - Internal corporate APIs behind a firewall
  - Compliance-bound SaaS integrations

Route traffic from Modal through the proxy. Implementation details vary, but often look like:

import os
import modal
import requests

image = (
    modal.Image.debian_slim()
    .pip_install("requests")
)

app = modal.App("static-ip-client")

@app.function(image=image)
def call_vendor_api():
    session = requests.Session()

    # Example if Modal provides an HTTPS proxy endpoint:
    proxy_url = os.environ["MODAL_STATIC_IP_PROXY"]
    session.proxies = {
        "http": proxy_url,
        "https": proxy_url,
    }

    resp = session.get("https://api.vendor.com/secure-endpoint")
    resp.raise_for_status()
    return resp.json()

Modal handles gVisor-based isolation and scheduling across clouds.
The static IP proxy gives you network observability and predictability without sacrificing autoscaling.

Test and monitor.
- Run the function locally via modal run to validate behavior:
```
modal run static_ip_client.py::call_vendor_api
```
- Use the Modal dashboard for logs and metrics:
  - Check for connection errors (misconfigured proxy or allowlist).
  - Watch latency; if the vendor is in a far region, factor that into your timeout budgets.

4. How credits interact with the Team plan

Modal has separate credit programs (e.g., for startups and academics) that can grant you $500–$25k in free credits depending on eligibility. This is documented in the “Modal for Startups” and “Modal for Academics” materials, where you’ll see language like:

“$500–$25k credits available”
“Unlock thousands of free GPU credits to supercharge your startup.”

Key points:

Team plan ≠ automatic $100/month credits.
- The Team plan itself does not guarantee a $100/month free credit allocation.
- Usage on the Team plan is billed according to the pricing in your region and hardware choice (CPU, A10G, A100, H100, etc.).
Credits come from separate programs.
- If you apply and are accepted into a program (e.g., startup credits), you’ll receive a credit balance that:
  - Can be used across Modal products: Inference, Sandboxes, Training, Notebooks, Batch, Core Platform.
  - Will show up in your account so you can see remaining credits and burn rate.
- Those credits can offset Team plan usage until they’re consumed or expire.
Payment method is still required.
- Even with credits, Modal still requires a payment method on file for:
  - Overages once credits are exhausted.
  - Ensuring continuity for production workloads.
- This is reflected in the FAQ language: “Why do you require a payment method?”
Expiration and visibility.
- Credits come with:
  - A validity window (e.g., 3–12 months, depending on the program).
  - Visibility in your account dashboard to track usage.
- If credits expire, they’re generally not automatically reinstated; you’d need to talk to Modal if you think there’s an issue.

If you specifically need $100/month in recurring credits, that’s not the default Team plan behavior. You’ll want to:

Apply for the relevant credit program.
Confirm the exact amount, duration, and scope of credits with Modal.

Common Mistakes to Avoid

Assuming rollbacks are automatic.
Rollbacks require Modal to enable that capability for your Team plan. Don’t assume you can revert just because you’ve deployed multiple times—get confirmation that rollbacks are turned on and understand how they’re exposed in your account.
Treating the static IP as “just another endpoint.”
If your code doesn’t actually route traffic through the Modal-provided proxy, your egress IP will not be the static one your vendor allowlisted. Make sure your HTTP client (e.g., requests, httpx) or system-level proxy config is wired correctly and tested.

Real-World Example

Imagine you’re serving a proprietary RAG-based LLM for financial analysis. You have:

A FastAPI-based inference endpoint wrapped with @modal.fastapi_endpoint for synchronous requests.
A batch eval pipeline using .map() to fan out prompts across A100 GPUs.
An external trading API that requires IP allowlisting for all inbound calls.

On the Modal Team plan you:

Define your infra in Python:

import modal
from fastapi import FastAPI

app = modal.App("finance-llm")
fastapi_app = FastAPI()

@app.cls()
class LLMServer:
    @modal.enter()
    def load(self):
        # Load model weights and vector index
        ...

    @modal.method()
    def infer(self, query: str):
        ...

@modal.fastapi_endpoint()
def fastapi_entry():
    @fastapi_app.post("/query")
    async def query_endpoint(payload: dict):
        result = await LLMServer().infer.remote(payload["query"])
        return {"result": result}

    return fastapi_app

Ask Modal to:
- Enable rollbacks so each modal deploy finance_llm.py can be reversed.
- Enable the static IP proxy and provide you the IP for your trading API vendor.
Configure your vendor to:
- Allowlist the Modal static IP.
- Reject any other IPs.

When you deploy a new LLM version with changed prompts or a bigger model, you monitor latency and error rates. If a regression hits production, you trigger a rollback on the Modal app to the previous version—no DNS changes, no new infrastructure. Your trading API integration keeps working because outbound requests still originate from the same static IP.

Pro Tip: Pair rollbacks with explicit versioning in your Modal code. Tag major behavior changes (e.g., new model weights or prompt structure) in both your git history and your modal.App names or metadata. That way, when you roll back, you know exactly which model and configuration you’re reverting to, not just “the previous build.”

Summary

On the Modal Team plan, rollbacks and the static IP proxy are production features that Modal can enable for your organization so you can ship faster without blowing up your risk profile. Rollbacks give you an instant escape hatch for bad deploys; the static IP proxy keeps your outbound networking compatible with IP-allowlisted vendors. The Team plan itself does not automatically include $100/month in free credits—credits come from separate programs (like Modal for Startups or Modal for Academics), and you’ll still need a payment method on file to cover real usage once credits are gone.

Next Step

Get Started