DEV Community: nly.kr

How to Manage Long UTM URLs in Developer Workflows

nly.kr — Tue, 25 Aug 2026 03:39:15 +0000

Long URLs are not always a problem.

Sometimes they are exactly what you want.

A campaign URL like this contains useful information:

https://example.com/pricing?utm_source=newsletter&utm_medium=email&utm_campaign=august_launch&utm_content=cta_button

The problem starts when the same URL has to move through several parts of a workflow:

an email system
a notification service
a CMS
a QR code
an internal dashboard
a social post
a database
an analytics pipeline

At that point, manually creating, copying, checking, and shortening URLs becomes repetitive.

Instead of treating URL shortening as a separate manual step, we can build a small workflow around it.

In this post, we'll create a practical JavaScript flow that looks like this:

Destination URL
      ↓
Add UTM parameters
      ↓
Validate the URL
      ↓
Shorten it
      ↓
Store both URLs
      ↓
Use the short URL for distribution

The important part is not the URL shortener itself.

The important part is keeping the original tracking URL correct while making the distribution URL easier to handle.

1. Build the UTM URL programmatically

You could concatenate strings manually:

const url =
  "https://example.com/pricing" +
  "?utm_source=newsletter" +
  "&utm_medium=email" +
  "&utm_campaign=august_launch";

It works, but it becomes easy to introduce encoding mistakes as the number of parameters grows.

The URL and URLSearchParams APIs give us a cleaner option.

function buildCampaignUrl(destination, campaign) {
  const url = new URL(destination);

  url.searchParams.set("utm_source", campaign.source);
  url.searchParams.set("utm_medium", campaign.medium);
  url.searchParams.set("utm_campaign", campaign.name);

  if (campaign.content) {
    url.searchParams.set("utm_content", campaign.content);
  }

  if (campaign.term) {
    url.searchParams.set("utm_term", campaign.term);
  }

  return url.toString();
}

Now we can create a campaign URL like this:

const longUrl = buildCampaignUrl(
  "https://example.com/pricing",
  {
    source: "newsletter",
    medium: "email",
    name: "august_launch",
    content: "cta_button",
  }
);

console.log(longUrl);

The output will contain the complete tracking URL.

This approach has another useful property: values are encoded correctly by the URL API instead of relying on manual string manipulation.

2. Validate before shortening

A short URL should not hide a broken long URL.

Before sending anything to a shortening service, validate the destination.

A basic validator can look like this:

function isHttpUrl(value) {
  try {
    const url = new URL(value);

    return (
      url.protocol === "http:" ||
      url.protocol === "https:"
    );
  } catch {
    return false;
  }
}

Then:

if (!isHttpUrl(longUrl)) {
  throw new Error("Invalid campaign URL");
}

This only validates the structure.

It does not guarantee that the destination actually exists.

If your workflow is important enough, you may also want a separate check for the destination before distributing the link.

3. Shorten the complete URL, not half of it

One mistake that makes tracking URLs harder to reason about is splitting the workflow like this:

Destination
    ↓
Shorten URL
    ↓
Add tracking parameters somewhere later

For a typical campaign workflow, I prefer this:

Destination
    ↓
Add UTM parameters
    ↓
Validate
    ↓
Shorten the COMPLETE URL

That gives you one canonical campaign URL before the shortening layer is introduced.

For example:

https://example.com/pricing

becomes:

https://example.com/pricing?utm_source=newsletter&utm_medium=email&utm_campaign=august_launch

and that complete URL becomes the input to the shortener.

This makes the system easier to debug later.

If something goes wrong, you still have the exact campaign destination that was originally created.

4. Put the shortener behind a function

Your application should not need to know the details of the shortening service everywhere.

Instead, isolate it.

async function shortenUrl(longUrl) {
  // call your URL shortening service here
}

Then the rest of your application only needs to understand:

const shortUrl = await shortenUrl(longUrl);

This small abstraction is useful if you ever:

change providers
add retries
add logging
introduce caching
disable shortening temporarily
use different providers in different environments

The campaign creation logic stays independent from the shortener implementation.

5. Example using a URL shortening API

As one concrete example, nly.kr provides a URL shortening API.

Its current documented endpoint is:

POST https://nly.kr/api/shorten

The API accepts the original URL and a required category, and API-key authentication can be sent using the X-API-Key header.

For developer-related links, dev is one of the documented categories.

A Node.js helper could look like this:

