Tidio to Podium Migration: A Technical Guide

Tidio to Podium Migration: A Technical Guide

Last verified: August 2026. Tested against Tidio OpenAPI and Podium REST API v4.

What Is a Tidio to Podium Migration?

A Tidio to Podium migration is the process of extracting contacts, conversation history, tags, custom properties, and ticket data from Tidio and loading them into Podium as contacts, conversations, attributes, and notes — while preserving customer identity and as much historical context as possible.

This is not a simple CSV import or a like-for-like platform swap. It requires a complete ETL rebuild because the two platforms have incompatible data models: Tidio organizes data by website session and email identifier; Podium organizes data by physical location and phone number. A Tidio conversation can exist without a phone number. A Podium conversation cannot exist without one. A Tidio contact requires no location. Every Podium contact requires a locationUid tied to a physical business address.

Tidio combines live chat, AI chatbots (Lyro), and multichannel messaging (website chat, email, Messenger, WhatsApp, Instagram) under a single dashboard built around website sessions and email identifiers.

Podium is built around SMS/text messaging, webchat, Google and Facebook review management, text-based payments, and marketing campaigns — designed for local businesses with physical locations. Every meaningful action in Podium requires a locationUid.

Teams that treat this as a simple CSV import rather than a full ETL pipeline fail because the data model transformation — not the volume — is the hard part.

For related migration paths, see:

• Tidio to Zendesk Migration Guide — for teams moving to a traditional helpdesk.
• Tidio to Intercom Migration Guide — for teams evaluating a product-led support platform.
• Plain to Tidio Migration: The Technical Guide — for teams moving data into Tidio from a B2B platform.
• Zero-Downtime Help Desk Data Migration — broader scope checklist for any support platform move.

Why Teams Move from Tidio to Podium

The switch is not an upgrade — it is a change in operational model. Teams migrate for specific reasons:

• Channel shift to SMS. When a business discovers customers respond faster to text messages than to chat widgets, Podium's SMS-first model becomes the obvious choice.
• Review and reputation management. Tidio has no built-in review management. Podium lets businesses request, collect, and respond to Google and Facebook reviews from the inbox — a core workflow for local service businesses.
• Location-based operations. Multi-location businesses (dental practices, auto shops, home services) need conversations and contacts scoped to physical locations. Podium handles this natively. Tidio has no concept of locations.
• Payments via messaging. Podium integrates text-to-pay directly into conversations. Tidio has no native payment processing.
• Lead conversion focus. Podium is built as a lead conversion platform with AI-powered responses, automated review requests, and campaign tools designed to turn inbound messages into booked appointments.

Tidio vs. Podium: Data Model Comparison

Understanding what maps — and what doesn't — is the most important step before writing any migration code.

API Access and Authentication

Tidio (Source)

Tidio's OpenAPI provides endpoints for contacts, conversations, tickets, and operators. Access requires a Plus plan ($749/month minimum) or Premium plan. Free, Starter, and Growth plans do not have backend API access.

Authentication uses two custom headers:

X-Tidio-Openapi-Client-Id: <your_client_id>
X-Tidio-Openapi-Client-Secret: <your_client_secret>

Every request must also include Accept: application/json; version=1. Credentials are generated in the Tidio Panel under Developer > OpenAPI. (developers.tidio.com)

Rate limits: 60 requests per minute on Plus, 120 on Premium — counted per project, not per API key. If your Tidio project has active integrations (CRM sync, Zapier workflows, Shopify connections) running during extraction, they compete for the same quota. Schedule extraction during off-hours or pause non-essential integrations.

If you don't have a Plus or Premium plan, the fallback is CSV export from the Tidio Contacts section. This captures contact identity fields and properties but does not include conversation history or message content. You can also request a data export from Tidio support under GDPR/data portability regulations. (developers.tidio.com)

Podium (Target)

Podium uses OAuth 2.0 for API authentication. You need a developer account at developer.podium.com, an approved OAuth application, and authorization from a Podium Platform User. (docs.podium.com)

Key endpoints for migration:

• Contacts API: Create, read, update, and delete contacts. Supports name, phone, email, tags, and custom attributes. Every contact must be associated with at least one locationUid.
• Import a Message: Load historical messages into Podium without triggering live SMS delivery to the customer. Requires locationUid, channel, contactName, direction, and publishedAt. (docs.podium.com)
• Conversation Notes: Write internal notes to conversations — the destination for Tidio internal ticket notes.
• Locations API: Retrieve location UIDs needed for all contact and message operations.

