ForHosting KIT · Developer Utilities

Create a calendar invite

A calendar invite that renders perfectly in one client and garbles the timezone in another isn't a rare bug — it's the default outcome of hand-building .ics text. This endpoint takes structured event details and returns a spec-correct file that every major calendar app can parse the first time.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

The invite nobody wants to debug

Booking confirmations, webinar reminders, appointment systems and course platforms all eventually need to hand a user a file they can add to their own calendar. The temptation is to string together a VEVENT block by hand, and it works — until a recurring event crosses a daylight-saving boundary, or a guest opens the file in a client that's strict about line folding and rejects the whole thing. dev.ical exists so that the file leaving your system is correct by construction, not correct until the next edge case.

What you send and what comes back

POST /dev/ical with the event title, start and end times, timezone, location, description and any attendees or recurrence rule, and the call returns a task_id immediately. The finished .ics file is delivered by a signed webhook call or held behind a signed link valid for 24 hours, so it fits into a queue-driven booking system just as easily as a one-off confirmation email sent right after checkout.

Why the format is stricter than it looks

The iCalendar format, defined in RFC 5545, has been the common language between calendar programs since the late 1990s, evolving out of the earlier vCalendar standard so that an invite created in one system could survive being opened in another. Its rules around timezone identifiers, line-folding at 75 octets, and escaping commas and semicolons inside text fields are exactly the parts developers get wrong when writing .ics by hand, and exactly the parts that make a file bounce in Outlook while looking fine in a text editor. Generating it programmatically removes that category of failure entirely.

Fitting into a larger booking or reminder flow

Because the task is async and billed per request, an appointment platform can generate an invite the instant a booking is confirmed, a webinar tool can produce one per registrant without slowing down the signup flow, and a recurring reminder system can regenerate updated invites whenever a schedule changes — all without a person watching the process. The output is just a file: attach it to an email, serve it from a download link, or hand it straight to whatever system triggers the send, and the calendar app on the other end does the rest correctly.

What you can do with it

Booking confirmation emails

An appointment scheduling app generates a .ics attachment the moment a client confirms a time slot, so the appointment lands directly on their calendar.

Webinar and event registration

A webinar platform creates a personalized invite per registrant, including the correct timezone conversion for each attendee's locale.

Recurring class or lesson reminders

An online course platform generates a recurring-event .ics file so students get one calendar entry that repeats weekly instead of a new invite every session.

Deadline and renewal notices

A SaaS billing system emits a calendar invite for a subscription renewal date so customers see it alongside their other commitments.

FAQ

How do I generate an .ics file with the API?

POST the event details to /dev/ical, keep the returned task_id, and retrieve the finished .ics file by webhook or a signed link valid for 24 hours.

Is the iCal generator API free?

No, there is no free tier or trial; it costs $0.002 per request, and a failed generation is never charged.

Which calendar apps will open the file?

The output follows RFC 5545, the standard iCalendar format supported by Google Calendar, Outlook, Apple Calendar and virtually every other major calendar client.

Does it support recurring events?

Yes, you can pass a recurrence rule and the generated file encodes it correctly for calendar apps to expand into repeating occurrences.

Does it handle timezones correctly?

Yes, timezone identifiers are encoded per the standard so attendees in different regions see the correct local time rather than a raw UTC offset.

Can I generate many invites in bulk?

Yes, submit one async task per event and collect each .ics file by webhook as it completes, which suits registration systems processing many attendees.

Is this endpoint live?

Yes, /dev/ical is live and accepting requests now.

Is my event data stored after the file is generated?

No, event data and the generated file are deleted after the retention window and are never used for training.

For developers — API access

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.

API endpoint

POSThttps://api.kit.forhosting.com/dev/ical

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, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/dev/ical \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"items":["valor-1","valor-2"]}'

const res = await fetch("https://api.kit.forhosting.com/dev/ical", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "items": [
      "valor-1",
      "valor-2"
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/ical",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "items": [
        "valor-1",
        "valor-2"
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/ical", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"items":["valor-1","valor-2"]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"items":["valor-1","valor-2"]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/ical", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "items": [
    "valor-1",
    "valor-2"
  ]
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.ical",
  "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.

Pricing

Per request$0.002

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

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Read the full KIT documentation →

Run — free