Skip to content

Migrate to Tallyfy

How do I migrate data from other platforms to Tallyfy?

You can move from many popular workflow and form tools into Tallyfy using our open-source migrator scripts. Start with a dry run, review the report, then run the full migration when you’re ready. The code lives here: Tallyfy Migrator on GitHub ↗[1].

What does the migrator do?

The migrator runs a five-phase flow that matches how data moves from a source vendor into Tallyfy:

  • Discovery: Connects to the source, catalogs available data, and gathers counts.
  • Mapping: Translates vendor concepts to Tallyfy concepts (for example, project → template, task → step/task, custom field → form field).
  • Transformation: Converts structures to Tallyfy format and prepares users, fields, and metadata.
  • Migration: Creates data in Tallyfy. Supports dry-run and checkpoint resume.
  • Validation: Verifies integrity and outputs a report you can keep.

  1. Clone and install.

    Terminal window
    git clone https://github.com/tallyfy/migrator.git
    cd migrator
    pip install -r requirements.txt

  2. Configure environment variables.

    Terminal window
    cp .env.template .env
    # Edit .env with: TALLYFY_API_KEY, TALLYFY_ORGANIZATION, and the source vendor's API keys

  3. Run a dry run first.

    Terminal window
    # Example: Asana
    cd asana/src
    python main.py --dry-run --verbose

  4. Review the report. Confirm mappings, spot errors, and check rate-limiting notes. Adjust batch sizes or delays if needed.

  5. Run the actual migration.

    Terminal window
    python main.py

  6. Validate and spot-check. Use the generated report and sample records in Tallyfy. If anything fails mid-way, use --resume.

  7. (Optional) Enable AI-assisted mapping. Add AI_ENABLED=true and an AI API key in .env to improve field and structure mapping for complex vendors.

Vendor-by-vendor notes and caveats

Each folder below links directly to the open-source code for that vendor, with a quick summary of scope and common considerations.

  • Asana: Folder ↗[2]

    • Scope: Projects, tasks/subtasks, sections, custom fields → map to Tallyfy templates, steps, and form fields.
    • Caveats: Dependencies and sections may flatten or translate into conditional steps. Tags often become metadata. Respect API rate limits.

  • Basecamp: Folder ↗[3]

    • Scope: To-dos and lists → procedure templates and steps; message docs are typically referenced via links.
    • Caveats: Threads/comments are not 1:1 with Tallyfy task comments; attachments may be copied by URL.

  • ClickUp: Folder ↗[4]

    • Scope: Lists/folders/spaces, tasks, custom fields.
    • Caveats: Deep hierarchy is flattened into templates and steps. Use rules-based flattening; consider AI mapping for complex setups.

  • Cognito Forms: Folder ↗[5]

    • Scope: Forms and submissions → kick-off forms and variables.
    • Caveats: Field validation and conditional logic translate to Tallyfy where possible; verify complex branching.

  • Google Forms: Folder ↗[6]

    • Scope: Questions and responses.
    • Caveats: Simple structure migrates well; logic jumps may require manual checks. Low complexity.

  • Jotform: Folder ↗[7]

    • Scope: Forms, fields, and submissions.
    • Caveats: Rich widgets may need custom mapping. Watch for attachment handling and rate limits.

  • Kissflow: Folder ↗[8]

    • Scope: Workflows and forms.
    • Caveats: Some constructs (like advanced states) may map to conditional steps or automations; review validation results carefully.

  • Monday.com: Folder ↗[9]

    • Scope: Boards, groups, items, column types.
    • Caveats: 30+ field types via GraphQL. Use AI for field mapping where possible. High complexity; test thoroughly.

  • Next Matter: Folder ↗[10]

    • Scope: Processes and tasks.
    • Caveats: Step logic and automations may need manual review. Confirm user-role mapping.

  • Pipefy: Folder ↗[11]

    • Scope: Pipes, phases, fields.
    • Caveats: Paradigm shift from card/connection model to templates/steps. Use AI for workflow conversion. High complexity.

  • Process Street: Folder ↗[12]

    • Scope: Checklists, tasks, conditional logic.
    • Caveats: Complex conditions translate to Tallyfy automations. Medium complexity; validate branching.

  • Rocketlane: Folder ↗[13]

    • Scope: Project templates and tasks.
    • Caveats: Timeline and resource views do not directly map; focus on steps and assignments.

  • Trello: Folder ↗[14]

    • Scope: Boards, lists, cards → templates and steps.
    • Caveats: Checklists and labels map to steps/metadata. Butler automations require manual recreation.

  • Typeform: Folder ↗[15]

    • Scope: Forms and responses.
    • Caveats: Logic jumps translate where feasible. Low complexity overall.

  • Wrike: Folder ↗[16]

    • Scope: Projects/folders, tasks, custom fields.
    • Caveats: Folder/project distinctions flatten into template/process structure. Validate dependencies and custom field mappings.

Prerequisites

  • Python 3.10+ and pip installed
  • Tallyfy credentials: TALLYFY_API_KEY and TALLYFY_ORGANIZATION
  • Source vendor API credentials
  • Sufficient disk space for logs and reports

Tips, validation, and troubleshooting

  • Always dry-run first. Review the migration report. Fix obvious mapping gaps before moving on.
  • Mind rate limits. Tune MIGRATION_RATE_LIMIT_DELAY and batch sizes for large datasets.
  • Use checkpoints. For long runs, --resume saves time after transient failures.
  • AI assistance helps. For complex vendors (Monday.com, Pipefy), enable AI mapping to improve field translations.
  • Verify outcomes. Spot-check templates, steps, users, and sample processes in Tallyfy after migration.

Where this lands in Tallyfy

Migrated structures typically become Tallyfy templates, then you launch processes you can track as live processes with individual tasks. Use automations to recreate conditional behavior from the source system.

Templates > Import a template

Tallyfy provides multiple template import methods including AI-powered document and flowchart conversion template copying between accounts API integration and Word document import capabilities to help organizations migrate existing processes into standardized digital workflows.

Pro > Integrations

Tallyfy connects with existing business software through multiple methods including email integrations API implementations webhooks middleware platforms AI agents native integrations analytics connections chat platform tools and Azure translation services allowing teams to choose the approach that best fits their technical capabilities and integration needs.

Integrations > Middleware

Middleware platforms like Zapier Make and Power Automate enable non-technical users to automatically connect Tallyfy with other business applications through visual drag-and-drop interfaces without requiring any coding expertise.

Middleware > n8n

N8n is an open-source workflow automation platform that connects Tallyfy with hundreds of business applications through visual workflows offering both cloud-hosted and self-hosted options with flexible HTTP Request and Webhook nodes for seamless integration without vendor lock-in.
Get in touch
About Tallyfy