async function shortenUrl(longUrl) {
  const apiKey = process.env.NLY_API_KEY;

  if (!apiKey) {
    throw new Error("NLY_API_KEY is not configured");
  }

  const response = await fetch(
    "https://nly.kr/api/shorten",
    {
      method: "POST",
      headers: {
        "Content-Type":
          "application/x-www-form-urlencoded",
        "X-API-Key": apiKey,
        Accept: "application/json",
      },
      body: new URLSearchParams({
        url: longUrl,
        category: "dev",
      }),
    }
  );

  const data = await response.json();

  if (!response.ok) {
    throw new Error(
      data.message ||
        `Shortening failed: HTTP ${response.status}`
    );
  }

  return data.short_url;
}

Notice that the API key comes from:

process.env.NLY_API_KEY

rather than being hardcoded.

Do not put a private API key into browser-side JavaScript.

If authentication is required, make the request from your backend.

You can check the current endpoint, authentication options, parameters, and response format in the nly.kr URL Shortener API documentation.

6. Combine the pieces

Now we can turn the separate steps into one function.

async function createCampaignLink({
  destination,
  source,
  medium,
  campaign,
  content,
}) {
  const longUrl = buildCampaignUrl(
    destination,
    {
      source,
      medium,
      name: campaign,
      content,
    }
  );

  if (!isHttpUrl(longUrl)) {
    throw new Error("Invalid campaign URL");
  }

  const shortUrl = await shortenUrl(longUrl);

  return {
    originalUrl: destination,
    campaignUrl: longUrl,
    shortUrl,
  };
}

Usage:

const result = await createCampaignLink({
  destination: "https://example.com/pricing",
  source: "newsletter",
  medium: "email",
  campaign: "august_launch",
  content: "cta_button",
});

console.log(result);

Conceptually, the result looks like this:

{
  originalUrl: "...",
  campaignUrl: "...?utm_source=...",
  shortUrl: "..."
}

Now we have three separate pieces of information instead of throwing the original URL away.

7. Store the long URL too

This is probably the most important operational detail.

Do not store only:

short_url

Store enough information to reconstruct what happened.

For example:

{
  id: 127,
  campaign: "august_launch",
  channel: "newsletter",
  original_url: "https://example.com/pricing",
  campaign_url: "https://example.com/pricing?...",
  short_url: "...",
  created_at: "..."
}

Why?

Because three months later, a short URL alone tells you very little.

You may want to answer:

Which campaign created this link?
Which destination did it point to?
Which UTM parameters were used?
Was a new short URL generated later?
Which channel received it?

Keeping the original campaign URL makes debugging and reporting much easier.

8. Avoid generating duplicates unnecessarily

Imagine your application runs this code every time someone opens an admin page:

const shortUrl = await shortenUrl(longUrl);

You could end up generating multiple short links for exactly the same campaign URL.

A better workflow may be:

Create campaign URL
       ↓
Search existing record
       ↓
Found?
 ├─ Yes → reuse saved short URL
 └─ No  → create short URL and save it

A simple pseudo implementation:

async function getOrCreateShortUrl(longUrl) {
  const existing = await findByCampaignUrl(longUrl);

  if (existing) {
    return existing.shortUrl;
  }

  const shortUrl = await shortenUrl(longUrl);

  await saveLink({
    campaignUrl: longUrl,
    shortUrl,
  });

  return shortUrl;
}

This also reduces unnecessary external API calls.

9. Treat shortening as optional infrastructure

Your main product probably should not stop working just because a URL shortening API is temporarily unavailable.

Consider this flow:

Create content
     ↓
Generate campaign URL
     ↓
Try shortening
     ↓
Success → use short URL
Failure → keep long URL / retry later

Depending on your use case, falling back to the original URL may be better than failing the entire operation.

For example:

async function safeShortenUrl(longUrl) {
  try {
    return await shortenUrl(longUrl);
  } catch (error) {
    console.error(
      "URL shortening failed:",
      error
    );

    return longUrl;
  }
}

Whether this fallback makes sense depends on your application.

For a marketing batch that must use predefined short links, you might prefer to stop the job instead.

For a non-critical notification, using the original URL may be acceptable.

The key is to decide deliberately.

10. Add timeouts and retries carefully

External APIs can fail.

Your application should expect:

network errors
authentication errors
bad input
server errors
timeouts

Retries are useful for temporary failures, but do not blindly retry every error.

For example:

400 Bad Request

usually suggests that changing nothing and retrying the same request will not help.

A temporary server or network error may be different.

A production workflow could use:

Request
  ↓
Success → save result

Temporary failure
  ↓
retry with backoff

