Charger management

Migration discovery questionnaire

Before a network moves its chargers to Ivora, we ask the questions on this page. Most migration surprises come from things nobody wrote down: a charger model that rebuilds its server URL in its own way, payment terminals wired to the previous platform, SIM cards that only reach one address, card numbers read in another byte order, or a price rule the charger screen has to show. Answering up front lets the migration start with a plan for each of them.

Whoever is closest to the network answers: the network's own operations team, its sales contact at Ivora, or the partner or installer running the move. Fill in the answers template and send the file to your Ivora contact. One file covers one network. "Unknown" is a useful answer: it tells us what to check first. Only the template's format line is required.

Note

Keep secrets out of the answers. Never write charger passwords, API keys, portal logins, card numbers or drivers' personal data into the file. When a step needs a credential, Ivora asks for it through a separate, secure channel. The contacts section names people, so share the file only with the people working on the migration.

How the answers are used

Answers	Become
Incumbent, charger and site counts, target dates	The migration request: `source_platform`, `chargers_estimate`, `sites_estimate`, `target_from`, `target_to`
Sites and charger inventory	The network import CSV, then the move plan
Charger models, OCPP versions, security profiles, URL format	The connection plan per model (Connecting chargers) and the charger proxy's routes
Network and SIMs	Whether chargers can reach Ivora at all, and who has to change what
Payments and terminals	The settlement flow and moving the payment service site by site
Drivers and RFID	The RFID token import and the driver communication
Pricing and tax	Tariffs, tax lines and the screen price
QR stickers	QR sticker redirects
Quiet windows and constraints	The batches and their schedule

Incumbent platform

Key	Question	Why we ask
`network_name`	What is the network called?	It names the project and the migration workspace.
`filled_by`	Who answered, and in what role?	We know whom to ask about an answer.
`filled_on`	When were the answers written?	Inventories change; we re-check answers older than a few weeks.
`incumbent.platform`	Which platform do your chargers connect to today?	Each platform has its own charger URL format, export tools and quirks.
`incumbent.white_label`	Do drivers see your brand on another company's platform?	Your brand on driver pages, receipts and stickers has to carry over, and the platform owner may hold accounts or contracts in its own name.
`incumbent.portal_access`	What access do you have to its admin portal?	A read-only user lets us read charger configuration and session data without asking you for every detail.
`incumbent.api_access`	Does it offer an API, and is it documented?	An API or a location feed lets us import sites and chargers instead of typing them in.
`incumbent.ocpp_endpoint`	What address are chargers configured with today?	Chargers move by changing (or routing) this address; its hostname decides whether a proxy can sit in front of it.
`incumbent.remote_configuration`	Can you send configuration changes to chargers through it?	If yes, URLs and heartbeat settings change remotely; if not, someone has to visit or use the vendor's tools.
`incumbent.contract_end`	When does the contract end?	It sets the latest date every charger has to be moved and every export done.
`incumbent.notice_period_days`	How many days' notice does it need?	Notice given too late can mean paying for another term.
`incumbent.data_export_rights`	What does the contract say about exporting your data?	Session history, driver accounts and card lists are often needed for reporting and for drivers to keep charging.

Sites

inventory_file takes the whole per-connector inventory in the network import CSV template, if you already have it. Otherwise answer per site:

Key	Question	Why we ask
`inventory_file`	Do you have the inventory as the network import CSV?	It is imported directly, with a dry run you can review.
`sites[].ref`	What is your ID for the site?	It links the site across your systems, the import and later reports.
`sites[].name`	What do drivers call the site?	It is shown in apps, receipts and roaming maps.
`sites[].address`	What is the street address?	Drivers, roaming maps and field engineers find the site by it.
`sites[].city`	Which city?	Part of the address; some tax and reporting rules apply per city.
`sites[].state`	Which state or province?	Tax, pricing display and reporting rules differ per state.
`sites[].postal_code`	What is the postal code?	Part of the address; some tax lookups use it.
`sites[].country`	Which country?	Currency, tax and connector standards follow the country.
`sites[].latitude`	What is the latitude?	Maps and apps place the site by its coordinates.
`sites[].longitude`	What is the longitude?	Maps and apps place the site by its coordinates; a swapped sign puts it on another continent.
`sites[].time_zone`	Which time zone?	Time-of-use prices, quiet windows and receipts use local time.
`sites[].access`	Is the site public, restricted or private?	Private sites are not published to maps or roaming partners.
`sites[].opening_hours`	When can drivers reach it?	Moves are best done when the site is closed or quiet. Ivora locations do not store opening hours yet, so drivers keep seeing them in your own app or pages.
`sites[].chargers`	How many chargers are there?	Sizes the batches and checks the inventory.
`sites[].power_limit_kw`	Do the chargers share a power limit?	A shared limit needs load management on Ivora too, or breakers trip.
`sites[].host`	Who hosts the site?	The host may need notice before a move, and may own the network the chargers use.

