Kebab case

Kebab case (also known as dash-case, lisp-case, or spinal-case) is a text formatting convention that splits input phrases on spaces, underscores, and capital-letter boundaries—including screaming-snake input such as HELLO_WORLD—then lowercases every token and joins them together using hyphens. This format is heavily relied upon in web development for generating readable, predictable strings. Most importantly, this conversion tool prioritizes your privacy by running entirely locally in your web browser; the text you paste is securely processed on your own device and is never uploaded to or stored on any external server.

Kebab-case is a fundamental naming convention across modern engineering stacks. Common use cases include:

• Web URLs and Routing: Constructing clean, RESTful endpoint paths (e.g., /api/v1/user-profiles/). Unlike camelCase or snake_case, hyphens are treated as standard space delimiters by search engine indexers, drastically improving SEO and keyword parsing.
• CSS Selectors and HTML Attributes: Standardizing class names (.button-primary, .grid-container) and custom data attributes (data-user-id, aria-labelledby) for readability and consistency.
• Package Management: Naming published dependencies and libraries in ecosystems like NPM (e.g., react-dom, lodash-es), where uppercase characters are often forbidden.
• Cloud and Infrastructure: Tagging and naming Kubernetes pods, namespaces, AWS resources, and Helm charts. These systems frequently enforce strict DNS-1123 compliance, mandating lowercase alphanumeric characters and hyphens.

When integrating kebab-case into your workflows, keep these best practices in mind:

• Understand Tokenization Boundaries: Be aware of how acronyms and uppercase sequences are handled. A robust tokenizer safely splits acronym boundaries (e.g., transforming XMLHttp into xml-http), guaranteeing consistent lowercase hyphenated outputs.
• Internationalization Differences: While kebab-case preserves base Unicode characters (lowercasing them appropriately), it does not perform ASCII transliteration. If your application requires strict ASCII strings—such as for highly restricted legacy systems—you should use a dedicated Slugify tool instead.
• Avoid Trailing Hyphens: Ensure your text manipulation pipelines trim leading or trailing hyphens after removing punctuation or special characters.

• Zero Data Leakage: Because this utility performs all string manipulations strictly on the client side, sensitive strings such as proprietary API endpoints, internal microservice names, or user data can be safely converted without risk of network interception.
• Injection Attacks: While kebab-cased strings are inherently URL-safe and typically exclude malicious HTML characters, you must always sanitize user-generated inputs before rendering them directly into the DOM or injecting them into database queries to prevent Cross-Site Scripting (XSS).

Here are implementations for converting standard strings to kebab-case in popular programming languages:

JavaScript / TypeScript

function toKebabCase(input: string): string {
  return input
    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
    .replace(/[_.\s]+/g, "-")
    .trim()
    .toLowerCase()
    .replace(/^-+|-+$/g, "");
}

Python 3

import re

def to_kebab_case(text: str) -> str:
    # Insert spaces between lowercase and uppercase boundaries
    text = re.sub(r"([a-z0-9])([A-Z])", r"\1 \2", text)
    # Split by spaces, underscores, or existing hyphens
    words = re.split(r"[-_\s]+", text)
    # Join with hyphens and lowercase
    return "-".join(word.lower() for word in words if word)