Permanent/input failure
  ↓
log + require correction

This matters even for a feature as small as URL shortening.

11. Keep API keys on the server

If your shortener requires authentication, avoid this:

// DON'T do this in browser code
const API_KEY = "my-secret-key";

Everything delivered to the browser should be considered visible to the user.

A safer architecture is:

Browser
   ↓
Your backend
   ↓
URL Shortener API

Your backend reads the key from an environment variable or secret manager.

For example:

NLY_API_KEY=...

and:

const apiKey =
  process.env.NLY_API_KEY;

The browser never needs to receive the credential.

12. A more realistic campaign workflow

Once everything is combined, an internal system might work like this:

Editor creates campaign
        ↓
Destination selected
        ↓
UTM parameters generated
        ↓
Campaign URL validated
        ↓
Existing short URL lookup
        ↓
Short URL generated if needed
        ↓
Both URLs stored
        ↓
Short URL sent to email/SMS/QR workflow

This is much more reliable than manually moving URLs between browser tabs.

It also creates a clean boundary between different concerns:

Tracking
   = UTM parameters

Distribution
   = short URL

Analytics
   = campaign/traffic data

Storage
   = mapping between them

Keeping those responsibilities separate makes the workflow easier to maintain.

What I would implement first

If I were adding this to a small project, I would not start with a complicated link-management system.

I'd begin with four pieces:

1. buildCampaignUrl()
2. isHttpUrl()
3. shortenUrl()
4. save the long + short URL pair

Then add caching, retries, dashboards, or batch processing only when the project actually needs them.

A URL shortener is a small component.

The useful part is the workflow around it.

When you create the full campaign URL first, validate it, shorten it behind a small abstraction, and keep the original URL in storage, long UTM links become much easier to manage without losing the information that made them useful in the first place.

How to Generate Short URLs with JavaScript and a URL Shortening API

nly.kr — Tue, 18 Aug 2026 09:14:43 +0000

Long URLs are often inconvenient when building web applications.

You may want to:

generate short links for social media posts
create links for QR codes
shorten URLs automatically from an admin dashboard
create campaign links programmatically

In this tutorial, we'll use a URL shortening API with both curl and JavaScript's fetch() API.

For the examples, I'll use the API from nly.kr, a URL shortener that I develop and operate.

API endpoint

The endpoint used in this tutorial is:

POST https://nly.kr/api/shorten

The request uses:

Content-Type: application/x-www-form-urlencoded

Authentication is handled with an API key.

The recommended header is:

X-API-Key: your_API_KEY

Bearer authentication is also supported:

Authorization: Bearer your_API_KEY

For JSON responses, send:

Accept: application/json

Required parameters

Two parameters are required when creating a short URL:

Parameter	Type	Required	Description
`url`	String	Yes	Original HTTP/HTTPS URL
`category`	String	Yes	Category key for the link

For this example, we'll use:

category=dev

Creating a short URL with curl

The quickest way to test the API is with curl.

curl -X POST "https://nly.kr/api/shorten" \
  -H "X-API-Key: your_API_KEY" \
  -H "Accept: application/json" \
  -d "url=https://example.com" \
  -d "category=dev"

Replace your_API_KEY with your actual API key.

A successful request returns JSON similar to this:

{
  "status": "success",
  "short_url": "https://nly.kr/Ab3XkQ",
  "original_url": "https://example.com",
  "code": "Ab3XkQ",
  "member_idx": 123,
  "category": "dev"
}

For most applications, the value you'll care about is:

short_url

Calling the API with JavaScript

You can make the same request using fetch().

const apiKey = "your_API_KEY";
const longUrl = "https://example.com";
const category = "dev";

fetch("https://nly.kr/api/shorten", {
  method: "POST",
  headers: {
    "Content-Type": "application/x-www-form-urlencoded",
    "X-API-Key": apiKey,
    "Accept": "application/json",
  },
  body: new URLSearchParams({
    url: longUrl,
    category,
  }),
})
  .then(async (response) => {
    const data = await response.json().catch(() => null);

    if (!response.ok) {
      throw {
        status: response.status,
        data,
      };
    }

    return data;
  })
  .then((data) => {
    console.log("Short URL:", data.short_url);
  })
  .catch((error) => {
    console.error(
      "Request failed:",
      error.status || "",
      error.data || error
    );
  });

One important detail here is that the API expects:

application/x-www-form-urlencoded

rather than a JSON request body.

That's why we're using URLSearchParams.

Using Bearer authentication

If you prefer the Authorization header, you can use:

