What Changes When You Move to Daytona V2?

Use Daytona’s V2 SDK to test the workload on a disposable Linux sandbox, then compare its metered CPU, memory, and disk subtotal with the avoidable cost of keeping your current deployment.

Test the SDK surface your workload actually uses

Daytona’s V2 client repository lists TypeScript and Python SDKs and a CLI, with API access organized around sandbox resources. The older Daytona repository’s v0.190.0 release page is marked archived. Treat that as a reason to test the client contract your application depends on. Pick a representative job and feed both deployments the same synthetic CSV. Have each worker write a sorted output file, return its checksum, emit one line on stderr, and exit with a deliberate nonzero status in a separate run. Record the checksum, exit status, and time from submission to first result. If your app also uses a preview port, add a harmless service that returns a fixed string and log whether the intended caller can reach it. A matching checksum paired with a missing exit status still blocks migration if the coordinator uses that status to decide whether to retry.

GitHub - daytona/clients: Official SDKs, API clients, and CLI/MCP tools for Daytona, the secure and elastic infrastructure for running AI-generated code · GitHub

Compare allocated sandbox-hours with an avoidable bill

Daytona’s pricing excerpt lists hourly charges for allocated vCPU, memory, and disk above the first 5 GiB. For a fleet of identical CPU-only sandboxes, sum sandbox-hours across the fleet. Ten workers running simultaneously for six minutes consume one aggregate sandbox-hour under that accounting assumption. At 2 vCPU, 4 GiB RAM, and 10 GiB disk, the listed subtotal is $0.16614 per aggregate hour, of which $0.00054 is disk. Profile a smaller allocation against the same job mix and record sandbox-hours per successful job. A smaller worker that slows jobs or increases retries can cost more per completion. For the comparison, enter the monthly spend that would actually disappear when you retire the existing deployment. Shared infrastructure you will keep contributes zero avoidable cost. Use a short billing export to reconcile your assumed billable hours before relying on the break-even point.

Daytona - Secure Infrastructure for Running AI-Generated Code

Identify the target before provisioning

Record the installed SDK version, configured API host, and account for the job you’re moving. The original Daytona documentation shows a daytona-v0 CLI and an API example on app.daytona.io. Capture those details from the environment that actually runs the job, since a developer shell and a deployed worker can load different configurations.

Create one disposable sandbox using the documented client for your intended platform. Confirm that the sandbox appears in the intended account and that the client can reconnect to it. If authentication succeeds but the sandbox appears in the wrong account or dashboard, stop the migration and check endpoint and credential selection. An accepted create request tells you that an API worked. The account check tells you which deployment you exercised.

Sandboxes | Daytona

Exercise a clean-worker handoff

Daytona’s V2 client repository identifies TypeScript and Python SDKs. For a migration pilot, pin the V2 client version tested by your application and record the API host it actually contacts. Run the same recovery test on the original and V2 targets. Use the same input, output check, and timing boundaries so you can compare how much work each path repeats.

In an illustrative build, suppose 40 of 60 files are complete when you retire a disposable worker. Save the 40 outputs and a manifest to application-controlled storage before ending the worker. Start a separate sandbox and verify that it builds only the remaining 20 files and yields the same final manifest as an uninterrupted run. If recovery requires reconnecting to the retired sandbox, the workflow still depends on that sandbox’s lifecycle.

GitHub - daytona/clients: Official SDKs, API clients, and CLI/MCP tools for Daytona, the secure and elastic infrastructure for running AI-generated code · GitHub

Keep the two cost estimates separate

The supplied daytona.io price schedule lists $0.0504 per vCPU-hour and $0.0162 per GiB-hour. An illustrative workload reserving two vCPUs and 4 GiB for 30 billable hours yields $4.968, or about $4.97 for compute and memory before storage, credits, or other charges. Use the pilot to record any extra runtime spent warming a fresh sandbox and restoring checkpoints.

For Daytona 2.0, obtain the rate schedule for the actual account, region, and capacity type. Verify what CPU and memory quantities are billed, whether unused capacity carries a minimum charge, and which fees apply to checkpoints and interrupted jobs. Multiply each verified rate by the corresponding pilot usage and add any applicable plan fee. The daytona.io rates support the original-platform example only.

Daytona - Secure Infrastructure for Running AI-Generated Code

Verify network policy in the running worker

Include a connectivity test if the original Daytona job depends on an internal package registry or a restricted outbound policy. The original platform’s isolation documentation distinguishes rules for incoming and outgoing traffic. List which destinations the job needs and test them from inside the sandbox itself. Also test a harmless endpoint you control that the policy should deny.

Repeat the same test on 2.0 using that platform’s documented settings. A successful pilot can fetch the required package and records a denial for the test destination. If the registry request fails, use the error to distinguish name resolution, connection failure, and an authentication rejection. Keep the workload on the proven target while correcting the specific dependency or network setting.

Isolation | Daytona

Sources