Chargers

One entry per combination of vendor, model and firmware: chargers that share it behave the same.

Key	Question	Why we ask
`chargers[].vendor`	Who made the charger?	Vendors differ in configuration keys, firmware updates and support contacts.
`chargers[].model`	Which model?	Models of one vendor still differ in display, meter and payment options.
`chargers[].count`	How many of this model and firmware?	Sizes the work and tells us which model to try first.
`chargers[].firmware_version`	Which firmware version?	Firmware decides OCPP behaviour; some versions have known bugs or need an update before moving.
`chargers[].ocpp_version`	Which OCPP version do they speak (1.6, 2.0.1 or 2.1)?	Messages, configuration and card types differ between versions.
`chargers[].security_profile`	Which OCPP security profile do they use (0 to 3)?	It sets whether they send a password or a client certificate, and so how they sign in to Ivora.
`chargers[].password_known`	Do you hold each charger's OCPP password?	OCPP passwords cannot be read back from a charger; without them the move has to set new ones.
`chargers[].identity_format`	What do charger IDs look like?	The ID must match exactly, case included, or the charger is refused (Charger IDs).
`chargers[].backend_url_format`	How does the charger build its server URL?	Some append their ID to the URL and some expect it already in it; a wrong format means a charger that never connects.
`chargers[].url_config_key`	Which configuration key holds that URL?	That is the key the move changes, or the one we read to check it.
`chargers[].heartbeat_interval_s`	Which heartbeat interval is configured?	Chargers that stay quiet too long are disconnected (Keep the connection alive); cellular chargers often use a longer interval to save data.
`chargers[].connectors`	Which connectors does each charger have?	Drivers, tariffs and roaming partners see each connector.
`chargers[].power_type`	AC single-phase, two-phase, split-phase, three-phase, or DC?	Pricing, power limits and reporting differ.
`chargers[].max_power_kw`	What is the maximum power?	Shown to drivers, and needed for load management.
`chargers[].display`	What can the screen show: nothing, status, free text or a price?	Decides whether the charger can show a payment QR, messages or the running cost (Charger displays).
`chargers[].display_languages`	Which languages must the screen show?	Ivora writes the screen price text in English only; other languages need a plan before the move.
`chargers[].california_pricing`	Does it support the California Pricing OCPP 1.6 extension?	Where the price has to be on the screen, chargers without it need another way to show it (Running cost).
`chargers[].connectivity`	Cellular, Wi-Fi or Ethernet?	Each has its own owner and its own limits on what the charger can reach.
`chargers[].local_access`	How is it configured on site: installer app, web page or vendor portal?	If the URL cannot be changed remotely, this is how it is changed, and by whom.
`chargers[].known_issues`	What problems have you seen: reboots, lost sessions, wrong meter readings, clock drift?	Known quirks get a check before the move, instead of a surprise after it.

Network and SIMs

