Easy Twitter Automation

This project received 3 bids from talented freelancers with an average bid price of $233 USD.

Get free quotes for a project like this
Employer working
Skills Required
Project Budget
$30 - $250 USD
Total Bids
Project Description


I need someone to create a web application to automate
some very simple Twitter operations.


I have already written most of the software in PHP,
however it is too user-intensive. I need someone to
take what work I've already done and make it easy
enough for anybody to use.

The web application's job is simple: to automatically
follow other Twitter users and to automatically unfollow
other Twitter users.

Here are the three primary functions this software must
be capable of:

EXAMPLE: If a user wants to automatically follow 20
people an day who use the keywords "fly fishing" in
a tweet, the web application needs to do it for them.

EXAMPLE: If a user wants to follow 20 people a day
from a list of followers for another Twitter user, the
web application needs to automate that for our user.

EXAMPLE: Every 72 hours, the web application should
scan the user's list of Twitter follows and followers,
and unfollow everybody who isn't following the user back.


We are billed based on CPU cycles and bandwidth, so both
should be conserved when possible. Your software needs
to be clean-running.


We'll be using PHP and MySQL for user interfaces.

These need to look a little pretty and very simple.
This is our last concern, after we have the core software
ready and working.

There's another web application that does automatic
following called [url removed, login to view] -- you can see a sample of
the kind of interfaces we need there.

While I'm open to suggestion, I believe the user interfaces
should be limited to scheduling & reporting only and should
*NOT* allow any direct Twitter tasks.

What I mean is this: I don't want users on the web site
sitting at their computer waiting for second-by-second
results from the software. This is extremely over-bearing
on the server. Instead, the user interfaces should ONLY
interact with a couple database tables and should have no
direct/immediate connection to the Twitter interaction
function set.

IMPORTANT NOTE: We have a Wordpress-based membership
web site that will be where the user interfaces must
be kept. I have worked extensively with using outside
web pages within the bounds of a Wordpress CMS and it
isn't that difficult, however there will be a little
trial-and-error in the final phase to make everything
look clean before we release this to the users. It
will be your responsibility to get the final user
interfaces setup and working in the Wordpress web site.
(I am here to help, but don't have time to do the full
integration myself.)

But don't worry, it really isn't that difficult.


You can use PHP or PERL for background processes.

The background processes, of course, handle all of the
actual Twitter automation. They go one by one through
the table of follow instructions and do the hard part.

The FOLLOW automation needs to operate based loosely
on the parameters set by the users (such as how many
people to follow within a certain time frame).

The UNFOLLOW automation needs to be run on every user
account every 48 hours. (Make this a variable at the
top of the soure code that can be easily changed later.
It may make more sense to do this every 3 to 7 days
instead of every 2 days, so we need flexibility.)


Users can set these parameters for each auto-follow

- Twitter username
- Twitter password
- keyword/phrase
- auto-follow (yes/no)
- if auto-follow: max number of new follows/day (5-100)
- receive report of people auto-followed (yes/no)

Users should be able to do either of these two things:

- auto-follow people using those keywords
- manually see a list of people using those keywords
over a 5 day period, with links to visit the people's
Twitter page or follow. ([url removed, login to view] has a great
example of how to do this.)


Users can set these parameters for each auto-follow

- Twitter username
- Twitter password
- Twitter username to get list of followers from
- max number of new follows/day (5-100)
- receive report people auto-followed (yes/no)

Users should be able to do this:

- Input the username of a Twitter user with a lot of
followers and our system will automatically grab a
list of a handful of their followers every day at
a random time and automatically follow them in our
user's Twitter account.


We need the ability to easily limit the number of
instructions (keyword/phrases being used) by each
account depending on their membership level. You only
need to create the logic to set a limit based upon
a variable in the source code. I can add the code
to integrate the membership levels later (it's a
pain because it works with 3rd part software).

EXAMPLE: When a user loads the user interface, the
variable $max_instructions should be set to 100 and
all necessary code should use that variable. That
way, at my leisure, I can write the code to set
$max_instructions based on their membership level.


Users can set these parameters:

- automatically unfollow people who don't follow
you? (yes/no)
- Twitter username
- Twitter password
- max number of unfollows/day (5-100)
- receive report of unfollows (yes/no)


I have already written PHP code to do these tasks:
- retrieve a full list of followers for ANY
Twitter user
- retrieve a full list of follows for ANY
Twitter user
- create a list of non-mutuals (follows that are
not following back)
- add a follow (function, just needs the parameters)
- unfollow (function, just needs the parameters)

They can be easily ported to perl if you want
to use it instead of PHP. (This *may* be less
CPU intensive. I'll leave this decision up to
you, I can work in both.)


For future administration functions, we need the
automation instructions to have an extra field
called "member_id" which will be set with the
user identification number in our membership system.
(I will write the line of code to integrate the
two systems: your code for automation and user
interfaces and our code for the membership system.)

Make sure in your code you have a line that reads
$member_id = 1. I will change that line to set the
identification number properly.


I would like to give this project to someone who
can continue to work with me when we need updates
or changes made. If it stops working for any
reason (such as Twitter changes their API), I need
you to be available for emergency fixes.

Please let me know in your bid how we will be able
to work together AFTER the initial project is complete.

I'm comfortable either paying you a small monthly
fee to insure the software works for my users for
years to come. (I would give you full access to
the administration of the software and you will be
responsible for checking the software for issues
and fix anything that comes up.)

...or just paying you on-call as issues arise.
Either one is okay with me, so think about what
you'd like to be paid for either scenario and
put that in your notes.


I'm very easy to work with. Check my rating comments
and you'll see that I'm laid back, easy going, and
very understanding.

The biggest challenge we'll have in our relationship
is that deadlines are very important to me. For
example, I need this system setup and running by the
end of the month.


I do not have a fortune to invest in the creation of
this software. Frankly, since the core of the system
is already written, your job isn't that difficult.

Please keep in mind that we're starting a long-term
relationship (hopefully 12-24-36 months or more).
I can write software, but really don't enjoy doing it.
So, I want this to be your creation and I will want
you to maintain it. So, as my users need more features
or as Twitter changes and we need updates, I want to
have you continue the development.

So, please bid accordingly.

If your bid is over $300, please do not bother posting
a bid at all.



Looking to make some money?

  • Set your budget and the timeframe
  • Outline your proposal
  • Get paid for your work

Hire Freelancers who also bid on this project

    • Forbes
    • The New York Times
    • Time
    • Wall Street Journal
    • Times Online