Rate limits: Most Podium endpoints are documented at 300 requests per minute. The live message-sending endpoint is more restrictive. For long-running migration scripts, implement OAuth token refresh logic — a migration extracting 50K conversations can run for 10+ hours, well past typical token TTLs.

Step-by-Step Migration Process

Step 1: Audit and Inventory Tidio Data

Before extracting anything, understand what you have:

• Total contacts and what percentage have phone numbers vs. email-only
• Conversation volume — total threads and average messages per thread
• Active Help Desk tickets — these need careful handling (see data model table)
• Custom Contact Properties — list every property and its data type
• Tags — full taxonomy, noting which are ticket-scoped vs. contact-scoped
• Chatbot flows — document active flows for manual rebuild in Podium
• Canned Responses — export text for recreation as Podium templates
• Attachments — identify conversations with file uploads; these require a separate workstream

Use the Tidio OpenAPI GET /contacts endpoint to pull a full inventory, or export via CSV if you lack API access.

Step 2: Map Tidio Projects to Podium Locations

This is the architectural decision that drives everything else. Tidio organizes data by Projects (usually corresponding to a website). Podium organizes data by Locations (physical business addresses).

Query the Podium Locations API to retrieve all locationUid values:

import requests
 
def get_podium_locations(access_token):
    headers = {"Authorization": f"Bearer {access_token}"}
    response = requests.get(
        "https://api.podium.com/v4/locations",
        headers=headers
    )
    return response.json().get("data", [])

Build your mapping table using one of these patterns:

Decide your mapping pattern before any data moves. Changing it mid-migration requires re-running the entire load for affected contacts. (help.tidio.com)

Step 3: Extract Contacts from Tidio

Pull all contacts with their properties, tags, and associated conversation IDs:

import time
import requests
 
TIDIO_BASE = "https://api.tidio.co"
HEADERS = {
    "X-Tidio-Openapi-Client-Id": "<your_client_id>",
    "X-Tidio-Openapi-Client-Secret": "<your_client_secret>",
    "Accept": "application/json; version=1"
}
 
def extract_tidio_contacts(output_path="contacts_raw.jsonl"):
    contacts = []
    cursor = None
    page = 0
    with open(output_path, "a") as f:
        while True:
            params = {"limit": 100}
            if cursor:
                params["cursor"] = cursor
            resp = requests.get(
                f"{TIDIO_BASE}/contacts",
                headers=HEADERS,
                params=params
            )
            if resp.status_code == 429:
                retry_after = int(resp.headers.get("Retry-After", 60))
                time.sleep(retry_after)
                continue
            data = resp.json()
            page_data = data.get("data", [])
            for record in page_data:
                f.write(json.dumps(record) + "\n")  # Write each page to disk
            contacts.extend(page_data)
            cursor = data.get("meta", {}).get("next_cursor")
            page += 1
            if not cursor:
                break
            time.sleep(1)  # Stay within 60 req/min
    return contacts

Step 4: Extract Conversations, Tickets, and Messages

For each contact, pull associated conversations and their messages. For a full-fidelity move, also extract tickets, departments, and contact property definitions. (developers.tidio.com)

Tag each message with its sender type (visitor, operator, or bot) and its visibility (public vs. internal) during extraction. Tidio separates visibility with message_type and sender role with author_type. You need both to decide what becomes a Podium imported message vs. a conversation note.

This is the most time-consuming step due to rate limits.

Step 5: Transform and Normalize

Before loading anything into Podium, normalize your extracted data:

Phone numbers. Parse all phone numbers through a library like Google's libphonenumber and format to E.164 (+15551234567). Podium's API rejects non-E.164 numbers. Tidio allows freeform input — you will encounter (555) 123-4567, 555 123 4567, and worse. Non-E.164 numbers cause silent load failures if not caught before submission.

Deduplication. Tidio often creates duplicate contacts when a user chats from different devices without logging in. Podium deduplicates contacts by phone number within a location — a duplicate submission either merges silently or errors, depending on the endpoint behavior. Your pipeline must merge Tidio chat histories into a single record per E.164 phone number before loading to avoid split contact records in Podium.

Visibility split. Separate customer-visible messages from internal notes. Customer-visible Tidio messages become Podium imported messages. Internal Tidio notes become Podium conversation notes. Getting this wrong leaks private agent commentary into customer-visible history — the most common and most damaging error in this migration.

Tag scope adjustment. Tidio ticket tags are per-ticket. Podium tags are per-contact. If one contact had multiple tickets with different tags, all those tags will aggregate on the single Podium contact record. Prefix ticket-specific tags (e.g., ticket:billing-issue, ticket:refund-requested) to preserve the original scope and prevent tag pollution.