Key	Question	Why we ask
`network.sim_provider`	Which carrier or IoT provider supplies the SIMs?	SIM settings can block new addresses; we need to know whom to call.
`network.sim_owner`	Who owns the SIM contracts: you, the incumbent, the charger vendor or the installer?	SIMs owned by the incumbent can stop working when its contract ends.
`network.sim_contract_end`	When does the SIM contract end?	Chargers lose their connection when it does.
`network.private_apn`	Do the SIMs use a private APN?	A private APN often allows only listed addresses, so Ivora's address has to be added before any charger moves.
`network.ip_allow_list`	Is there an allow-list or firewall between the chargers and the internet, and who changes it?	Chargers cannot reach Ivora until it allows Ivora's addresses.
`network.site_networks`	Who runs the site Wi-Fi or Ethernet, and what may leave it?	Site IT teams often allow only known destinations and need notice.
`network.fixed_addresses`	Do any chargers use a fixed IP address instead of a hostname?	A fixed address cannot follow a move; those chargers need their configuration changed.

Payments and terminals

Key	Question	Why we ask
`payments.processor`	Which processor takes card payments today: Stripe, Braintree, another, or none?	It decides the settlement flow and what can move.
`payments.processor_other`	If another, which one?	Each processor has its own move steps.
`payments.merchant_account_owner`	Whose merchant account is it: yours or the incumbent's?	Payments on your own account can keep their history; payments on the incumbent's account need a new account.
`payments.payment_methods`	How do drivers pay: app, web QR, terminal, RFID account, roaming, free?	Every method must still work on the day each charger moves.
`payments.authorization_hold`	How much is held before a session, and when is it released?	Drivers notice a different hold; the amount carries over to the new checkout.
`payments.payouts`	Who pays you, how often, and which fees are deducted?	Payouts must not stop or double during the move.
`payments.terminals[].vendor`	Who makes the payment terminals?	Terminals talk to their own vendor's service, which has to know about the new platform.
`payments.terminals[].model`	Which model?	Models differ in how they are wired to the charger.
`payments.terminals[].count`	How many?	Sizes the work.
`payments.terminals[].placement`	Built in, one per EVSE, one per charger, or a site kiosk?	Decides which charger and connector a payment starts.
`payments.terminals[].evse_link`	How does a payment reach its charger: through the charger, through the incumbent's platform, or standalone?	A terminal tied to the incumbent's platform stops starting sessions when its charger moves, unless it is moved too.
`payments.terminals[].contract_owner`	Who holds the terminal contract?	Only the contract owner can reconfigure the terminals.
`payments.terminals[].connectivity`	Does the terminal use its own SIM, the charger's connection or the site network?	It has the same reachability questions as the chargers.

Drivers and RFID

Key	Question	Why we ask
`drivers.app`	Which app do drivers use: the incumbent's, a white-label app, your own, or none?	Drivers of the incumbent's own app lose it when chargers move and need to be told what to use.
`drivers.accounts`	How many driver accounts are there?	Sizes the driver communication and any account move.
`drivers.active_accounts_90_days`	How many charged in the last 90 days?	These are the drivers who notice a change.
`drivers.stored_payment_methods`	Do drivers keep cards on file with the incumbent or its processor?	Stored cards usually cannot move; drivers must add them again.
`drivers.rfid_cards`	How many RFID cards are in use?	Every card must be imported before its charger moves, or it is refused.
`drivers.rfid_format`	What does a card value look like as the charger sends it (length, hex, case, byte order)?	The same card can be read in different formats; the token import must match what chargers send.
`drivers.rfid_issuer`	Who issued the cards, and who issues new ones?	New cards must keep working after the move.
`drivers.groups`	Are there fleets, members or other groups with their own price or free charging?	Each group needs its own tariff or authorization.
`drivers.subscriptions`	Do drivers pay for memberships or plans?	Running plans must be honoured or ended cleanly.
`drivers.roaming`	Which roaming hubs or partners publish your chargers?	Roaming drivers stop being able to charge unless the partners switch to Ivora (OCPI publishing).
`drivers.plug_and_charge`	Do any vehicles start by Plug & Charge today?	Plug & Charge needs certificates that do not move by themselves.

Pricing and tax