curl -X POST "https://nly.kr/api/shorten" \
  -H "Authorization: Bearer your_API_KEY" \
  -H "Accept: application/json" \
  -d "url=https://example.com" \
  -d "category=dev"

For most cases, using the recommended X-API-Key header is simpler.

Handling API errors

If a required parameter is missing, the API returns an error response.

For example:

{
  "status": "error",
  "message": "Category is required."
}

Possible HTTP responses include:

Status	Meaning
`400`	Bad Request
`401`	Unauthorized
`405`	Method Not Allowed
`500`	Server Error

In production code, it's a good idea to check both the HTTP status code and the returned JSON.

Don't expose private API keys in frontend code

The JavaScript example above contains:

const apiKey = "your_API_KEY";

This is useful for demonstrating the request, but private API keys should generally not be embedded directly in frontend JavaScript.

Anything sent to the browser can be inspected by users.

For production applications, consider calling the URL shortening API from your backend instead:

Browser
   ↓
Your server
   ↓
URL shortening API

This lets your server keep the API key private.

Practical use cases

Once you receive short_url, you can use it in many workflows.

For example:

store it in your database
include it in email campaigns
generate QR codes
create social media links
generate short links automatically from a CMS
create campaign-specific tracking links

Conclusion

A URL shortening API makes it easy to automate link generation.

The basic flow is:

receive the original URL
send it to the API
get the short_url
store or share the generated link

API documentation:

https://nly.kr/en/api

If you just want to shorten a URL directly in the browser:

https://nly.kr/en/create-short-url

Disclosure: I develop and operate nly.kr. I used its API here as a practical example for this tutorial.

API로 URL 단축하기: JavaScript와 cURL로 긴 링크 자동으로 줄이는 방법

nly.kr — Sun, 16 Aug 2026 23:51:06 +0000

API로 URL 단축하기: JavaScript와 cURL로 긴 링크 자동으로 줄이는 방법

긴 URL을 한두 번 줄이는 정도라면 URL 단축 사이트에 접속해서 직접 처리하면 됩니다.

하지만 개발 과정에서 URL을 반복해서 생성해야 한다면 이야기가 달라집니다.

예를 들어 이런 경우입니다.

게시물이 등록될 때 공유용 짧은 링크를 자동 생성
긴 UTM 링크를 생성한 뒤 자동으로 URL 단축
관리자 페이지에서 버튼 한 번으로 공유 링크 생성
사내 도구나 개인 프로젝트에서 짧은 링크 생성
여러 URL을 처리하는 자동화 작업

이럴 때는 웹페이지에서 하나씩 URL을 입력하는 것보다 URL 단축 API를 사용하는 방식이 편합니다.

이번 글에서는 nly.kr의 URL 단축 API를 이용해 cURL과 JavaScript에서 긴 링크를 짧게 만드는 기본 흐름을 정리해보겠습니다.

URL 단축 API를 사용하면 무엇이 달라질까?

일반적인 URL 단축 과정은 다음과 같습니다.

URL 단축 사이트를 연다.
긴 URL을 붙여넣는다.
단축 버튼을 누른다.
생성된 짧은 URL을 복사한다.
필요한 곳에 붙여넣는다.

한두 번이라면 전혀 문제가 없습니다.

하지만 프로그램에서 URL이 계속 생성된다면 이 과정을 사람이 반복할 필요는 없습니다.

API를 사용하면 프로그램이

긴 URL 생성
↓
URL 단축 API 호출
↓
짧은 URL 응답
↓
DB 저장 또는 화면 표시

처럼 처리할 수 있습니다.

nly.kr URL 단축 API 기본 구조

nly.kr에서는 다음 Endpoint로 URL 단축 요청을 보낼 수 있습니다.

POST https://nly.kr/api/shorten

요청 데이터는 application/x-www-form-urlencoded 형식으로 전송합니다.

API Key는 헤더에 포함할 수 있습니다.

X-API-Key: YOUR_API_KEY

단축 요청에는 기본적으로 두 가지 값이 필요합니다.

url
category

url은 줄이려는 원본 주소이고, category는 해당 링크의 분류입니다.

예를 들어 개발 관련 문서라면 dev 카테고리를 사용할 수 있습니다.

cURL로 URL 단축하기

터미널에서 가장 간단하게 테스트하려면 cURL을 사용할 수 있습니다.

curl -X POST "https://nly.kr/api/shorten" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Accept: application/json" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "url=https://example.com/docs/getting-started" \
  --data-urlencode "category=dev"