Status and priority mapping. Tidio's pending, urgent, and department fields have no native Podium equivalent. Preserve these as tags (e.g., tidio_status:pending, tidio_priority:urgent) or custom attributes before they are lost.

HTML and encoding. Tidio chat messages can contain emoji, HTML fragments from rich text input, and Unicode characters. Sanitize HTML before loading. SMS messages are subject to GSM-7 encoding limits (160 characters per segment) or UCS-2 for Unicode content including most emoji (70 characters per segment). A 300-character Tidio chat message with a single emoji becomes a 5-segment SMS, which may affect readability in Podium's inbox.

Step 6: Load Contacts into Podium

Create Podium contacts before loading any message history so every later import resolves cleanly.

def create_podium_contact(access_token, location_uid, tidio_contact):
    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"
    }
    payload = {
        "locationUid": location_uid,
        "name": tidio_contact.get("name", ""),
        "phoneNumbers": [tidio_contact["phone"]] if tidio_contact.get("phone") else [],
        "emails": [tidio_contact["email"]] if tidio_contact.get("email") else [],
        "tags": tidio_contact.get("tags", []),
        "attributes": transform_properties(tidio_contact.get("properties", {}))
    }
    resp = requests.post(
        "https://api.podium.com/v4/contacts",
        headers=headers,
        json=payload
    )
    return resp.json()

Store the resulting Podium contact UID alongside the original Tidio contact ID in a local mapping table (SQLite works well for datasets under 500K rows). You need this mapping to link conversations and messages in later steps. Write a tidio_contact_id as a Podium contact attribute for stable foreign key tracking — useful for reconciliation, auditing, and replay if a batch fails.

Step 7: Load Conversation History

This is where expectations meet reality. You have three options, and the right choice depends on your data and your team's needs.

Option 1: Import as Podium messages (use when contacts have phone numbers and history has agent value). Use Podium's Import a Message endpoint to load historical messages chronologically. This endpoint imports data into Podium without triggering live SMS delivery to the customer. (docs.podium.com)

function mapTidioMessageToPodium(message, ctx) {
  if (message.message_type === 'internal') {
    return {
      kind: 'note',
      body: message.message_content,
      senderName: ctx.operatorName || 'Tidio import'
    };
  }
 
  return {
    kind: 'message',
    body: message.message_content,
    direction: message.author_type === 'contact' ? 'inbound' : 'outbound',
    publishedAt: message.created_at,
    contactName: ctx.contactName,
    channel: ctx.channel,
    locationUid: ctx.locationUid
  };
}

For tickets, use the Tidio subject line as the first Podium message or preserve it in a leading note. Keep internal comments out of customer-visible history by routing them to Podium conversation notes. Migrate Tidio bot messages as outbound imported messages attributed to a dedicated "Bot" user, or write them as notes. This preserves triage context (e.g., the customer already confirmed their account number) without confusing human agents.

Option 2: Store as contact notes or attributes. Serialize conversation summaries or full transcripts into a custom attribute or note on the contact record. Preserves context for agents but is not searchable at the message level. Best for email-only contacts where you cannot use Option 1, or for very high-volume, low-value chat sessions.

Option 3: Accept the clean break. Keep Tidio accessible in read-only mode for 90 days while historical context ages out. Many teams find this is the correct decision — forcing years of web chat history into an SMS platform creates confusing data for agents, and the effort-to-value ratio of serializing thousands of low-value chat transcripts is rarely justified.

Decision framework:

Step 8: Implement OAuth Token Refresh

For migrations running longer than a few hours, Podium access tokens will expire. Implement token refresh logic before starting any long-running load:

import time
import requests
 
class PodiumAuthClient:
    def __init__(self, client_id, client_secret, initial_token_response):
        self.client_id = client_id
        self.client_secret = client_secret
        self.access_token = initial_token_response["access_token"]
        self.refresh_token = initial_token_response["refresh_token"]
        self.expires_at = time.time() + initial_token_response["expires_in"] - 60  # 60s buffer
 
    def get_access_token(self):
        if time.time() >= self.expires_at:
            self._refresh()
        return self.access_token
 
    def _refresh(self):
        resp = requests.post(
            "https://api.podium.com/oauth/token",
            data={
                "grant_type": "refresh_token",
                "refresh_token": self.refresh_token,
                "client_id": self.client_id,
                "client_secret": self.client_secret,
            }
        )
        resp.raise_for_status()
        data = resp.json()
        self.access_token = data["access_token"]
        self.refresh_token = data.get("refresh_token", self.refresh_token)
        self.expires_at = time.time() + data["expires_in"] - 60

