# How do I create a URL shortener?

I want to create a URL shortener service where you can write a long URL into an input field and the service shortens the URL to "`http://www.example.org/abcdef`".

Instead of "`abcdef`" there can be any other string with six characters containing `a-z, A-Z and 0-9`. That makes 56~57 billion possible strings.

My approach:

I have a database table with three columns:

1. id, integer, auto-increment
2. long, string, the long URL the user entered
3. short, string, the shortened URL (or just the six characters)

I would then insert the long URL into the table. Then I would select the auto-increment value for "`id`" and build a hash of it. This hash should then be inserted as "`short`". But what sort of hash should I build? Hash algorithms like MD5 create too long strings. I don't use these algorithms, I think. A self-built algorithm will work, too.

My idea:

For "`http://www.google.de/`" I get the auto-increment id `239472`. Then I do the following steps:

``````short = '';
if divisible by 2, add "a"+the result to short
if divisible by 3, add "b"+the result to short
... until I have divisors for a-z and A-Z.
``````

That could be repeated until the number isn't divisible any more. Do you think this is a good approach? Do you have a better idea?

Due to the ongoing interest in this topic, I've published an efficient solution to GitHub, with implementations for JavaScript, PHP, Python and Java. Add your solutions if you like :)

51

I would continue your "convert number to string" approach. However, you will realize that your proposed algorithm fails if your ID is a prime and greater than 52.

### Theoretical background

You need a Bijective Function f. This is necessary so that you can find a inverse function g('abc') = 123 for your f(123) = 'abc' function. This means:

• There must be no x1, x2 (with x1 ? x2) that will make f(x1) = f(x2),
• and for every y you must be able to find an x so that f(x) = y.

### How to convert the ID to a shortened URL

1. Think of an alphabet we want to use. In your case, that's `[a-zA-Z0-9]`. It contains 62 letters.
2. Take an auto-generated, unique numerical key (the auto-incremented `id` of a MySQL table for example).

For this example, I will use 12510 (125 with a base of 10).

3. Now you have to convert 12510 to X62 (base 62).

12510 = 2×621 + 1×620 = `[2,1]`

This requires the use of integer division and modulo. A pseudo-code example:

``````digits = []

while num > 0
remainder = modulo(num, 62)
digits.push(remainder)
num = divide(num, 62)

digits = digits.reverse
``````

Now map the indices 2 and 1 to your alphabet. This is how your mapping (with an array for example) could look like:

``````0  ? a
1  ? b
...
25 ? z
...
52 ? 0
61 ? 9
``````

With 2 ? c and 1 ? b, you will receive cb62 as the shortened URL.

``````http://shor.ty/cb
``````

### How to resolve a shortened URL to the initial ID

The reverse is even easier. You just do a reverse lookup in your alphabet.

1. e9a62 will be resolved to "4th, 61st, and 0th letter in the alphabet".

e9a62 = `[4,61,0]` = 4×622 + 61×621 + 0×620 = 1915810

2. Now find your database-record with `WHERE id = 19158` and do the redirect.

### Example implementations (provided by commenters)

• C++
• Python
• Ruby
• C#
• CoffeeScript
• Perl
Tuesday, June 1, 2021

81
``````Server.UrlDecode(xxxxxxxx)
``````
Saturday, June 5, 2021

16

Did you mean urllib2.urlopen?

You could potentially lift the intended filename if the server was sending a Content-Disposition header by checking `remotefile.info()['Content-Disposition']`, but as it is I think you'll just have to parse the url.

You could use `urlparse.urlsplit`, but if you have any URLs like at the second example, you'll end up having to pull the file name out yourself anyway:

``````>>> urlparse.urlsplit('http://example.com/somefile.zip')
('http', 'example.com', '/somefile.zip', '', '')
>>> urlparse.urlsplit('http://example.com/somedir/somefile.zip')
('http', 'example.com', '/somedir/somefile.zip', '', '')
``````

Might as well just do this:

``````>>> 'http://example.com/somefile.zip'.split('/')[-1]
'somefile.zip'
>>> 'http://example.com/somedir/somefile.zip'.split('/')[-1]
'somefile.zip'
``````
Tuesday, June 22, 2021

67

I just tried this and received 404 code and page back.

At a guess it's doing User-Agent detection which either by accident or on purpose doesn't serve content to python urllib.

Clarification, with `urllib`, I received the `urlopen` returned a response object with a 404 code and HTML content. With `urllib2.urlopen` an `urllib2.HTTPError` exception was raised.

I'd suggest you try setting your User Agent to something that looks like a browser. There's a question about this here: Changing user agent on urllib2.urlopen

Tuesday, August 3, 2021

32

Use ASP.NET routing rather than rewriting when possible. It's available with both MVC and Web Forms. Routing is much more flexible and does a better job in passing context to the processing code, handling postbacks, etc.

You can also use the IIS7 Rewrite Module to handle rewriting at the webserver level before your ASP.NET code executes. There's some good information on how to do that here.

Friday, October 1, 2021