Key	Question	Why we ask
`pricing.currency`	Which currency?	Prices, receipts and payouts use it.
`pricing.tariffs[].applies_to`	Which sites, chargers or driver groups pay this price?	Each tariff is attached to connectors or groups.
`pricing.tariffs[].energy_per_kwh`	What is the price per kWh?	Rebuilt as a tariff before the first session on Ivora, or sessions are not priced.
`pricing.tariffs[].per_hour`	Is there a price per hour of charging?	Time prices bill differently from energy prices; some chargers also show them differently on screen.
`pricing.tariffs[].session_fee`	Is there a fee per session?	A flat fee changes the hold, the receipt and the price shown before charging.
`pricing.tariffs[].time_of_use`	Do prices change by time of day or day of week?	Needs time restrictions in the tariff, in the site's time zone.
`pricing.tariffs[].limits`	Is there a minimum or maximum session price?	A maximum becomes the tariff's session cost cap; Ivora tariffs have no minimum session price, so a minimum needs a decision before the move.
`pricing.idle_fee`	Is there an idle fee: rate, grace period and cap?	Drivers dispute idle fees most. Ivora bills idle time as PARKING_TIME, with an idle grace counted from when charging ends; we tell you before the move where your current rules differ.
`pricing.tax`	Where is tax charged, at which rates, and who files it?	Configured per location as tax lines; you stay the seller.
`pricing.prices_include_tax`	Do posted prices include tax?	Changes every price shown and billed.
`pricing.screen_price_required`	Does a rule require the price on the charger screen?	Some states require it at the charger; it decides which chargers need the price pushed to their screen.
`pricing.receipts`	What must a receipt show, and who sends it?	Receipts carry your brand and any legally required fields.

QR stickers

Key	Question	Why we ask
`qr.stickers`	Do chargers carry QR stickers?	A sticker that points at the old platform strands drivers after a move.
`qr.count`	How many?	Sizes the sticker import.
`qr.per`	One per charger, per EVSE or per site?	Decides how scans map to chargers.
`qr.url_example`	What URL does one sticker encode, exactly?	Ivora answers the scans by recognising this URL (QR sticker redirects).
`qr.hostname_owner`	Who controls the sticker's hostname: you or the incumbent?	If you control it, scans can come to Ivora without new stickers.
`qr.replace_allowed`	May new stickers be put up?	If not, the existing stickers have to keep working for good.

Data to export

Key	Question	Why we ask
`data_export.sessions_history`	How far back is the session history, in what format, and who can export it?	You keep reporting, refunds and disputes for sessions before the move.
`data_export.users`	Can driver accounts be exported, and in what format?	Decides whether drivers are moved or invited again.
`data_export.rfid_list`	Can the card list be exported with status and owner?	It is what the token import reads.
`data_export.invoices_and_payouts`	Can invoices and payout reports be exported?	Your accounting needs the history in one place.
`data_export.reporting_obligations`	Do you report charging or uptime data to a program or funder?	Reports must cover the whole period, across both platforms.
`data_export.retention`	How long does the incumbent keep your data after the contract ends, and how long must you keep history?	Exports must happen before the incumbent deletes your data, and must cover what you are required to keep.

Contacts

Key	Question	Why we ask
`contacts[].role`	What is the person's role: decision maker, technical, operations, payments, site host, installer, incumbent, SIM provider?	Each step needs a different person's yes or hands.
`contacts[].name`	Who is it?	So we ask the right person.
`contacts[].email`	How do we email them?	For planned work and reports.
`contacts[].phone`	How do we call them?	For anything urgent during a move.
`contacts[].hours`	When can they be reached, in which time zone?	Moves are planned when the right people are available.

Quiet windows

Key	Question	Why we ask
`quiet_windows.time_zone`	Which time zone are the windows in?	Avoids moving chargers an hour early or late.
`quiet_windows.allowed`	When may chargers be moved?	A charger is briefly unavailable while it moves; we move when the fewest drivers charge.
`quiet_windows.blackout_dates`	Which dates are off limits?	A charger out of service hurts most on events, holidays and peak days, so moves avoid them.
`quiet_windows.site_exceptions`	Do some sites have other windows?	Fleet depots and workplaces are busy at other hours than public sites.
`quiet_windows.reboots_allowed`	May chargers be rebooted inside the window?	Some changes only apply after a reboot.
`quiet_windows.on_site_visits`	What do field engineers need to get on site, and how much notice?	Chargers that cannot be changed remotely need a visit.

Constraints

