Float is a resource planning platform for agencies and service businesses: who on the team is available, when, and for how many hours. When a deal moves to “Won” in Kommo, the project needs to be entered in Float immediately - otherwise the project manager does not know about the new workload, the team gets overloaded, and deadlines slip. Float REST API v3 makes it possible to automate this handoff.
Unlike task managers (Linear, Jira, Asana), Float solves a different problem: not “what needs to be done” but “who will do it and when.” For agencies this is critical - setting up a Kommo pipeline for a service business always ends with the question: how do you hand a won deal over to delivery?
The problem without integration
The typical process without automation: manager closes the deal -> opens Float -> creates a project manually -> finds an available specialist -> creates an allocation. This takes 20-30 minutes. With 15-20 new projects per month that is 5-8 hours of administrative work.
The second problem is data synchronization. The project name in Float often differs from the deal name in Kommo. The budget is entered from memory rather than from the CRM. The start date is approximate. After a month, Float and Kommo are out of sync: it is unclear which Float project corresponds to which Kommo deal.
The third problem is resource conflicts. If resource planning is not updated immediately after a deal closes, a department head can take on another project with the same resources. The conflict is discovered too late.
Integration architecture
Float API v3 works via REST; authentication uses a Bearer token (Personal Access Token from the Float profile). The API covers: projects (/projects), clients (/clients), allocations (/allocations), people (/people).
How it works:
- Kommo sends a webhook when a deal’s status changes to “Won.”
- The service creates or finds a Client in Float by matching the company name from Kommo.
- Creates a Project with data from the deal: name, budget, start/end date.
- Optionally: creates initial allocations for key roles based on a template.
- Writes the Float Project ID back into a custom field on the Kommo deal.
- When a project status updates in Float (via Float webhook) - updates a tag in Kommo.
import requests
from datetime import datetime, timedelta
FLOAT_BASE = "https://api.float.com/v3"
def get_or_create_client(token: str, company_name: str) -> int:
"""Find or create a client in Float."""
headers = {
"Authorization": f"Bearer {token}",
"Content-Type": "application/json",
}
# Float has no search; fetch the full list
clients = requests.get(f"{FLOAT_BASE}/clients", headers=headers).json()
for client in clients:
if client["name"].lower() == company_name.lower():
return client["client_id"]
# Create a new client
resp = requests.post(
f"{FLOAT_BASE}/clients",
headers=headers,
json={"name": company_name}
)
resp.raise_for_status()
return resp.json()["client_id"]
def create_float_project(
token: str,
client_id: int,
name: str,
budget_total: float,
start_date: str,
end_date: str,
tags: list = None
) -> dict:
"""Create a project in Float."""
headers = {
"Authorization": f"Bearer {token}",
"Content-Type": "application/json",
}
payload = {
"name": name,
"client_id": client_id,
"budget_total": budget_total,
"start_date": start_date,
"end_date": end_date,
"status": 1, # 1=Tentative, 2=Confirmed
"tags": tags or [],
}
resp = requests.post(
f"{FLOAT_BASE}/projects",
headers=headers,
json=payload
)
resp.raise_for_status()
return resp.json()
def create_allocation(
token: str,
project_id: int,
person_id: int,
start_date: str,
end_date: str,
hours_per_day: float
) -> dict:
"""Allocate a person to a project."""
headers = {
"Authorization": f"Bearer {token}",
"Content-Type": "application/json",
}
resp = requests.post(
f"{FLOAT_BASE}/allocations",
headers=headers,
json={
"project_id": project_id,
"people_id": person_id,
"start_date": start_date,
"end_date": end_date,
"hours": hours_per_day,
}
)
resp.raise_for_status()
return resp.json()
def on_deal_won(deal: dict, float_token: str, kommo_client):
"""Entry point: called when a deal is closed."""
company = deal.get("company_name", "No company")
project_name = deal["name"]
budget = float(deal.get("price", 0))
# Start date - from a custom deal field or +7 days from today
raw_start = deal.get("custom_start_date")
start_date = raw_start or (
datetime.now() + timedelta(days=7)
).strftime("%Y-%m-%d")
# End date - from a custom deal field or +30 days
raw_end = deal.get("custom_end_date")
end_date = raw_end or (
datetime.now() + timedelta(days=37)
).strftime("%Y-%m-%d")
client_id = get_or_create_client(float_token, company)
project = create_float_project(
float_token, client_id, project_name,
budget, start_date, end_date,
tags=["kommo-auto"]
)
# Write Float Project ID back to Kommo
kommo_client.update_lead(
deal["id"],
custom_fields={"float_project_id": str(project["project_id"])}
)
return projectStep-by-step implementation
Step 1 - Float Personal Access Token. In your Float profile: Account Settings -> Developer API. Generate the token. It does not expire, but rotating it once a year is recommended.
Step 2 - custom fields in Kommo. Create fields on deals: “Project Start Date,” “Project End Date,” “Float Project ID.” Managers fill in the first two when closing the deal - the integration picks them up.
Step 3 - Kommo webhook. Subscribe to the status change event. Filter: only transitions to the “Won” status (pipeline_id + status_id of the corresponding stage).
Step 4 - allocation templates (optional). For standard project types you can create a template: when a Float project is created, a Project Manager is automatically allocated for the full duration and a Senior Developer for the first two weeks. The template is stored in the service configuration.
Step 5 - Float webhook for reverse synchronization. Float supports outbound webhooks (configured in Settings -> Integrations -> Webhooks). The project.updated event lets you update data in Kommo when a project status changes in Float.
Step 6 - notifications to the project lead. When a new project is created in Float, send a Slack notification to the project manager’s channel: “New project added: [name]. Budget: $X. Start: [date]. Needs resource assignment.”
Real case: digital agency, 22 people
Design agency, Berlin. Team of 22: 3 sales managers, 6 designers, 4 developers, 2 PMs. On average 12-15 new projects per month.
Before integration: when a deal closed, the PM found out via Slack or by chance. Creating the project in Float took 25-30 minutes. On several occasions one specialist ended up allocated to two projects simultaneously - discovered on Friday when the overtime had already happened.
After integration: when a deal closes in Kommo, the manager fills in two fields (start date, end date). Within 30 seconds the project appears in Float with the client, budget, and timeframe. The PM gets a Slack notification and assigns specific people.
Result: time from deal close to project appearing in Float - from 1-2 days down to 1 minute. Resource conflicts dropped to zero over 4 months of observation.
Who this is for
The Kommo + Float integration is relevant for:
- Agencies (digital, consulting, development) with teams of 10-100 people
- Companies where sales and delivery are separate teams using different tools
- Organizations with repeating project types where allocations can be templated
- Managers who currently plan resources in Excel or from memory
If your team manages tasks in Linear or Jira, these integrations can coexist: Float handles “who and when,” task managers handle “what exactly to do.” Custom Kommo integrations let you combine both flows from a single trigger - a closed deal.
Frequently asked questions
Float shows workload in percentages or hours. Which is better for allocations?
Float supports both formats. The API accepts hours (hours per day) or percent (percentage of working time). For project businesses with fixed hours, hours is more convenient; for retainers, percent works better. In our integration we typically use hours, calculating the approximate count from the budget and the specialist’s rate.
Can you automatically assign specific people, or only create the project?
You can assign specific people via the allocations API, but you need their people_id in Float. Typically a mapping is built: role on the Kommo deal -> specific person in Float. Or: project type from a custom deal field -> allocation template. Full automation works for standard projects; non-standard ones are assigned by the PM manually.
Float is paid. Are there alternatives with a similar API?
Resource planning alternatives include Teamdeck, Resource Guru, and Runn. All have REST APIs. The integration architecture with Kommo is similar; only the API specifics change. The choice of tool depends on team size and feature set.
How do you handle date changes in the Kommo deal?
If a manager updates the date custom fields on the Kommo deal, the Kommo lead.updated webhook notifies the service. The service retrieves the Float Project ID from the custom field, calls PUT /projects/{id} with the new dates, and adjusts existing allocations as needed. Full two-way synchronization.
What happens to the Float project if the Kommo deal is lost?
If the deal was already closed as Won, the Float project has already been created. If the deal is reopened or marked Lost in Kommo, the integration can notify the PM - “Deal X changed status, please check Float.” Automatically deleting the Float project is not recommended - resources may already be allocated and would require manual re-planning.
Next step
If you need a Kommo + Float integration - describe your requirements to the Exceltic.dev team. We will review your project handoff process and propose an architecture. A typical project takes 2-3 weeks including allocation template setup.