정상적으로 처리되면 결과는 JSON 형태로 받을 수 있습니다.

예를 들면 이런 구조입니다.

{
  "status": "success",
  "short_url": "https://nly.kr/Ab3XkQ",
  "original_url": "https://example.com/docs/getting-started",
  "code": "Ab3XkQ",
  "category": "dev"
}

프로그램에서는 여기서 short_url 값을 가져와 저장하거나 사용자에게 보여주면 됩니다.

JavaScript에서 URL 단축하기

JavaScript에서도 같은 방식으로 요청할 수 있습니다.

아래는 Node.js 등 서버 측 JavaScript에서 사용할 수 있는 간단한 예입니다.

const apiKey = "YOUR_API_KEY";

const params = new URLSearchParams({
  url: "https://example.com/docs/getting-started",
  category: "dev"
});

async function createShortUrl() {
  const response = await fetch("https://nly.kr/api/shorten", {
    method: "POST",
    headers: {
      "X-API-Key": apiKey,
      "Accept": "application/json",
      "Content-Type": "application/x-www-form-urlencoded"
    },
    body: params
  });

  const data = await response.json();

  if (!response.ok) {
    console.error("URL shortening failed:", data);
    return;
  }

  console.log("Short URL:", data.short_url);
}

createShortUrl();

성공하면 data.short_url을 이용해 이후 작업을 이어갈 수 있습니다.

예를 들어 DB에 저장하거나 이메일, 알림 메시지, 관리자 페이지 등에 짧은 주소를 표시할 수 있습니다.

API Key는 프론트엔드에 노출하지 않는 것이 좋다

JavaScript 예제를 볼 때 주의할 점이 하나 있습니다.

API Key가 필요한 API라면 실제 서비스에서는 API Key를 브라우저 JavaScript 코드에 그대로 넣지 않는 것이 좋습니다.

브라우저에 전달된 코드는 사용자가 확인할 수 있기 때문입니다.

따라서 실제 서비스에서는 보통 다음과 같은 구조가 더 적합합니다.

Browser
   ↓
내 서버
   ↓
URL Shortener API

API Key는 서버에 저장하고 브라우저에서는 자신의 서버를 호출하도록 구성하는 방식입니다.

UTM 링크 자동화에도 활용할 수 있다

URL 단축 API가 특히 유용한 경우 중 하나가 UTM 링크입니다.

마케팅이나 유입 분석을 위해 URL에 여러 파라미터를 붙이면 주소가 금방 길어집니다.

예를 들어:

https://example.com/product/123
?utm_source=newsletter
&utm_medium=email
&utm_campaign=summer_event

실제로는 한 줄의 URL이지만 사람이 보기에는 상당히 길어질 수 있습니다.

이런 시스템을 만들고 있다면

원본 URL
↓
UTM 파라미터 생성
↓
완성된 UTM URL
↓
URL 단축 API
↓
짧은 공유 URL

순서로 자동화할 수 있습니다.

여기서 중요한 점은 UTM 파라미터까지 포함된 완성된 원본 URL을 먼저 만든 후 단축하는 것입니다.

사용자는 짧은 링크를 공유하지만, 링크를 통해 이동할 때는 원래 목적지의 UTM 정보를 그대로 사용할 수 있는 구조가 됩니다.

직접 URL을 줄일 때와 API를 사용할 때

두 방식 중 무조건 하나가 좋은 것은 아닙니다.

웹 URL 단축기가 편한 경우

몇 개의 링크만 빠르게 줄이고 싶다면 굳이 코드를 작성할 필요가 없습니다.

nly.kr 무료 URL 단축기에서 긴 URL을 입력해 바로 짧은 링크를 만들 수 있습니다.

웹 방식은 직접 URL을 줄이거나 QR 코드까지 함께 활용하고 싶을 때 편합니다.

API가 편한 경우

반대로 아래처럼 반복적인 처리가 있다면 API 방식이 더 적합합니다.

게시물 등록
→ 짧은 공유 URL 자동 생성

상품 등록
→ 공유 링크 자동 생성

UTM 링크 생성
→ 짧은 캠페인 링크 자동 생성

관리자 도구
→ 버튼 클릭 시 URL 단축

결국 기준은 간단합니다.

사람이 가끔 만드는 링크라면 웹 도구, 프로그램이 반복해서 만들어야 한다면 API입니다.

URL 단축과 SEO는 별개의 문제다

URL을 짧게 만들었다고 해서 원본 페이지의 Google 검색 순위가 올라가는 것은 아닙니다.

URL 단축은 주로

