Below are a list of recurring monthly bills. The first number is the day of the month the bill arrives (first chance to pay it) and the second number is the due day of the month (last chance to pay it).

16, 1
2, 16
10, 25
31, 26
15, 31

The difference between the arrival and due date is always less than a month. I'm looking for an algorithm that, for any number of bills with any reception dates and any due dates, will:

produce a list of fewest possible login dates to the online bank where the bills are paid.
guarantee that no due dates are missed.

My idea so far is to look for a single date (or date range) on which as many as possible bills are between arrival and due date, and then repeat this process until the list is empty.
Is this the best approach? Is there an existing algorithm for this problem? What is it called? Code examples, if any, would be preferred in Python, PHP or just pseudo-code.
Actually, Your solution is not correct and here is why:
Suppose you have many days where the same amount of ranges intersect, and this amount is the maximum among all others. For example:

1 -> 3
3 -> 6
6 -> 9
9 -> 10

From what I see you you have the following days (3, 6, 9) where all of them have two bills to be paid, and no other day contains more bills to be paid. Now since you can't possibly determine which day to start with, you could for example choose day 6 and pay the bills (2, 3). Next, you have no other option but to choose days 3 and 9 to pay bills 1 and 4 correspondingly. You used 3 days, while the answer is 2 choosing the first day to be 3 paying both bills 1 and 2, then choosing day 9 paying bills 3 and 4.
Anyways, I'm pretty sure I have an almost linear time solution for you.
First, let's make your input a little bit more clear, and add 30 (or 31 in case of 31 days month) to the second number if it is in fact smaller than the first one. Your example would look like this:

16 -> 31
2  -> 16
10 -> 25
31 -> 56
15 -> 31

My idea is based on the following 2 facts: 

Whenever a login is made, it is always better to pay all the bills which are available, and haven't been paid yet.
When traversing the time line of the month from the beginning (day 1) to the end (day 60) it is always better to try and delay the logging process if possible; meaning that if the delay won't cause any due date to be missed.

In order to do so let's first assign a unique ID to each entry:

16 -> 31
2  -> 16
10 -> 25
31 -> 56
15 -> 31

Let's use sweep line algorithm which generally solves interval related problems. Create a vector called Sweep where each element of this vector contains the following information:

ID: The ID of the corresponding entry.
Timer: Indicating either the first or the last day to pay a bill.
Type: Just a flag. 0 means that Timer contains the first day to pay the bill number ID (first number), whereas 1 means that Timer contains the last day to pay the bill number ID (second number).

For each entry insert 2 elements to Sweep vector:

ID = ID of the entry, Timer = First number, Type = 0.
ID = ID of the entry, Timer = Second number, Type = 1.

After inserting all these elements to Sweep vector it will have a size equals to 2 x number of entries. Sort this vector increasingly based on the value of Timer, in case of a tie then increasingly based on the value of Type (In order to first check the start of an entry before its end).
Traverse Sweep vector while keeping a set containing the IDs of all the unpaid bills so far, let's call this set Ready. In each step you might deal with one the following elements (based on the Type we added):

Type = 0. In this case it means that you have reached the day of first being able to pay the bill number ID. Don't pay this bill yet. Instead insert its ID to our Ready set (idea 2).
Type = 1. In this case check to see whether the corresponding ID is inside Ready set. If it is not just continue to the next element. If it is in fact inside Ready set this means that you have reached the last day for paying a previously unpaid bill. You have no other option but to pay this bill, alongside with all the other bills inside Ready set at this day (idea 1). By paying the bill I mean to increase the variable containing your answer by one, and if it's important to you traverse Ready set and store somewhere that all these IDs must be paid at the current day. After doing so you have paid all the ready bills, just clear Ready set (erase all the elements inside it).

Every entry causes 2 elements to be inserted into the Sweep vector, and every entry will be inserted exactly once into Ready set, and deleted once as well. The cost for checking an ID inside Ready set is O(Log N) and it's done for every entry exactly once. The sorting operation is O(N Log N). Thus, your total complexity would be: O(N Log N) where N is the total number of entries you have.
Python is not really my strongest programming language, so I will leave the mission of coding the mentioned algorithm up to you (in C++ for example it's not that hard to implement). Hope it helps!

EDIT (thanks to @Jeff's comment)
You can make your solution to be even O(N) using the following approach:
Instead of iterating over the events, you could iterate over the days from 1 to 60, and keep the same handling method as I mentioned. This way we eliminated the sort operation.
To remove the O(Log N) factor from the inserting and checking operation we could use a hash table as mentioned by @Jeff's comment, or instead of a hash table you could use a boolean array Visited, with a vector Ready. you will insert Ready bills to the vector. When you need to pay bills you will simply iterate over the Ready vector and mark the bills inside it as visited in their corresponding indexes inside the Visited array. Checking if I bill has been paid can be simply done by accessing the corresponding index inside the Visited array.
The funny thing is that after writing my answer I came up with almost the exact same optimization as mentioned by @Jeff's comment. However, seeing that number of days is really small, I decided not to make my answer any more complex, and keep it easier to understand. Now that @Jeff mentioned the optimization I decided to add it to my answer as well. However, please note that with this optimization the overall complexity now equals to O(N + D), where N is the total number of bills, and D is the total number of days. So, if D is quite large you will actually need to stick with the first solution.
Algorithm for fewest logins to online bank