Inject this client into every API call during the migration. A 50K-conversation migration running for 12 hours will invalidate multiple tokens; without refresh logic, the load silently fails and leaves your data partially imported.

Step 9: Rebuild Automation and Templates

Tidio chatbot flows, Lyro AI configuration, and canned responses do not transfer.

• Canned Responses → Podium Templates: Export response text from Tidio and create equivalent message templates in Podium.
• Chatbot Flows → Podium Automations: Podium supports automations (review requests, follow-ups, campaign triggers) but uses a different paradigm. Map Tidio flow triggers to Podium automation triggers. This is a design exercise, not a data migration — budget time for it separately.
• Lyro AI → Podium AI: Podium has its own AI features for suggested replies and automated responses. These are configured within Podium, not imported.

Tidio can export flows between Tidio projects, but that does not make them portable to Podium. Expect a full manual rebuild. (help.tidio.com)

Cutover Strategy

Once the main backfill is running, subscribe to Tidio webhooks for new events so source and destination stay in sync during the transition window. Tidio signs webhook payloads in the x-tidio-signature header using HMAC-SHA256 over body_timestamp. Use stable source IDs for idempotency — Tidio documents at-least-once delivery for webhook events. (developers.tidio.com)

Safe cutover sequence:

1. Backfill: Run the ETL pipeline to migrate all historical data. This handles 99% of the volume.
2. Delta capture: Turn on webhook-based delta sync and let it run long enough (minimum 48 hours) to prove replay and idempotency across multiple event types.
3. Freeze: Disable the Tidio widget and stop routing new chats to agents.
4. Final sync: Run a final delta to catch conversations from the freeze window.
5. Pilot: Test with one location or a small operator group in Podium before full rollout.
6. Go-live: Deploy the Podium webchat widget, update your Google Business Profile to use the Podium phone number, and port any necessary SMS numbers.
7. Soak period: Leave Tidio readable so agents can look up historical context for 30–90 days.
8. Reconcile and retire: Verify counts, spot-check transcripts against the validation checklist, then retire old workflows.

If cutover risk is your main concern, read Zero-Downtime Help Desk Data Migration before scheduling the switchover.

Edge Cases and Failure Modes

Attachments

Decision tree for attachment handling:

• Are the attachments legally significant (contracts, signed documents, evidence)? → Archive externally (S3, Google Drive), generate stable URLs, and link from a Podium conversation note. Do not rely on Tidio's CDN URLs, which may expire after account closure.
• Are the attachments operationally useful (photos of a job site, product images)? → Manual recreation for high-value cases; accept loss for the rest.
• Are the attachments low-value (marketing screenshots, generic support images)? → Accept the loss. The effort to individually migrate image attachments almost never justifies the outcome.

Tidio supports file uploads up to 10 MB. Podium supports attachments up to 30 MB for live messages, but the public Import a Message endpoint does not document an attachment parameter for historical imports.

Unicode and Encoding

Tidio chat messages can contain emoji, HTML fragments from rich chat, and Unicode characters. Sanitize HTML before loading into Podium. SMS messages are subject to GSM-7 encoding limits (160 characters per segment) or UCS-2 for Unicode content including emoji (70 characters per segment). A 300-character Tidio message with a single emoji becomes a 5-segment UCS-2 SMS — this affects readability in Podium's conversation view.

Merged and Duplicate Contacts

Tidio creates duplicate contacts when a user chats from different devices without logging in. Podium deduplicates contacts by phone number within a location. If your ETL pipeline submits two Tidio contacts with the same E.164 phone number, Podium's API may merge them silently or error, depending on endpoint behavior — either outcome loses conversation attribution for one of the source contacts. Deduplicate by phone number before loading, and merge chat histories explicitly in your pipeline.

Rate Limit Collisions

Tidio rate limits are per-project. Active integrations (Shopify, Zapier, CRM syncs) on the same project compete for the same 60 req/min budget. Run extraction during off-peak hours or pause non-essential integrations for the duration of extraction.

Podium OAuth Token Expiry

Covered in Step 8 above. Without token refresh logic, any migration running longer than the token TTL will fail silently mid-load.

CSAT and Ratings

Tidio allows customers to rate individual chat sessions. Podium is built for Google/Facebook reviews — there is no equivalent internal rating field. Extract Tidio CSAT scores and append them as contact tags (e.g., tidio_csat_5, tidio_csat_1) or as a custom attribute. This preserves the data for reporting without forcing it into a Podium field that doesn't exist.

Webhook Gaps During API Testing

