ForHosting KIT · Developer Utilities

Check itinerary time conflicts and overlapping activities

The itinerary time conflict checker reviews a list of planned activities and identifies every pair that occupies the same time.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

Add each activity with a name, start time, and end time in 24-hour HH:MM format. The result shows whether conflicts exist, how many were found, which activities collide, and the exact shared time window. It also rejects an activity whose end is earlier than its start, preventing an invalid schedule from producing misleading conflict results.

Enter a clear same-day itinerary

Give every activity a useful name and enter its start and end in 24-hour HH:MM format. The checker treats all entries as belonging to the same day, which makes it well suited to a sightseeing plan, conference agenda, day trip, group tour, or travel-day checklist. Use names that remain recognizable in the result, especially when several bookings have similar times. For example, “Museum guided tour” is more useful than “Tour” when the conflicting item is “Old Town walking tour.” The input order does not need to be chronological. The checker compares all pairs and retains each activity’s original zero-based index, so an automated system can connect a reported conflict to the submitted record without guessing. An end time may equal its start time; that represents an activity with no duration and creates no overlap. An overnight activity is outside this capability’s same-day model because an end such as 01:00 after a start at 23:00 appears reversed. Split overnight plans by date or use explicit dated scheduling before checking them here.

Understand exactly what counts as a conflict

Two activities conflict only when they share a positive amount of time. If a museum visit ends at 11:00 and lunch begins at 11:00, they touch at the boundary but do not overlap. If lunch begins at 10:59, the pair conflicts for one minute. For every collision, the output identifies both activity names and indexes, the start and end of their shared window, and the overlap length in minutes. This pair-based reporting is deliberately complete: when three activities occupy the same period, the result contains all three conflicting pairs rather than merging them into one vague block. That makes the answer useful for both people and software because each booking relationship can be reviewed independently. Conflicts are returned in deterministic input-pair order, not ranked by severity. An activity fully contained inside another is still one conflict, with the contained activity’s entire duration as the overlap window. Identical time ranges also conflict for their full duration. These rules match the practical question of whether attendance at both planned items is possible without being in two places during the same minute.

Fix invalid ranges and use the result

Before comparing activities, the checker validates every time. A value must have two hour digits, a colon, and two minute digits, using the 00:00 through 23:59 range. It also stops with an input error if any end time is earlier than its start time. That fail-fast behavior matters because silently treating a reversed range as overnight, empty, or automatically corrected could hide a booking mistake. Once the input is valid, start with `has_conflicts` for a simple workflow decision. Use `conflict_count` to summarize the schedule and inspect `conflicts` to show actionable details beside the original activities. A travel planner might ask the traveler to choose between each pair, while a spreadsheet or booking pipeline could flag the referenced indexes for revision. After changing the itinerary, submit the complete list again; a result with zero conflicts confirms that no positive-duration overlaps remain under the same-day rules. The calculation is deterministic, uses no network or current clock, and returns the same answer for the same ordered input. Browser use is free, while an automated API request uses the published base price of $0.002.

Review a sightseeing day

Check timed museum tickets, tours, meals, and transfers before committing to a packed day plan.

Validate a conference itinerary

Find sessions, meetings, and hosted events that compete for the same attendee’s time.

Add conflict checks to a planner

Use stable indexes and complete conflict pairs to flag itinerary records that need rescheduling.

What time format should I use?

Use 24-hour HH:MM values from 00:00 through 23:59, such as 09:30 or 18:05.

Do back-to-back activities conflict?

No. If one activity ends at the exact minute another starts, their intervals only touch and no conflict is reported.

What happens when an end time is before its start time?

The request fails with an invalid input error that identifies the activity position. The checker does not assume the activity continues overnight.

Will it report more than one conflict?

Yes. It returns every overlapping pair, including all pair combinations when three or more activities overlap.

Can I check activities on different dates?

Not directly. This capability compares same-day clock times. Group activities by date and check each day separately.

How much does the API request cost?

An API request uses the published base price of $0.002. The browser version can run the same deterministic check for free.

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

POSThttps://api.kit.forhosting.com/travel2/itinerary-time-conflict-check

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

curl -X POST https://api.kit.forhosting.com/travel2/itinerary-time-conflict-check \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"activities":[{"name":"Museum visit","start":"09:00","end":"11:00"},{"name":"Walking tour","start":"10:30","end":"12:00"}]}'
{
  "activities": [
    {
      "name": "Museum visit",
      "start": "09:00",
      "end": "11:00"
    },
    {
      "name": "Walking tour",
      "start": "10:30",
      "end": "12:00"
    }
  ]
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "travel2.itinerary_time_conflict_check",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →