Emoji shortcode lookup
Emoji shortcodes are convenient in source code, chat exports, templates, release notes, and automation, but a name such as :smile: is not the character a reader ultimately sees.
Run — free
This emoji shortcode lookup accepts one complete, colon-wrapped shortcode and returns its matching Unicode emoji immediately. The lookup is exact, deterministic, and local: it does not call a chat service, guess at similar names, or silently rewrite malformed input. Unknown shortcodes produce a clear input error so broken templates can be caught before publication.
Enter the complete shortcode you need to resolve
Provide one shortcode with its opening and closing colons, for example :smile:, :rocket:, or :+1:. Names are lowercase and matching is exact. Requiring the complete token matters in real workflows because plain words such as smile can appear naturally in prose, while the wrapped form clearly signals an intended emoji substitution. The result contains the submitted shortcode and the corresponding Unicode emoji character, so a script can preserve a useful audit trail while using the character directly. You do not need to supply a platform name, locale, or output encoding. Unicode is returned as JSON text and can be inserted into a document, copied into a message, stored in a database, or passed to a later transformation. If the input is missing, uses uppercase letters, omits either colon, contains spaces, or names an entry outside the mapping, the request fails explicitly. That strict behavior prevents an accidental word or typo from turning into an unexplained replacement.
Understand exact mapping and Unicode output
Shortcode vocabularies are conventions rather than a feature built into Unicode itself. This tool uses a fixed, versioned mapping of familiar GitHub- and Slack-style names for common faces, gestures, symbols, objects, foods, animals, weather, and sports. A fixed mapping makes repeated automation reproducible: the same accepted token yields the same sequence of Unicode code points every time. Some visible emoji, including hearts and warning symbols, contain a variation selector that requests emoji presentation. The returned value preserves that sequence even when it looks like a single character on screen. Appearance can still vary by operating system, browser, font, and messaging application because each renderer supplies its own artwork. The lookup does not turn arbitrary Unicode character names into emoji, search by description, apply skin tones, or interpret service-specific custom emoji uploaded by a workspace. For those cases, use the target service's own directory. Here, an unrecognized name is an error rather than a guessed match, which keeps generated content predictable and makes stale tokens easy to detect during tests.
Use the lookup safely in templates and automation
A common pattern is to validate a configurable status icon before saving a template. Send the configured token to this capability, keep the returned emoji when the lookup succeeds, and show the error to the editor when it fails. Build tools can perform the same check on release-note metadata, documentation fixtures, notification rules, or small content records. Because one request resolves one item, callers retain clear control over where replacements happen; the capability never scans a paragraph and cannot unexpectedly alter code samples, URLs, timestamps, or prose that happens to contain colons. Browser use is free, while an API request costs $0.002. The implementation performs no network requests and stores nothing, so there is no dependency on a chat provider's availability or account configuration. For batch processing, deduplicate tokens in the calling application, resolve each distinct shortcode, and cache the stable answers alongside the version of your content pipeline. Treat an invalid-input response as a validation failure instead of substituting a question mark: preserving the original token makes diagnosis and correction much easier.
What you can do with it
Validate a notification template
Confirm that a configured status shortcode exists before a message template is saved or deployed.
Render release-note metadata
Turn a selected category token such as :rocket: into a Unicode character for a changelog heading.
Test content fixtures
Assert the exact emoji produced by a known shortcode and fail clearly when a fixture contains a typo.
FAQ
What format does the input require?
Provide one lowercase name wrapped in colons, such as :smile:. Both colons are required.
What happens when a shortcode is unknown?
The request returns an invalid-input error that identifies the unrecognized token. It never guesses a similar name.
Does it support custom workspace emoji?
No. Custom emoji belong to a particular service or workspace and are not part of this fixed standard mapping.
Why can the emoji look different on another device?
The returned Unicode sequence is stable, but operating systems, fonts, browsers, and applications draw their own emoji artwork.
How much does an API lookup cost?
Each API request costs $0.002. The browser version runs locally for free.
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
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.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/str/emoji-shortcode-lookup \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"shortcode":":smile:"}'const res = await fetch("https://api.kit.forhosting.com/str/emoji-shortcode-lookup", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"shortcode": ":smile:"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/emoji-shortcode-lookup",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"shortcode": ":smile:"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/emoji-shortcode-lookup", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"shortcode":":smile:"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"shortcode":":smile:"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/emoji-shortcode-lookup", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"shortcode": ":smile:"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.emoji_shortcode_lookup",
"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
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. |