ForHosting KIT · Developer Utilities

Create a vCard

A contact file that opens fine on one phone and mangles the name field on another usually means someone hand-built the vCard text instead of following the specification closely. This vcard generator api takes structured contact fields and returns a properly formatted .vcf file, so every field lands in the right place regardless of which device or address book imports it.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Why a hand-rolled vCard breaks so easily

The vCard format looks simple, a handful of labeled lines like FN, TEL and EMAIL, which is exactly why so many implementations get it subtly wrong: line folding rules, character escaping for commas and semicolons within a field, and the specific ordering some address book apps silently expect all trip up a quick string-concatenation approach. A contact that imports perfectly into one phone's address book can lose its organization field, mangle an accented name, or drop a phone number entirely on another, and the cause is almost always a spec detail that only shows up when a real device parses the file strictly.

What POST /dev/vcard takes and produces

You send structured fields, name, phone numbers, email addresses, organization, title, physical address and a photo reference where relevant, and the task assembles a properly encoded .vcf file following the format's escaping and line-folding rules exactly. The result is delivered by signed webhook or a signed link valid for 24 hours, ready to attach to an email, serve as a download, or encode directly into a QR code for a digital business card.

A format that predates the smartphone by a decade

The vCard specification originated in 1995 as an initiative of the Versit Consortium, a group formed by several major electronics and software companies to standardize how personal contact data moved between devices before anyone was carrying a phone in their pocket. Later revisions, including vCard 4.0 standardized in 2011, extended the format for a world of mobile devices and international character sets, but the underlying goal never changed: one file that any compliant application can read without guessing at the sender's intent.

Where a generated vCard actually gets used

Digital business cards encode a vCard directly into a QR code so a handshake ends with a contact saved rather than a typo-prone manual entry. Email signature systems attach a .vcf file automatically so recipients can save a sender's details in one tap. CRM exports and event registration systems that need to hand attendees a downloadable contact file all rely on the same underlying correctness a strict parser expects.

How it fits an automated workflow

A signup system that generates a vCard the moment a new employee's directory entry is created, an event platform producing one file per registered attendee, and a bulk export job converting an entire CRM table into individual contact files all call this endpoint the same way: submit structured fields, get a task_id, and receive the finished .vcf through a signed webhook or link. Generating one contact card and generating a thousand for a directory migration follow the identical asynchronous path.

What you can do with it

Digital business cards via QR code

Generate a vCard and encode it into a QR code so scanning it saves a complete, correctly formatted contact instead of a plain text snippet.

Automated email signature attachments

Attach a generated .vcf file to outgoing emails so recipients can save the sender's contact details in one tap, correctly on any device.

Event registration contact export

Produce a downloadable contact file for each attendee immediately after registration, ready to import into their address book.

Bulk directory migration

Convert an entire employee or customer directory into individual, standards-compliant vCard files in one batch during a system migration.

FAQ

What does this vcard generator api actually return?

A properly formatted .vcf file built from the structured fields you send, encoded and escaped according to the vCard specification so it imports cleanly on any compliant device.

Which vCard version does it produce?

The task generates standards-compliant vCard output following the widely supported specification, formatted for reliable import across current phones and address book applications.

Can I include a photo in the vCard?

Yes, a photo reference can be included as one of the structured fields and is encoded into the resulting file according to the format's rules.

Will special characters and accented names come through correctly?

Yes, the correct escaping and character encoding is applied automatically, which is precisely the detail that breaks most hand-built vCard files.

Can I generate vCards in bulk for a directory export?

Yes, since the task runs asynchronously, a full directory or CRM table can be converted to individual files in a single batch submission.

Is there a free tier for generating vCards?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

How much does generating a vCard cost?

$0.002 per request, charged only for tasks that complete successfully.

How do I receive the generated .vcf file?

POST /dev/vcard returns a task_id immediately, and the file is delivered via signed webhook or a signed link valid for 24 hours.

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/vcard

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/vcard \
  -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/vcard", {
  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/vcard",
    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/vcard", 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/vcard", 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.vcard",
  "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