Tidio does not fire webhooks for changes made via its own OpenAPI. If you test your migration pipeline against a Tidio staging project using API writes, none of those writes will appear in the webhook event stream. Test webhook handling with manual UI actions only.

Migration Timeline and Effort

The effort estimates below are derived from per-step component time:

These estimates assume one engineer with API familiarity. They do not include agent training on Podium, phone number enrichment, or legal review of consent records.

Validation Checklist

After migration, verify:

• Contact count match: Total contacts with phone numbers in Tidio ≈ total contacts created in Podium
• Tag integrity: Spot-check 50+ contacts for correct tag assignment and ticket: prefix where applicable
• Attribute mapping: Custom property values transferred correctly to Podium attributes; no encrypted attributes that need to be filtered
• Location assignment: Every Podium contact has the correct locationUid
• Duplicate check: No duplicate contacts by phone number within the same location
• Note visibility: Internal Tidio notes stayed internal in Podium — not leaked into customer-visible history (test with 20+ records including known internal notes)
• Status preservation: pending and urgent data survived in the chosen surrogate tag or attribute
• Consent accuracy: Marketing consent was not overstated; email opt-in was not converted to SMS opt-in
• Template parity: Canned response content matches new Podium templates
• SMS test: Send a test message to 5–10 migrated contacts to confirm end-to-end delivery and correct number assignment
• Historical access: Tidio remains accessible in read-only mode for lookups
• Reconciliation table: External table with source IDs, destination UIDs, batch timestamps, and loader status exists for replay
• Token refresh: OAuth refresh logic confirmed working through a full token expiry cycle during load

When NOT to Migrate from Tidio to Podium

This migration doesn't make sense in every scenario:

• Your support is primarily email and web chat. Podium is SMS-first. If your customers interact via email tickets and web chat, Podium is a worse fit and leaves most of your channel history with no home.
• You need a ticketing system. Podium has no help desk or ticket management with status, priority, or SLA tracking. If you rely on Tidio's Help Desk feature, you need a second tool alongside Podium or a different migration target entirely.
• Most contacts lack phone numbers. If your Tidio contact base is 70%+ email-only, the migration will leave most of your customer data functionally unusable in Podium. The enrichment cost to fix this often exceeds the value of the migrated data.
• You're a SaaS or digital-only business. Podium is designed for local businesses with physical locations. If you don't have storefronts or service areas, the locationUid requirement adds architectural friction with no corresponding benefit.

If your real destination is a ticket-centric help desk rather than a local-business messaging platform, Tidio to Zendesk is often a closer fit. If you are still deciding whether Podium is the right target, Top Podium Alternatives (2026) is the better next read. You can also explore our Podium to Crisp and Podium to Helpshift guides to see how Podium's unique location-based architecture compares to other messaging and support platforms.

What This Migration Costs

Beyond engineering time, factor in:

• Tidio Plus plan ($749/month) if you need API access and aren't already on it
• Podium subscription — pricing is location-based and not publicly listed; expect pricing to scale with location count and user seats. Request a quote directly from Podium sales; budget for a per-location monthly fee plus add-ons for AI features and campaigns.
• Podium developer account — free to apply, but approval takes a few days; factor this into your project timeline
• Phone number enrichment (if needed) — third-party services like Clearbit or ZoomInfo charge per-record for phone append; at scale this is a non-trivial cost
• Agent retraining — Podium's inbox, automation, and review workflows are completely different from Tidio; budget 8–16 hours per team
• Parallel operation — plan to run both platforms for 2–4 weeks during transition; this is a real cost if Tidio is on a monthly plan

Summary

Migrating from Tidio to Podium is a deliberate shift from a web-chat-and-email support model to an SMS-and-reviews business communication model. The contact and tag migration is technically straightforward with the right API access. The hard parts are:

1. Phone number coverage — contacts without phone numbers are inert in Podium
2. Consent — email opt-in is not SMS consent; do not conflate them
3. Note visibility — internal Tidio notes must not appear in customer-visible Podium history
4. Conversation history — requires careful routing through Podium's Import a Message endpoint or an explicit clean break decision
5. Chatbot flows — require a full manual rebuild with no import path
6. OAuth token management — long-running migrations must implement token refresh
7. Tag scope — per-ticket Tidio tags must be prefixed before becoming per-contact Podium tags

For teams that have confirmed their contacts have phone numbers, mapped their locations, and committed to Podium's model, this is a 2–4 week project with known failure modes and predictable outcomes.

At ClonePartner, we build the custom ETL pipelines, handle the edge cases around phone number normalization, location assignment, and note visibility, and deliver validated data in Podium — so your team can focus on learning the new platform instead of debugging extraction scripts.