긴 링크 정리
SNS 및 메신저 공유
문서에 넣을 링크 정리
UTM 주소 단순화
QR 코드 활용
프로그램 자동화

같은 목적에 사용하는 것이 적절합니다.

검색 노출을 늘리려면 결국 검색엔진이 평가하는 실제 콘텐츠와 원본 페이지를 개선해야 합니다.

즉, 단축 URL은 SEO 기법이라기보다 링크를 공유하고 관리하는 도구에 가깝습니다.

마무리

URL 단축은 기능 자체는 단순합니다.

하지만 API와 연결하면 활용 범위가 꽤 넓어집니다.

단순히 긴 주소를 줄이는 것을 넘어

콘텐츠 생성
→ URL 생성
→ UTM 추가
→ URL 단축
→ 저장 및 공유

과정 전체를 자동화할 수 있기 때문입니다.

직접 URL을 줄이고 싶다면:

👉 nly.kr URL 단축기

프로젝트에서 자동으로 단축 URL을 생성하고 싶다면:

👉 nly.kr URL 단축 API 문서

를 참고할 수 있습니다.

작은 자동화라도 반복되는 복사·붙여넣기를 없애면 개발 흐름이 훨씬 단순해집니다.

DEV.to Tags

webdev api javascript productivity

How to Shorten URLs from Your App with a Simple API

nly.kr — Fri, 14 Aug 2026 02:54:27 +0000

When building a small app or side project, there are times when you need to generate short links automatically.

You could build your own URL shortening system, but for many projects that means adding a database, redirect logic, unique code generation, and analytics just for one small feature.

A simpler option is to use a URL shortening API.

I’ve been working with the nly.kr URL Shortener, which also provides an API for creating short URLs programmatically.

In this post, I’ll show a few simple examples.

API Endpoint

The endpoint for creating a short URL is:

POST https://nly.kr/api/shorten

The API expects form-encoded data.

Two parameters are required:

url — the original HTTP or HTTPS URL
category — a category key for the link

You’ll also need an API key for authentication.

The recommended header is:

X-API-Key: your_API_KEY

You can find the full API documentation here:

nly.kr URL Shortener API

Example with cURL

The quickest way to test the API is with cURL.

curl -X POST "https://nly.kr/api/shorten" \
  -H "X-API-Key: your_API_KEY" \
  -H "Accept: application/json" \
  -d "url=https://example.com" \
  -d "category=dev"

A successful response looks similar to this:

{
  "status": "success",
  "short_url": "https://nly.kr/Ab3XkQ",
  "original_url": "https://example.com",
  "code": "Ab3XkQ",
  "member_idx": 123,
  "category": "dev"
}

Once you have the short_url, you can store it, display it to the user, or use it anywhere your application needs a shorter shareable link.

JavaScript Example

You can call the same endpoint with fetch().

const apiKey = "your_API_KEY";
const longUrl = "https://example.com";
const category = "dev";

fetch("https://nly.kr/api/shorten", {
  method: "POST",
  headers: {
    "Content-Type": "application/x-www-form-urlencoded",
    "X-API-Key": apiKey,
    "Accept": "application/json",
  },
  body: new URLSearchParams({
    url: longUrl,
    category: category,
  }),
})
  .then(async (response) => {
    const data = await response.json();

    if (!response.ok) {
      throw new Error(data.message || "Failed to shorten URL");
    }

    return data;
  })
  .then((data) => {
    console.log("Short URL:", data.short_url);
  })
  .catch((error) => {
    console.error("Error:", error);
  });

This can be useful when you want to generate short links from an internal tool, dashboard, CMS, or other web application.

Python Example

The same request is also straightforward with Python and the requests library.

import requests

api_key = "your_API_KEY"
long_url = "https://example.com"
category = "dev"

response = requests.post(
    "https://nly.kr/api/shorten",
    headers={
        "X-API-Key": api_key,
        "Accept": "application/json"
    },
    data={
        "url": long_url,
        "category": category
    },
    timeout=10
)

print("HTTP:", response.status_code)
print(response.json())

If the request succeeds, the JSON response contains the generated short URL.

Handling Errors

It’s also worth checking the HTTP status instead of assuming every request succeeded.

For example, the API may return an error response such as:

{
  "status": "error",
  "message": "카테고리는 필수입니다."
}

Typical API errors can include invalid parameters, missing authentication, unsupported methods, or server errors.

In production code, always handle both HTTP errors and malformed responses.

When Is a URL Shortening API Useful?

I find this kind of API useful for things like:

