GITNUXSOFTWARE ADVICE
Top 10 Best Online Taxi Booking System Software of 2026
Top 10 ranking of online taxi booking system software with technical comparisons for fleets and operators, covering Onde, Autocab, and iCabbi.
How we ranked these tools
Core product claims cross-referenced against official documentation, changelogs, and independent technical reviews.
Analyzed video reviews and hundreds of written evaluations to capture real-world user experiences with each tool.
AI persona simulations modeled how different user types would experience each tool across common use cases and workflows.
Final rankings reviewed and approved by our editorial team with authority to override AI-generated scores based on domain expertise.
Score: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Onde
Event-driven booking lifecycle updates via API and webhook contracts that map cleanly to dispatch actions.
Built for fits when dispatch teams need API-driven automation plus governance for multi-channel bookings..
Autocab
Editor pickAPI-driven booking lifecycle automation tied to structured trip and status entities.
Built for fits when transport teams need API-first booking automation with strict state control..
iCabbi
Editor pickDispatch and booking status transitions modeled for automation and reconciliation via integration points.
Built for fits when dispatch teams need API-based automation and governed configuration across multiple vehicle and service types..
Comparison Table
Onde
vertical specialistWhite-label ride-hailing dispatch platform with passenger and driver apps.
Event-driven booking lifecycle updates via API and webhook contracts that map cleanly to dispatch actions.
Onde models core entities such as rider request, booking lifecycle states, driver availability, and geospatial pickup and dropoff points. The integration depth is strongest where external apps push booking requests and where dispatch updates flow back through API calls and webhooks. Automation is oriented around state transitions, including acceptance, assignment, cancellation, and completion events.
A practical tradeoff is that the automation and schema alignment require upfront configuration of booking states, routing rules, and notification contracts. Onde fits best when a team already runs booking intake through multiple channels such as apps, call center tooling, or partner integrations and needs consistent governance and audit visibility.
- +Trip, driver, and location schema supports consistent booking state transitions
- +API and webhook event model supports automation without manual re-entry
- +Admin RBAC style permissions separate dispatch, operations, and reporting access
- +Audit log tracks operational changes that affect bookings and assignments
- –State and rule configuration takes time to align with existing operations
- –Geofencing and routing behavior depends on accurate location payloads
- –Complex multi-channel workflows require careful idempotency handling
Dispatch operations teams
Automate acceptance and assignment workflows
Fewer manual handoffs
Integration engineering teams
Provision bookings from external systems
Lower integration drift
Show 2 more scenarios
Customer operations teams
Handle cancellations and reroutes
Faster resolution cycles
Triggers automated lifecycle transitions and notifies upstream systems when status changes.
Compliance and admin teams
Audit assignment and config changes
Clear accountability trails
Maintains audit log trails for role-scoped operational updates that affect booking outcomes.
Best for: Fits when dispatch teams need API-driven automation plus governance for multi-channel bookings.
Autocab
enterpriseTaxi booking and dispatch system used by fleets across the United Kingdom.
API-driven booking lifecycle automation tied to structured trip and status entities.
Autocab fits organizations that need booking throughput with controlled state changes from request capture to trip completion. The integration depth shows up in its API and automation hooks that connect booking, dispatch, and back-office systems through consistent identifiers. Autocab’s data model organizes core entities like bookings, drivers, vehicles, and service rules so downstream systems can map events deterministically. Governance controls and operational visibility support multi-role teams that run concurrent markets or fleets.
A tradeoff appears in implementation effort because deeper configuration requires careful schema mapping and state transition alignment across connected services. Autocab works best when automation must enforce policy at booking time, such as service eligibility rules, allocation triggers, and status-driven messaging to external systems. Usage also favors teams that already maintain internal dispatch or customer-care tooling and need extensibility without manual exports.
- +API supports booking, dispatch, and status-driven automation workflows
- +Structured data model for trips, drivers, vehicles, and service rules
- +RBAC-style governance supports multi-role operational control
- +Configuration-oriented approach improves determinism for integrations
- –Deeper configuration increases onboarding time for integration teams
- –Requires careful schema mapping for external systems and event handlers
- –Workflow tuning can demand domain knowledge of booking states
Dispatch operations teams
Automate booking-to-assignment state transitions
Fewer manual handoffs
Integration engineers
Sync bookings with internal systems
Deterministic data sync
Show 2 more scenarios
Multi-market administrators
Enforce service rules across fleets
Reduced operational drift
Apply configuration and governance controls to keep policy consistent per market.
Customer support operations
Trace bookings through lifecycle states
Faster resolution cycles
Use status-linked operational data to verify what changed and when for each booking.
Best for: Fits when transport teams need API-first booking automation with strict state control.
iCabbi
enterpriseCloud taxi dispatch platform serving fleets in Ireland and international markets.
Dispatch and booking status transitions modeled for automation and reconciliation via integration points.
iCabbi’s core strength is integration and automation around dispatch state, since bookings and driver assignments map to explicit status transitions in the data model. iCabbi is designed for extensibility through API-connected processes, which reduces manual re-entry when routing, availability, or pricing rules change. Configuration supports multi-asset operations by separating vehicle and service parameters from booking records, which helps keep schema changes controlled across deployments. The operational fit is strongest when the organization already tracks orders, dispatch steps, and fulfillment events in systems that need reconciliation.
A tradeoff appears with higher integration setup effort, because maintaining consistency between external order systems and iCabbi’s booking lifecycle depends on disciplined event mapping. iCabbi works best when an integration can push updates in near real time, such as confirmations, cancellations, and driver assignment outcomes, and when governance controls define who can change configuration and dispatch rules. Usage becomes less efficient if operations require frequent one-off schedule edits without automation hooks, since those changes still need to propagate through the same workflow.
- +API-driven booking and dispatch lifecycle integration
- +Clear data model for vehicles, services, and assignment states
- +Automation-friendly provisioning for operational workflows
- +Governance controls that support auditability of changes
- –External system event mapping adds integration overhead
- –Configuration changes require careful change control
- –Complex workflows can increase admin setup time
- –Some automation depends on near real-time syncing
Taxi agencies and dispatch teams
Dispatch automation across booking lifecycle
Fewer manual updates and errors
Travel ops integrators
Connect booking flows to ERP
Reduced duplicate order handling
Show 2 more scenarios
Multi-location mobility operators
Govern configuration across sites
Controlled changes and audit trail
Vehicle and service schemas support consistent rules while role-based controls restrict edits.
Customer care and operations QA
Track and audit booking changes
Faster incident resolution
Audit log and configuration governance help isolate when and how booking state changed.
Best for: Fits when dispatch teams need API-based automation and governed configuration across multiple vehicle and service types.
TaxiCaller
SMBTaxi dispatch and booking system with passenger, driver, and dispatcher applications.
Audit logging for booking state changes plus configuration edits tied to user identities.
TaxiCaller is an online taxi booking system focused on operational control for dispatch workflows. The system centers on a structured data model for bookings, assignments, and status changes that can feed third-party integration points.
TaxiCaller supports automation through configurable rules and exposes integration surfaces via API for provisioning and event-driven updates. Admin governance includes role-based access control and audit logging so changes to bookings and configuration remain traceable.
- +API-driven booking and status updates for dispatch integrations
- +Configurable automation around assignment and customer communication events
- +RBAC controls for booking management and configuration administration
- +Audit log coverage for booking edits and administrative actions
- –Automation tuning can require careful mapping between statuses and rules
- –Integration depth varies by external system when bridging legacy dispatch data
- –Admin configuration screens can feel dense for small operations
- –Throughput under peak volume depends on external callback and polling patterns
Best for: Fits when dispatch teams need API-led booking automation with RBAC and audit trails across multiple channels.
CabStartup
SMBTaxi dispatch software offering booking apps, driver apps, and admin panels.
Event-driven API for provisioning bookings and updating ride lifecycle state with configurable status schemas.
CabStartup provides an end-to-end booking flow with ride status updates that map to dispatch and fulfillment operations.
Integration depth is driven by an API and automation surface that can carry booking events and operational state changes between systems.
The data model uses schemas for bookings, drivers, and fleet entities so configuration and governance rules can be applied consistently.
- +API-based booking and lifecycle event integration
- +Configurable booking statuses for dispatch governance
- +RBAC-style admin separation for operational control
- +Automation hooks for status updates and fleet changes
- –Integration effort rises with custom routing and SLA rules
- –Operational configuration needs careful schema mapping
- –Reporting depth depends on how events are instrumented
- –Sandbox-based API validation is limited for complex workflows
Best for: Fits when dispatch teams need API-driven booking workflows with governed roles and auditable operational state changes.
Gazoop
SMBCloud-based taxi dispatch system with online booking and fleet management features.
API-based event flow that maps booking and dispatch lifecycle states to operational automation.
Gazoop is a taxi booking system built around route and dispatch workflows that connect riders, drivers, and operations in one data model. Its integration depth comes from an API and automation surface that supports event-driven booking and dispatch flows.
Admin controls focus on configuration, provisioning, and role boundaries so operations can manage behavior without code changes. Extensibility is oriented around schema-aligned entities like vehicles, availability, and booking states.
- +API-first dispatch flows with booking state transitions
- +Configurable operational rules for availability and assignment
- +Clear entity model for vehicles, riders, drivers, and trips
- +Automation hooks that reduce manual back-office steps
- –Admin configuration can require careful schema and state planning
- –Automation coverage gaps appear for edge cases like partial cancellations
- –Audit and governance depth for RBAC and retention is less transparent
- –Throughput tuning requires more integration work than expected
Best for: Fits when mid-size teams need an API-driven dispatch workflow with schema-aligned booking states.
Yelowsoft
SMBTaxi booking and dispatch software with white-label passenger and driver apps.
API-driven booking lifecycle events mapped to a configurable schema for dispatch, fare, and assignment orchestration.
Yelowsoft focuses on taxi booking operations with an automation-first data model rather than only dispatch screens. It supports route, fare, driver, and booking entities that can be configured into a consistent schema for real workflows.
The system is driven by an API and extensibility points that can connect dispatch, payment, and back-office services. Admin governance emphasizes role-based access, operational auditability, and controlled configuration changes across operations.
- +Configurable booking and dispatch data model for consistent operations
- +API surface supports integrations for drivers, vehicles, and fare logic
- +Automation rules reduce manual updates across booking lifecycle states
- +Role-based access and audit log support administrative governance
- –Schema configuration can require careful planning for new markets
- –Automation rules may need tuning to handle high throughput bursts
- –Extensibility requires API discipline and consistent event handling
- –Operational workflows can feel complex without a clear setup blueprint
Best for: Fits when multi-operator taxi fleets need API-driven booking automation with RBAC and audit log governance.
MoveInSync
enterpriseCorporate employee transport and taxi booking management platform.
Trip lifecycle event automation that syncs booking and driver assignment state changes to external systems via API.
MoveInSync is an online taxi booking system that focuses on operational control across dispatch, driver availability, and trip lifecycle events. The system’s integration depth shows up in its data model for bookings, fares, and driver assignments, plus automation hooks for state changes.
Configuration is oriented around governance controls like role-based access and audit visibility, which helps teams administer bookings at scale. Extensibility is driven through API and automation surfaces that map booking events into external workflows.
- +Event-driven trip lifecycle updates for downstream workflows
- +Data model covers bookings, assignments, and fare calculation inputs
- +RBAC and audit logging support admin governance workflows
- +API-first design enables integrations with existing dispatch tools
- –API and automation setup adds overhead for small fleets
- –State mapping complexity can surface during edge-case cancellations
- –Admin configuration breadth increases time-to-stable rollout
- –Sandbox and test tooling for high-throughput scenarios is limited
Best for: Fits when mid-size taxi operations need booking automation plus API-driven integration control.
Limo Anywhere
SMBBooking and dispatch software for limousine, black car, and taxi operators.
Trip status update endpoints that keep external dispatch systems synchronized in near real time.
Limo Anywhere provides online taxi booking workflows that route request intake through configurable booking, driver assignment, and dispatch operations.
The system supports an integration-oriented data model built around trips, customers, vehicles, rates, and scheduling rules.
Integration depth comes from its API and automation surface, which can feed bookings, update trip status, and synchronize data with external dispatch, fleet, and payment components.
Admin controls cover configuration management and operational governance needed to run high-throughput booking and dispatch.
- +API-driven trip and status synchronization with external systems
- +Configurable booking and dispatch rules tied to a clear trip model
- +Admin configuration and operational governance for live operations
- +Workflow automation reduces manual re-keying during dispatch
- –RBAC granularity and role controls are not clearly surfaced
- –Automation endpoints may require custom integration logic
- –Rate and availability rule modeling can become complex
- –Audit log detail level is limited for deeper compliance needs
Best for: Fits when dispatch teams need an API-backed booking workflow and tight control over trip lifecycle.
Curb
enterpriseTaxi fleet technology platform providing booking apps and dispatch tools for cab operators.
Event-based booking status transitions that integrate with dispatch automation and downstream systems.
Curb is an online taxi booking system software solution that centers scheduling, dispatch, and fare capture in a single operational workflow. Integration depth relies on a documented data model for bookings, driver assignments, and status transitions, which reduces ambiguity during API-based operations.
Automation and extensibility show up through configurable rules for state changes and event handling that keep dispatch throughput predictable. Admin and governance controls focus on operator permissions and traceability through audit-ready operational logs.
- +Clear booking lifecycle states that map cleanly to API events
- +Automation rules for assignment and status changes reduce manual dispatch work
- +Permissioned admin workflows support controlled operational roles
- +Event-driven integration model supports high booking throughput
- –Fewer deep customization hooks for pricing and trip metadata shaping
- –API surface requires careful mapping of internal status codes
- –Governance controls feel more operational than schema governance
- –Less visibility tooling than enterprise control rooms for multi-region operations
Best for: Fits when dispatch teams need API-based booking lifecycle control with auditable operations.
How to Choose the Right online taxi booking system software
This buyer’s guide covers how to evaluate online taxi booking system software using integration depth, data model fit, automation and API surface, and admin and governance controls across Onde, Autocab, iCabbi, TaxiCaller, CabStartup, Gazoop, Yelowsoft, MoveInSync, Limo Anywhere, and Curb.
It focuses on concrete mechanisms like event-driven booking lifecycle updates via API and webhooks, RBAC-style operational permissions, audit logging for booking and configuration changes, and the way trip state transitions map into external dispatch workflows.
Dispatch and booking platforms that run taxi trip state end-to-end over online channels
Online taxi booking system software coordinates passenger intake, driver assignment, and trip lifecycle state transitions across passenger apps, driver apps, and dispatcher consoles.
These tools solve the operational problem of keeping booking statuses, assignments, and fare inputs consistent across channels and external systems using an API and event-driven automation. Tools like Onde and Autocab illustrate how a structured trips, drivers, and locations data model plus API-driven booking lifecycle automation can keep state changes deterministic for dispatch teams.
Evaluation criteria for taxi booking systems built for integration and governance
The strongest selection signals show up in how booking lifecycle events travel through the system and how the data model enforces correct state transitions.
These areas matter because dispatch workflows break when external systems receive inconsistent status codes, when automation cannot be made idempotent, or when admin edits lack traceability.
Event-driven booking lifecycle updates with API and webhooks
Onde maps booking lifecycle events to dispatch actions through API and webhook contracts so external channels can react to state changes without manual re-entry. Autocab and iCabbi also tie automation to structured booking and status entities, which reduces mismatches during lifecycle transitions.
Trip, driver, vehicle, and location data model aligned to state transitions
Onde’s operations model centers trips, drivers, and locations to support consistent booking state transitions across channels. Autocab, iCabbi, and Gazoop use structured schema for trips, drivers, vehicles, and booking status controls, which makes external integration and reconciliation more predictable.
API surface for provisioning and lifecycle automation endpoints
CabStartup exposes an event-driven API for provisioning bookings and updating ride lifecycle state using configurable status schemas. TaxiCaller, Gazoop, MoveInSync, and Curb provide API-driven booking and status updates that reduce dispatcher re-keying when dispatch throughput rises.
Automation configuration that can be tuned for booking and dispatch rules
TaxiCaller supports configurable automation rules around assignment and customer communication events, which helps integrate operational behavior into status workflows. Yelowsoft and Gazoop emphasize configurable booking and dispatch data models plus automation rules for availability and assignment, which supports consistent orchestration when workflows are standardized.
RBAC-style admin governance for operational roles
Onde separates operational access using RBAC-style permissions for dispatch, operations, and reporting access, which helps multi-channel teams keep controls narrow. Autocab and iCabbi also include role-based governance tools so different operational teams can manage booking and dispatch behavior without shared admin permissions.
Audit log coverage for booking edits and operational configuration changes
TaxiCaller provides audit logging tied to user identities for booking state changes and configuration edits, which supports traceability during operational incidents. Onde tracks operational changes that affect bookings and assignments, and iCabbi emphasizes auditability for booking and dispatch changes.
Choose a taxi booking system by validating state, events, and admin control before integration
A correct selection starts with mapping the dispatch lifecycle into the tool’s booking status model and then checking that API events reflect those transitions with clear contracts.
The next step is confirming governance controls so booking edits, configuration changes, and automation behavior remain traceable to identities and roles like dispatch, operations, and reporting.
Map internal booking states to the vendor’s lifecycle entities and status transitions
Compare how Onde structures trips, drivers, and locations for consistent booking state transitions so the same lifecycle events remain consistent across channels. For strict state control with transport workflows, validate Autocab’s structured trip and booking status entities and ensure external systems can map internal codes cleanly.
Test event delivery paths for idempotency and ordering across channels
If multiple systems consume the same events, validate that Onde’s event-driven booking lifecycle updates and webhook contracts can be handled safely when retries occur. For high throughput event flows, confirm that Curb and Gazoop deliver booking status transitions in a way that supports predictable assignment automation during peak bursts.
Verify the API surface covers provisioning and the operational changes dispatch needs
Ensure CabStartup’s provisioning endpoints and ride lifecycle update endpoints cover the operational events required for booking intake and assignment. Validate TaxiCaller’s API-driven booking and status updates for assignment and configuration events, and confirm the same operational triggers exist for downstream customer communication.
Validate governance controls before giving access to dispatch and configuration administrators
Check that Onde exposes RBAC-style role separation for dispatch, operations, and reporting access so teams cannot change reporting assumptions through operational settings. Confirm TaxiCaller audit logging tied to user identities and require iCabbi-style auditability so booking and dispatch changes remain traceable during reconciliation.
Stress the configuration and schema alignment work early using representative scenarios
Plan for schema mapping effort because iCabbi, Autocab, and Gazoop require careful mapping of external event handlers to internal booking and assignment states. Where complex routing and SLA rules exist, allocate time for integration effort and workflow tuning in tools like Onde and CabStartup so state mapping and automation rules stabilize before live operations.
Which teams should adopt taxi booking systems built around API automation and governed operations
Online taxi booking systems fit teams that need predictable dispatch outcomes and synchronized trip lifecycle state across apps and external services. The best fit depends on how much integration work is required to align status codes, events, and administrative governance.
Dispatch teams running multi-channel operations that require event contracts
Onde fits teams that need API-driven automation plus governance for multi-channel bookings because it emphasizes event-driven booking lifecycle updates via API and webhooks. TaxiCaller also fits because it pairs API-led booking automation with RBAC controls and audit logs for booking state changes and configuration edits.
Transport-focused fleets that require strict booking and status state control
Autocab fits transport teams that need API-first booking automation with strict state control because it centers structured schema for trips, fares, and booking status transitions. iCabbi fits fleets that need governed configuration across multiple vehicle and service types using modeled dispatch and booking status transitions for automation and reconciliation.
Mid-size operations integrating dispatch with external trip workflows via automation
MoveInSync fits mid-size taxi operations that need trip lifecycle event automation syncing booking and driver assignment state changes via API. Gazoop fits when schema-aligned booking states and API-first dispatch flows matter, especially when availability and assignment rules must run through the same entity model.
Multi-operator fleets that need role governance and auditable operational state edits
Yelowsoft fits multi-operator fleets that need API-driven booking automation with RBAC and audit log governance because it maps booking lifecycle events into a configurable schema. TaxiCaller also fits because it provides RBAC controls plus audit log coverage tied to user identities for booking edits and administrative actions.
Operators that need near real-time synchronization of trip status to external dispatch components
Limo Anywhere fits dispatch teams that need trip status update endpoints to keep external systems synchronized in near real time. Curb fits when event-based booking status transitions must integrate with downstream dispatch automation while audit-ready operational logs support controlled roles.
Common failure points when integrating taxi booking systems into dispatch workflows
Taxi booking projects fail most often when status mapping and automation rules are treated as configuration afterthoughts. They also fail when governance and auditability requirements arrive late in the implementation timeline.
Assuming booking state mapping will be automatic across external systems
Treat schema mapping as an engineering task because iCabbi, Autocab, and TaxiCaller require careful mapping between external systems and booking states or event handlers. Validate the mapping using representative booking states early so retries and cancellations do not create inconsistent assignments.
Underestimating automation tuning work for routing, rules, and edge-case cancellations
Allocate time for workflow tuning because Onde and TaxiCaller require careful alignment of state and rule configuration to existing operations. Plan for edge-case behavior because Gazoop and MoveInSync can surface complexity for partial cancellations and state mapping.
Giving broad admin permissions without role separation and audit traceability
Require RBAC-style role separation and audit logging before going live since Onde provides RBAC-style permissions and audit logging for operational changes that affect bookings and assignments. TaxiCaller also ties audit log coverage to booking edits and administrative actions so identities remain traceable.
Choosing a system that lacks the automation endpoint coverage needed for provisioning and lifecycle updates
Confirm that booking provisioning and lifecycle state updates exist via the documented API for operational actions. CabStartup and Curb emphasize event-driven APIs and event-based status transitions, while tools with thinner endpoint coverage may force custom integration logic that increases fragility.
Ignoring throughput behavior when callbacks and polling patterns affect live dispatch
Validate throughput under peak booking volumes because TaxiCaller notes throughput dependence on external callback and polling patterns. For high-throughput event flows, validate Curb’s event-based status transitions and Onde’s event-driven dispatch actions so processing remains predictable under load.
How We Selected and Ranked These Tools
We evaluated Onde, Autocab, iCabbi, TaxiCaller, CabStartup, Gazoop, Yelowsoft, MoveInSync, Limo Anywhere, and Curb using features coverage, ease of use, and value, then computed an overall rating as a weighted average where features carry the most weight at forty percent while ease of use and value each account for thirty percent. Each score reflects how well the platform’s data model, automation and API surface, and governance mechanisms support booking and dispatch lifecycle execution rather than isolated screens.
Onde set apart from lower-ranked tools because it delivers event-driven booking lifecycle updates via API and webhook contracts that map cleanly to dispatch actions. That strength directly lifted the features score around automation and integration depth, and it also supported high ease-of-use outcomes since dispatch teams can drive state changes through contract-based events instead of manual re-entry.
Frequently Asked Questions About online taxi booking system software
Which taxi booking systems provide an API surface built for event-driven booking lifecycle automation?
What differences matter most between Onde and iCabbi for multi-channel dispatch workflows?
How do these platforms handle RBAC and audit logs for admin changes to bookings and dispatch configuration?
What data migration steps usually reduce risk when switching from one taxi booking system to another?
Which platforms support schema-aligned extensibility so teams can add vehicles, availability, and booking states without rebuilding dispatch logic?
How do booking and dispatch platforms synchronize driver availability with trip state updates?
Which system design is better for high-throughput throughput where route assignment and status updates must remain consistent?
What integration pattern works best for third-party systems that need provisioning and confirmations through API calls?
Which platform is most suitable for managing multiple vehicle and service types with governed configuration?
Conclusion
After evaluating 10 tools, Onde stands out as our overall top pick — it scored highest across our combined criteria of features, ease of use, and value, which is why it sits at #1 in the rankings above.
Use the comparison table and detailed reviews above to validate the fit against your own requirements before committing to a tool.
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
- Transportation LogisticsTop 10 Best Online Taxi Booking Software of 2026
- Transportation VehiclesTop 10 Best On Demand Taxi Software of 2026
- Travel TourismTop 10 Best Online Air Ticket Booking Software of 2026
- TelecommunicationsTop 10 Best Taxi App Development Services of 2026
- Tourism HospitalityTop 10 Best Online Booking Services of 2026
Keep exploring
Comparing two specific tools?
Software Alternatives
See head-to-head software comparisons with feature breakdowns, pricing, and our recommendation for each use case.
Explore software alternatives→Need a personal recommendation?
Software Advisory Service
Skip months of vendor evaluation. Our analysts recommend the right tool for your business in 2–4 weeks.
Talk to an analyst →