Key	Question	Why we ask
`constraints.target_start`	When should the first chargers move?	Plans the pilot and the request.
`constraints.target_end`	By when must every charger be moved?	Usually set by the incumbent's contract end.
`constraints.must_not_change`	What must drivers or site hosts not notice?	Tells us what to test before each batch.
`constraints.regulatory`	Which rules or funding programs must the network keep meeting?	Some programs require uptime, pricing display or data reporting without gaps.
`constraints.uptime_commitments`	What uptime have you promised site hosts or funders?	Sets how many chargers may move at once and how fast to roll back.
`constraints.other`	Anything else we should know?	Whatever did not fit above.

Answers template

Copy this template into a file, answer in it and send it to your Ivora contact. It is YAML: keep the keys as they are, write text in quotes, numbers as numbers, true or false for yes and no, and copy a list item once per site, charger model, terminal model, tariff or contact. The comments list the expected values. format names the template version, so a later version can still read your answers.

# Ivora migration discovery answers.
# Questions, and why we ask each one: the "Migration discovery questionnaire" developer guide.
# Answer what you know. Write "unknown" rather than guessing; leave a value empty only when it
# does not apply. Copy a list item (sites, chargers, terminals, tariffs, contacts) once per entry.
# Never put passwords, API keys, card numbers or drivers' personal data in this file.
format: ivora-migration-discovery/1
network_name: ""
filled_by: ""                    # name and role of whoever answered
filled_on: ""                    # YYYY-MM-DD

incumbent:
  platform: ""                   # the platform your chargers connect to today
  white_label: null              # true if drivers see your brand on another company's platform
  portal_access: ""              # none | read_only_user | admin_user
  api_access: ""                 # none | documented | on_request
  ocpp_endpoint: ""              # the address chargers connect to today, as configured on a charger
  remote_configuration: null     # true if you can send ChangeConfiguration / SetVariables through it
  contract_end: ""               # YYYY-MM-DD
  notice_period_days: null
  data_export_rights: ""         # what the contract says about exporting your data

inventory_file: ""               # the per-connector list in the network import CSV template, if you have it

sites:
  - ref: ""                      # your own site ID
    name: ""
    address: ""
    city: ""
    state: ""
    postal_code: ""
    country: ""                  # ISO 3166-1 alpha-3, for example USA
    latitude: null
    longitude: null
    time_zone: ""                # IANA name, for example America/Los_Angeles
    access: ""                   # public | restricted | private
    opening_hours: ""            # 24/7, or the hours
    chargers: null               # number of chargers at the site
    power_limit_kw: null         # a site or circuit limit its chargers share, if any
    host: ""                     # who hosts the site (role; details under contacts)

chargers:                        # one item per vendor, model and firmware combination
  - vendor: ""
    model: ""
    count: null
    firmware_version: ""
    ocpp_version: ""             # 1.6 | 2.0.1 | 2.1
    security_profile: null       # 0 | 1 | 2 | 3
    password_known: null         # true if you hold each charger's OCPP password (never write it here)
    identity_format: ""          # charge point ID pattern, for example CP-0001; case matters
    backend_url_format: ""       # how the charger builds its URL, for example base URL + "/" + identity
    url_config_key: ""           # the configuration key that holds the URL, for example CentralSystemURL
    heartbeat_interval_s: null
    connectors: ""               # per charger, for example "2 x J1772" or "CCS1 + CHAdeMO"
    power_type: ""               # AC1Phase | AC2Phase | AC2PhaseSplit | AC3Phase | DC
    max_power_kw: null
    display: ""                  # none | status_only | text | price
    display_languages: []        # languages the screen must show, for example [en, es]
    california_pricing: null     # true if it supports the California Pricing OCPP 1.6 extension
    connectivity: ""             # cellular | wifi | ethernet
    local_access: ""             # installer app, web page or vendor portal that configures it on site
    known_issues: ""             # reboots, lost sessions, meter or clock quirks you have seen

network:
  sim_provider: ""               # carrier or IoT SIM provider
  sim_owner: ""                  # you | incumbent | charger_vendor | installer
  sim_contract_end: ""           # YYYY-MM-DD
  private_apn: null              # true if the SIMs use a private APN
  ip_allow_list: ""              # allow-lists or firewalls between chargers and the internet, and who changes them
  site_networks: ""              # site Wi-Fi or Ethernet: who runs it, and its outbound rules
  fixed_addresses: ""            # chargers that pin IP addresses or cannot resolve DNS names