Automatically generating links from a CMS
Creating short links for notification messages
Sharing long campaign or tracking URLs
Generating links from internal admin tools
Creating cleaner URLs for documentation
Automating links in side projects

For one-off links, using a web interface is usually faster.

You can create one directly with the nly.kr URL Shortener.

But when link generation becomes part of an application workflow, an API is much easier to automate.

Final Thoughts

URL shortening is a small feature, but implementing and maintaining a complete shortening service yourself can be unnecessary for many projects.

A simple API lets you keep the application logic focused on your actual product while handling short-link generation separately.

If you want to experiment with it:

For small apps, automation scripts, and side projects, that’s often all you need.

Why I Couldn't Start Telecom Ads (Landing Page Was the Problem)

nly.kr — Thu, 16 Apr 2026 10:45:55 +0000

I tried to run telecom ads a while ago, and surprisingly, the hardest part wasn’t the ads themselves.

Setting up ads is actually not that difficult. There are tons of guides, and most platforms are pretty straightforward.

The real problem was something else.

Landing pages.

At first, I thought I could just collect leads through messages or chat.
But once I actually ran ads, I realized people don’t convert that way.

They want to:

check details
compare options
feel some level of trust

Without a proper landing page, they just leave.

So I tried building one myself.

That’s where things got messy.

I didn’t know:

what kind of copy to write
how to structure the page
what information should go first

And outsourcing wasn’t much better.

expensive
slow to update
annoying when conditions change (which happens a lot in telecom/rental)

Eventually, I found a different approach.

Check it here:
landing page tool

Instead of building everything from scratch, this kind of setup lets you:

pick an industry
generate a basic structure
get actual usable copy filled in

What stood out to me was this:

It’s not really about building a “perfect” landing page.

It’s more about
getting something ready fast so you can actually start running ads.

After trying it, I realized something:

In telecom ads, speed matters more than perfection.

If you wait too long to prepare everything, you miss timing.
And by then, competition is already ahead.

So now I think about it differently.

Instead of trying to make the perfect landing page,

I just:

create something quickly
launch ads
improve based on results

Generate Punycode in 1 Second with This Simple Online Tool

nly.kr — Mon, 09 Feb 2026 14:21:46 +0000

Internationalized domain names look friendly to users, but once you start working with DNS settings or server panels, you quickly run into encoding issues. Many systems don’t accept special characters directly and expect Punycode instead. That usually forces you to pause your workflow and search for a converter.
I’ve had to deal with this often while configuring multilingual sites and testing domain behavior. Instead of jumping between heavy tools, I started using a lightweight generator that focuses purely on fast conversion: https://nly.kr/tools/punycode�. You paste the text, it converts instantly, and you move on. No extra steps.
This becomes especially useful when debugging URL handling or checking how a system processes international domains. During one setup, a hosting panel kept rejecting a domain name without giving a clear error. Converting it to Punycode solved the problem immediately. Situations like that are where a quick one-second tool actually saves time.
There are still a few practical things to watch for. Some admin panels cache domain values, so changes might not apply right away. Also, copying text from formatted editors can introduce hidden characters that break encoding. When accuracy matters, especially for security testing, it’s smart to double-check results using browser developer tools.
For everyday work, though, a simple converter is one of those small utilities that quietly improves your workflow. It removes friction from repetitive tasks and lets you focus on the real problem instead of fighting with encoding.

A Small Tool I Ended Up Using More Than Expected

nly.kr — Wed, 04 Feb 2026 05:01:12 +0000

I didn’t originally plan to build a product.

It started as one of those small utilities you create for yourself because existing tools feel heavier than they need to be.

I wanted a simple way to shorten long URLs, generate QR codes, and create shareable documents without going through a complicated setup.

That eventually became nly.kr.

A Simple URL Shortener

There are plenty of URL shorteners available, but sometimes I only need a very simple workflow:

Paste a long URL
Generate a short link
Copy and share it

The nly.kr URL Shortener keeps that basic process simple and does not require signup for basic URL shortening.

It also generates a QR code for the shortened link, which is useful when sharing links outside the browser.

I often use short links for:

GitHub README files
Documentation
Messaging apps
Presentations
Long tracking URLs
QR codes

Registered users can optionally access link management and click statistics.

Adding PDF and Document Tools

After working on the URL shortener, I started running into another small problem.

Sometimes I needed a quick way to create or share documents without sending files back and forth.

That led me to add web-based PDF and document tools to nly.kr.

The PDF service is available here:

Create and share PDF documents with nly.kr

