# What is Callables?

> Callables turns Python functions into web forms, schedules and run history that your whole team can use. What it is, and when to use it.

Source: https://callables.app/docs

Callables turns Python functions into tools your team can run. A developer adds `@deploy` to a function and pushes the repo to GitHub. Callables builds it and gives every function a web form generated from its type hints, with schedules, run history, secrets and per-function sharing. The people who run it never see code, a terminal or a traceback.

```python
from typing import Literal

from callables import deploy


@deploy(title="Refund an order", secrets=["STRIPE_KEY"])
def refund(
    order_id: str,
    reason: Literal["Damaged", "Late", "Other"],
    notify_customer: bool = True,
) -> str:
    """Refunds the order in Stripe and records why."""
    ...
    return f"Refunded {order_id}"
```

That function becomes a form with a text box, a dropdown and a checkbox. Its result shows as formatted text, and every run is saved with its inputs, logs and result.

## When to use Callables

Use it when you have Python code that other people need to run, or that needs to run on its own:

- A script you run by hand whenever someone in support, ops or finance asks for it.
- Admin actions on your product (look up a user, issue a refund, change a plan) that need a safe UI instead of database access.
- Reports and data pulls that should run on a schedule and keep their results.
- File jobs: clean a CSV, convert a document, merge spreadsheets.
- Internal tools that would otherwise need a front end, auth and hosting built from scratch.

## When not to use it

- **Customer-facing apps or public APIs.** Callables is for internal tools. Only people on your team can run functions.
- **Long-running services.** Each run is a short job (up to 15 minutes), not a server or a worker that stays up.
- **Heavy data pipelines.** For multi-hour jobs or dependency graphs between tasks, use an orchestrator such as Airflow or Dagster.
- **No-code workflows between SaaS apps.** If nobody on the team writes code, a tool like Zapier fits better. See [Callables vs Zapier](https://callables.app/blog/callables-vs-zapier).

## How it works

1. **Write a function** with type hints and `@deploy`. Install the SDK with `pip install callables`.
2. **Check it locally.** `call check` finds deploy problems, and `call local` runs the function on your machine with the same input validation as the platform.
3. **Push to GitHub.** Connect the repo once in the web app. Every push to the branch builds and deploys.
4. **Your team runs it** from a form in the web app, schedules it, or runs it from a result row in another function.

## Concepts

- **Team:** your company's workspace. People join with a role: owner, admin, builder or member. See [sharing and access](https://callables.app/docs/sharing).
- **Project:** one connected GitHub repo and branch. A project holds any number of functions.
- **Function:** a Python function decorated with `@deploy`. Its name is its identity, so renaming it creates a new function.
- **Group:** a set of related functions inside a project, shown as one section, with shared secrets. See [groups](https://callables.app/docs/groups).
- **Deploy:** a build of one commit. Every push makes one, and you can roll a function back to an earlier one.
- **Run:** one call of a function, with its inputs, logs, result, files and resource usage.

## Next steps

- [Quickstart](https://callables.app/docs/quickstart): your first function, live in a few minutes.
- [Coding agents](https://callables.app/docs/coding-agents): let Claude Code, Cursor or Codex write and check functions for you.
- [Inputs](https://callables.app/docs/inputs) and [results](https://callables.app/docs/results): what each type hint and return type becomes.