payments:
  processor: ""                  # stripe | braintree | other | none
  processor_other: ""            # its name, when processor is other
  merchant_account_owner: ""     # you | incumbent
  payment_methods: []            # app, web_qr, terminal, rfid_account, roaming, free
  authorization_hold: ""         # the amount held before a session, and when it is released
  payouts: ""                    # who pays you, how often, and which fees are deducted
  terminals:                     # one item per terminal vendor and model; leave empty if none
    - vendor: ""
      model: ""
      count: null
      placement: ""              # built_in | one_per_evse | one_per_charger | site_kiosk
      evse_link: ""              # through_charger | through_incumbent | standalone
      contract_owner: ""         # you | incumbent | charger_vendor | terminal_vendor
      connectivity: ""           # own_sim | charger | site_network

drivers:
  app: ""                        # incumbent_app | white_label_app | your_own_app | none
  accounts: null
  active_accounts_90_days: null
  stored_payment_methods: null   # true if drivers keep cards on file with the incumbent or its processor
  rfid_cards: null
  rfid_format: ""                # for example "7-byte UID, 14 hex digits, uppercase, as the charger sends it"
  rfid_issuer: ""                # who issued the cards, and who issues new ones
  groups: ""                     # fleets, members, employees, free or discounted groups
  subscriptions: ""              # memberships or plans drivers pay for
  roaming: []                    # roaming hubs or partners your chargers are published to
  plug_and_charge: null          # true if any vehicle starts by Plug & Charge today

pricing:
  currency: ""                   # ISO 4217, for example USD
  tariffs:                       # one item per distinct price
    - applies_to: ""             # which sites, chargers or driver groups
      energy_per_kwh: null
      per_hour: null
      session_fee: null
      time_of_use: ""            # peak and off-peak hours, if any
      limits: ""                 # minimum or maximum session price
  idle_fee: ""                   # rate, grace period and cap
  tax: ""                        # jurisdictions, rates, and who files
  prices_include_tax: null
  screen_price_required: null    # true if a rule requires the price on the charger screen
  receipts: ""                   # what a receipt must show, and who sends it

qr:
  stickers: null                 # true if chargers carry QR stickers
  count: null
  per: ""                        # charger | evse | site
  url_example: ""                # one sticker's URL, exactly as encoded
  hostname_owner: ""             # you | incumbent: who controls the sticker's hostname
  replace_allowed: null          # true if new stickers may be put up

data_export:
  sessions_history: ""           # how far back, format (CSV, API), who can export it
  users: ""                      # driver accounts: allowed to export, format
  rfid_list: ""                  # card values, status and owner, format
  invoices_and_payouts: ""
  reporting_obligations: ""      # programs you report charging or uptime data to
  retention: ""                  # how long the incumbent keeps your data after the contract ends, and how long you must keep history

contacts:                        # one item per person; keep this file private
  - role: ""                     # decision_maker | technical | operations | payments | site_host | installer | incumbent | sim_provider
    name: ""
    email: ""
    phone: ""
    hours: ""                    # time zone and hours they can be reached

quiet_windows:
  time_zone: ""                  # IANA name
  allowed: ""                    # when changes may happen, for example Tue-Thu 22:00-05:00
  blackout_dates: ""             # events, holidays, peak days
  site_exceptions: ""            # sites with other windows
  reboots_allowed: null          # true if chargers may be rebooted inside the window
  on_site_visits: ""             # access rules and notice for field engineers

constraints:
  target_start: ""               # YYYY-MM-DD
  target_end: ""                 # YYYY-MM-DD
  must_not_change: ""            # what drivers or site hosts must not notice
  regulatory: ""                 # rules or funding programs the network must keep meeting
  uptime_commitments: ""         # uptime promised to site hosts or funders
  other: ""

format is ivora-migration-discovery/1. A later version adds keys and keeps these, so a version 1 file stays readable; a key that changes meaning gets a new version.