Depending on the use case, documents can be created in the browser, downloaded as PDF files, or shared through generated links.

This has been useful for things like:

Meeting notes
Simple reports
Quotations
Resumes
Documents that need to be shared through a link

It Gradually Became More Than One Tool

What started as a small URL shortener gradually expanded into a collection of lightweight web tools.

nly.kr now includes features such as:

URL shortening
QR code generation
Link management
Click statistics
PDF and document tools
Developer APIs
Chrome extension support

I still try to keep the basic tools simple enough that you can open the page, use what you need, and move on.

Why I’m Sharing It

I built most of these features because I needed them myself.

Over time, I realized that other developers, side-project builders, and people who regularly share links or documents might find them useful too.

If you need a lightweight URL shortening tool, you can try the nly.kr URL Shortener.

For the other tools and services, the main site is available at nly.kr.

That’s pretty much how a tiny utility ended up becoming something I use much more often than I originally expected.

A Simple URL Shortener for Side Projects (No Signup Required)

nly.kr — Mon, 02 Feb 2026 04:40:48 +0000

When working on small side projects, I often need a quick way to shorten URLs without dealing with complicated dashboards or mandatory signups.

Sometimes I just want to paste a long URL, get a shorter link, and move on.

I recently tried the nly.kr URL Shortener, a lightweight tool for creating short links without mandatory signup.

The basic workflow is simple:

Paste a long URL
Create a short link
Copy and share it

No account is required for basic URL shortening.

What I Like About It

A few things make it convenient for simple projects:

No signup required to shorten URLs
Clean and fast interface
Short and easy-to-share links
QR code generation
Optional link management for registered users
Click statistics for registered users

For developers, nly.kr also provides an API for integrating URL shortening into websites or applications.

Where I Use It

I mainly find URL shorteners useful for things like:

GitHub README files
Documentation
Messaging apps
Social media posts
Long tracking or campaign URLs
QR codes for offline sharing

It is especially useful when a URL contains a lot of parameters and becomes difficult to share cleanly.

Keeping Things Simple

There are many URL shorteners with advanced dashboards, marketing features, and paid plans.

Those features can be useful, but sometimes they are more than I need.

For small projects, I usually prefer something that lets me create a short link quickly without setting up an account first.

If you need a simple URL shortening tool, you can try the nly.kr URL Shortener.

For basic use cases and side projects, it keeps the process simple and gets the job done.

DEV Community: nly.kr

How to Manage Long UTM URLs in Developer Workflows

1. Build the UTM URL programmatically

2. Validate before shortening

3. Shorten the complete URL, not half of it

4. Put the shortener behind a function

5. Example using a URL shortening API

6. Combine the pieces

7. Store the long URL too

8. Avoid generating duplicates unnecessarily

9. Treat shortening as optional infrastructure

10. Add timeouts and retries carefully

11. Keep API keys on the server

12. A more realistic campaign workflow

What I would implement first

How to Generate Short URLs with JavaScript and a URL Shortening API

API endpoint

Required parameters

Creating a short URL with curl

Calling the API with JavaScript

Using Bearer authentication

Handling API errors

Don't expose private API keys in frontend code

Practical use cases

Conclusion

API로 URL 단축하기: JavaScript와 cURL로 긴 링크 자동으로 줄이는 방법

API로 URL 단축하기: JavaScript와 cURL로 긴 링크 자동으로 줄이는 방법

URL 단축 API를 사용하면 무엇이 달라질까?

nly.kr URL 단축 API 기본 구조

cURL로 URL 단축하기

JavaScript에서 URL 단축하기

API Key는 프론트엔드에 노출하지 않는 것이 좋다

UTM 링크 자동화에도 활용할 수 있다

직접 URL을 줄일 때와 API를 사용할 때

웹 URL 단축기가 편한 경우

API가 편한 경우

URL 단축과 SEO는 별개의 문제다

마무리

How to Shorten URLs from Your App with a Simple API

API Endpoint

Example with cURL

JavaScript Example

Python Example

Categories

Handling Errors

When Is a URL Shortening API Useful?

Final Thoughts

Why I Couldn't Start Telecom Ads (Landing Page Was the Problem)

Generate Punycode in 1 Second with This Simple Online Tool

A Small Tool I Ended Up Using More Than Expected

A Simple URL Shortener

Adding PDF and Document Tools

It Gradually Became More Than One Tool

Why I’m Sharing It

A Simple URL Shortener for Side Projects (No Signup Required)

What I Like About It

Where I Use It

Keeping Things Simple