How-to-efficiently-detect-sex-chatbots-in-Kik-Messenger-and-build-it-for-other-platforms

How to efficiently detect sex chatbots in Kik Messenger and build it for other platforms

Ever since 2017,  Kik messenger has been plagued by irrelevant messages distributed by automated bots. In particular, it has seen its public groups assailed by a large number of these bots which infuse it with spam-related content. Jaap, computer science and engineering master’s student, annoyed by these relentless and unwelcomed interruptions, decided to tackle the issue by engineering a counter bot called Rage that would identify and remove these bots.

Using proprietary algorithms to identify known spambot name patterns, Rage also uses Imagga’s adult content filtering API (NSFW API) to scan profile pictures as well. The result worked so well that friends soon wanted it. With word of mouth only, his bot was installed on over 2,000 groups in just three days. Now his bot is used in +3000 chats rooms, containing over 100.000 people, and some 20.000 images are being processed every month.

Major project issues - Neural networks are expensive: the cheapest is AWS g2.2 series which costs $0.65/hour. For a student, it is a hefty sum to invest in GPU instances. Therefore Jaap looked into using a third-party company that would provide him with a more affordable out of the box solution. While Google came up as first in a search, he selected Imagga because of the already tested accuracy compared to other solutions on the market.

Putting it all together - Since spambots use racy profile pictures, Rage bot’s detection algorithm works a lot better using Imagga NSFW API than it would be just applying name matching. When someone joins a chat, his or her name is scanned for known spambot name patterns while Imagga’s NSFW content moderation analyzes his or her profile picture. If the safety confidence level is less than 40%, the user is considered a spambot and is removed from the chat.
Since Kik profile pictures are public, Rage bot only needs to send image links directly to Imagga Content Moderation API from which it returns its result.

"confidence": 100,
"name": "safe"

Up until August 2018, Jaap and his bot have stopped over 20K spambots from plaguing Kik Messenger. Detected bots who have under a certain level of “confidence” are removed automatically, but the Rage bot is not stopping here. One of the most recent features is the 48 mode, which detects the number of people in a chat and removes inactive users.

Building and deploying - Imagga's NSFW classification were set up and running in a day. Using the 2,000 free API calls a month demo, Jaap was able to quickly implement, test and judge if this was the right tool for him. As a content moderation solution, it can be installed and run the same day with no downtime and deliver accurate content moderation. Then, if you need more API calls, Imagga has very affordable pricing.


Securing Images in Python With the Imagga NSFW Categorization API

In web and mobile applications, as well as any other digital media, the use of images as part of their content is very common. With images being so ubiquitous, there comes a need to ensure that the images posted are appropriate to the medium they are on. This is especially true for any medium accepting user-generated content. Even with set rules for what can and cannot be posted, you can never trust users to adhere to the set conditions. Whenever you have a website or medium accepting user-generated content, you will find that there is a need to moderate the content.

Why Moderate Content?

There are various reasons why content moderation might be in your best interest as the owner/maintainer of a digital medium. Some common ones are:

  • Legal obligations - If your application accomodates underaged users, then you are obligated to protect them from adult content.
  • Brand protection - How your brand is perceived by users is important, so you might want to block some content that may negatively affect your image.
  • Protect your users - You might want to protect your users against harassmsnt from other users. The harassment can be in the form of users attacking others by posting offensive content. An example of this is Facebook’s recent techniques of combating revenge p0rn on their platform.
  • Financial - It might be in your best interest financially, to moderate the content shown on your applications. For instance if your content is somewhat problematic, other businesses might not want to associate with you in terms of advertising on your platform or accepting you as an affiliate for them. For some Ad networks, keeping your content clean is a rule that you have to comply with if you want to use them. Google Adsense is an example of this. They strictly forbid users of the service from placing their ads on pages with adult content.
  • Platform rules - You might be forced to implement some form of content moderation if the platform your application is on requires it. For instance,Apple requires applications to have a way of moderating and restricting user-generated content before they can be placed on the App Store and Google also restricts apps that contain sexually explicit content

As you can see, if your application accepts user-generated content, moderation might be a requirement that you can’t ignore. There are different ways moderation can be carried out:

  • Individual driven - an example of this is a website that has admins that moderate the content. The website might work by either restricting the display of any uploaded content until it has been approved by an admin or it might allow immediate display of uploaded content, but have admins who constantly check posted content. This method tends to be very accurate in identifying inappropriate content, as the admins will most likely be clear as to what is appropriate/inappropriate for the medium. The obvious problem with this is the human labour needed. Hiring moderators might get costly especially as the application’s usage grows. Relying on human moderators can also affect the app’s user experience. Human response will always be slower than an automated one. Even if you have people working on moderation at all times, there will still be a delay in identifying and removing problematic content. By the time it is removed, a lot of users could have seen it. On systems that restrict showing uploaded content until it has been approved by an admin, this delay can become annoying to users.
  • Community driven - with this type of moderation, the owner of the application puts in place features that enable the app’s users to report any inappropriate content e.g. flagging the content. After a user flags a post, an admin will then be notified. This also suffers from a delay in identifying inappropriate content from both the community (who might not act immediately the content is posted) and the administrators (who might be slow to respond to flagged content). Leaving moderation up to the community might also result in reported false positives as content that is safe is seen by some users as inappropriate. With a large community, you will always have differing opinions, and because many people will probably not have read the Terms and Conditions of the medium, they will not have clear-cut rules of what is and isn’t okay.
  • Automated - with this, a computer system usually using some machine learning algorithm is used to classify and identify problematic content. It can then act by removing the content or flagging it and notifying an admin. With this, there is a decreased need for human labour, but the downside is that it might be less accurate than a human moderator.
  • A mix of some or all the above methods - Each of the methods described above comes with a shortcoming. The best outcome might be achieved from combining some or all of them e.g. you might have in place an automated system that flags suspicious content while at the same time enabling the community to also flag content. An admin can then come in to determine what to do with the content.

A Look at the Imagga NSFW Categorization API

Imagga makes available the NSFW (not safe for work) Categorization API that you can use to build a system that can detect adult content. The API works by categorizing images into three categories:

  • nsfw - these are images considered not safe. Chances are high that they contain ponographic content and/or display nude bodies or inappropriate body parts.
  • underwear - this categorizes medium safe images. These might be images displaying lingerie, underwear, swimwear, e.t.c.
  • safe - these are completely safe images with no nudity.

The API works by giving a confidence level of a submitted image. The confidence is a percentage that indicates the probability of an image belonging to a certain category.

To see the NSFW API in action, we’ll create two simple programs that will process some images using the API. The first program will demonstrate how to categorize a single image while the second will batch process several images.

Setting up the Environment

Before writing any code, we’ll first set up a virtual environment. This isn’t necessary, but is recommended as it prevents package clutter and version conflicts in your system’s global Python interpreter.

First, create a directory where you’ll put your code files.

[cc lang="bash"]$ mkdir nsfw_test[/cc]

Then navigate to that directory with your Terminal application.

[cc lang="bash"]$ cd nsfw_test[/cc]

Create the virtual environment by running:

[cc lang="bash"]$ python3 -m venv venv[/cc]

We’ll use Python 3 in our code. In the above, we create a virtual environment with Python 3. With this, the default Python version inside the virtual environment will be version 3.

Activate the environment with (on MacOS and Linux):

[cc lang="bash"]$ source venv/bin/activate[/cc]

On Windows:

[cc lang="bash"]$ venv\Scripts\activate[/cc]

Categorizing Images

To classify an image with the NSFW API, you can either send a GET request with the image URL to the [cci]/categorizations/[/cci] endpoint or you can upload the image to [cci]/content[/cci], get back a [cci]content_id[/cci] value which you will then use in the call to the [cci]/categorizations/[/cci] endpoint. We’ll create two applications that demonstrate these two scenarios.

Processing a Single Image

The first app we’ll create is a simple web application that can be used to check if an image is safe or not. We’ll create the app with Flask.

To start off, install the following dependencies.

[cc lang="bash"]$ pip install flask flask-bootstrap requests[/cc]

Then create a folder named [cci]templates[/cci] and inside that folder, create a file named [cci]index.html[/cci] and add the following code to it.

[cc lang="python"]
{% extends "bootstrap/base.html" %}

{% block title %}Imagga NSFW API Test{% endblock %}

{% block navbar %}

{% endblock %}

{% block content %}

{% if image_url %}

{{ res }}

{% endif %}

{% endblock %}
[/cc]

In the above code, we create a html template containing a form that the user can use to submit an image URL to the Imagga API. When the response comes back from the server, it will be shown next to the processed image.

Next, create a file named [cci]app.py[/cci] in the root directory of your project and add the following code to it. Be sure to replace [cci]INSERT_API_KEY[/cci] and [cci]INSERT_API_SECRET[/cci] with your Imagga API Key and Secret. You can signup for a free account to get these credentials. After creating an account, you’ll find these values on your dashboard:

[cc lang="python"]
from flask import Flask, render_template, request
from flask_bootstrap import Bootstrap
import os
import requests
from requests.auth import HTTPBasicAuth

app = Flask(__name__)
Bootstrap(app)

# API Credentials. Set your API Key and Secret here
API_KEY = os.getenv('IMAGGA_API_KEY', 'INSERT_API_KEY')
API_SECRET = os.getenv('IMAGGA_API_SECRET', 'INSERT_API_SECRET')

API_ENDPOINT = 'https://api.imagga.com/v1'

auth = HTTPBasicAuth(API_KEY, API_SECRET)

@app.route('/', methods=['GET', 'POST'])
def index():
image_url = None
res = None
if request.method == 'POST' and 'image_url' in request.form:
image_url = request.form['image_url']

response = requests.get(
'%s/categorizations/nsfw_beta?url=%s' % (API_ENDPOINT, image_url),
auth=auth)

res = response.json()
return render_template('index.html', image_url=image_url, res=res)

if __name__ == '__main__':
app.run(debug=True)
[/cc]

Every call to the Imagga API must be authenticated. Currently the only supported method for authentication is Basic. With Basic Auth, credentials are transmitted as user ID/password pairs, encoded using base64. In the above code, we achieve this with a call to [cci]HTTPBasicAuth()[/cci].

We then create a function that will be triggered by GET and POST requests to the [cci]/[/cci] route. If the request is a POST, we get the data submitted by form and send it to the Imagga API for classification.

The NSFW Categorizer is one of a few categorizers made available by the Imagga API. A Categorizer is used to recognize various objects and concepts. There are a couple predefined ones available (Personal Photos and NSFW Beta) but if none of them fit your needs we can build a custom one for you.

As mentioned previously, to send an image for classification, you send a GET request to the [cci]/categorizations/[/cci] endpoint. The [cci]categorizer_id[/cci] for the NSFW API is [cci]nsfw_beta[/cci]. You can send the following parameters with the request:

  • url: URL of an image to submit for categorization. You can provide up to 10 urls for processing by sending multiple url parameters (e.g. [cci]?url=&url=…&url=[/cci])
  • content: You can also directly send image files for categorization by uploading the images to our [cci]/content[/cci] endpoint and then provide the received content identifiers via this parameter. As with the url parameter you can send more than one image - up to 10 content ids by sending multiple [cci]content[/cci] parameters.
  • language: If you’d like to get a translation of the tags in other languages, you should use the language parameter. Its value should be the code of the language you’d like to receive tags in. You can apply this parameter multiple times to request tags translated in several languages. See all available languages here.

After processing the request, the API sends back a JSON object holding the image’s categorization data in case of a successful processing, and an error message incase there was a problem processing the image.

Below you can see the response of a successful categorization:

[cc lang="javascript"]
{
'results': [{
'image': 'https://auto.ndtvimg.com/car-images/big/dc/avanti/dc-avanti.jpg',
'categories': [{
'name': 'safe',
'confidence': 99.22
}, {
'name': 'underwear',
'confidence': 0.71
}, {
'name': 'nsfw',
'confidence': 0.07
}]
}]
}
[/cc]

Note that you might not always get JSON with the three categories displayed. If the confidence of a category is [cci]0[/cci], this category will not be included in the JSON object.

Below you can see the response of a failed categorization.

[cc lang="javascript"]
{
'results': [],
'unsuccessful': [{
'reason': 'An error prevented image from being categorized. Please try again.',
'image': 'http://www.axmag.com/download/pdfurl-guide.pdf'
}]
}
[/cc]

Back to our app, you can save your code and run it with:

[cc lang="bash"]
$ python app.py
[/cc]

If you navigate to http://127.0.0.1:5000/ you should see a form with one input field. Paste in the URL of an image and submit it. The image will be processed and you will get back a page displaying the image and the JSON returned from the server. To keep it simple, we just display the raw JSON, but in a more sophisticated app, it would be parsed and used to make some decision.

Below, you can see the results of some images we tested the API with.

As you can see, the images have been categorized quite accurately. The first two have [cci]safe[/cci] confidence scores of [cci]99.22[/cci] and [cci]99.23[/cci] respectively while the last one has an [cci]underwear[/cci] score of [cci]96.21[/cci]. Of course, we can’t show an [cci]nsfw[/cci] image here on this blog, but you are free to test that on your own.

To know the exact confidence score to use for your app, you should first test the API with several images. When you look at the results of several images, you will be able to better judge which number to look out for in your code when filtering okay and not okay images. If you are still not sure about this, our suggestion is setting the confidence threshold at 15-20%. However, if you’d like to be more strict on the accuracy of the results, setting the confidence threshold at 30% might do the trick.

You should know that the technology is far from perfect and that the NSFW API is still in beta. From time to time, you might get an incorrect classification.

Note that the API has a limit of 5 seconds for downloading the image. If the limit is exceeded with the URL you send, the analysis will be unsuccessful. If you find that most of your requests are unsuccessful due to timeout error, we suggest uploading the images to our [cci]/content[/cci] endpoint first (which is free and not accounted towards your usage) and then use the content id returned to submit the images for processing via the [cci]content[/cci] parameter. We’ll see this in action in the next section.

Batch Processing Several Images

The last app we created allowed the user to process one image at a time. In this section, we are going to create a program that can batch process several images. This won’t be a web app, it will be a simple script that you can run from the command line.

Create a file named [cci]upload.py[/cci] and add the code below to it. If you are still using the virtual environment created earlier, then the needed dependencies have already been installed, otherwise install them with [cci]pip install requests[/cci].

[cc lang="python"]
import os
import requests
from requests.auth import HTTPBasicAuth

# API Credentials. Set your API Key and Secret here
API_KEY = os.getenv('IMAGGA_API_KEY', 'INSERT_API_KEY')
API_SECRET = os.getenv('IMAGGA_API_SECRET', 'INSERT_API_SECRET')

API_ENDPOINT = 'https://api.imagga.com/v1'
FILE_TYPES = ['png', 'jpg', 'jpeg', 'gif']

class ArgumentException(Exception):
pass

if API_KEY == 'YOUR_API_KEY' or \
API_SECRET == 'YOUR_API_SECRET':
raise ArgumentException('You haven\'t set your API credentials. '
'Edit the script and set them.')

auth = HTTPBasicAuth(API_KEY, API_SECRET)

def upload_image(image_path):
if not os.path.isfile(image_path):
raise ArgumentException('Invalid image path')

# Open the desired file
with open(image_path, 'rb') as image_file:
filename = image_file.name

# Upload the multipart-encoded image with a POST
# request to the /content endpoint
content_response = requests.post(
'%s/content' % API_ENDPOINT,
auth=auth,
files={filename: image_file})

# Example /content response:
# {'status': 'success',
# 'uploaded': [{'id': '8aa6e7f083c628407895eb55320ac5ad',
# 'filename': 'example_image.jpg'}]}
uploaded_files = content_response.json()['uploaded']

# Get the content id of the uploaded file
content_id = uploaded_files[0]['id']

return content_id

def check_image(content_id):
# Using the content id, make a GET request to the /categorizations/nsfw endpoint
# to check if the image is safe
params = {
'content' : content_id
}
response = requests.get(
'%s/categorizations/nsfw_beta' % API_ENDPOINT,
auth=auth,
params=params)

return response.json()

def parse_arguments():
import argparse
parser = argparse.ArgumentParser(
description='Tags images in a folder')

parser.add_argument(
'input',
metavar='',
type=str,
nargs=1,
help='The input - a folder containing images')

parser.add_argument(
'output',
metavar='',
type=str,
nargs=1,
help='The output - a folder to output the results')

args = parser.parse_args()
return args

def main():
import json
args = parse_arguments()

tag_input = args.input[0]
tag_output = args.output[0]

results = {}
if os.path.isdir(tag_input):
images = [filename for filename in os.listdir(tag_input)
if os.path.isfile(os.path.join(tag_input, filename)) and
filename.split('.')[-1].lower() in FILE_TYPES]

images_count = len(images)
for iterator, image_file in enumerate(images):
image_path = os.path.join(tag_input, image_file)
print('[%s / %s] %s uploading' %
(iterator + 1, images_count, image_path))
try:
content_id = upload_image(image_path)
except IndexError:
continue
except KeyError:
continue
except ArgumentException:
continue

nsfw_result = check_image(content_id)
results[image_file] = nsfw_result
print('[%s / %s] %s checked' %
(iterator + 1, images_count, image_path))
else:
raise ArgumentException(
'The input directory does not exist: %s' % tag_input)

if not os.path.exists(tag_output):
os.makedirs(tag_output)
elif not os.path.isdir(tag_output):
raise ArgumentException(
'The output folder must be a directory')

for image, result in results.items():
with open(
os.path.join(tag_output, 'result_%s.json' % image),
'wb') as results_file:
results_file.write(
json.dumps(
result, ensure_ascii=False, indent=4).encode('utf-8'))

print('Done. Check your selected output directory for the results')

if __name__ == '__main__':
main()
[/cc]

We use the [cci]argparse[/cci] module to parse arguments from the command line. The first argument passed in will be the path to a folder containing images to be processed while the second argument is a path to a folder where the results will be saved.

For each image in the input folder, the script uploads it with a POST request to the [cci]/content[/cci] endpoint. After getting a content id back, it makes another call to the [cci]/categorizations/[/cci] endpoint. It then writes the response of that request to a file in the output folder.

Note that all uploaded files sent to [cci]/content[/cci] remain available for 24 hours. After this period, they are automatically deleted. If you need the file, you have to upload it again. You can also manually delete an image by making a DELETE request to [cci]https://api.imagga.com/v1/content/[/cci].

Add some images to a folder and test the script with:

[cc lang="bash"]$ python upload.py path/to/input/folder path/to/output/folder[/cc]

If you look at the output folder you selected, you should see a JSON file for each processed image.

Feel free to test out the Imagga NSFW Categorization API. If you have any suggestions on ways to improve it or just general comments on the API, you can post them in the Comment Section below or get in touch with us directly. We are always happy to get feedback on our products.


Tinder, Tigers, and... Tagging

It's sometimes striking how fast some crazy ideas go viral nowadays... and the tiger selfies on Tinder :) make no exception, going far enough to escalate to the attention of the New York State Assembly.

Funny (or not), taking selfies with tigers, and eventually using them as profile pictures, is not allowed in NY any more, unless you want to pay the $500 fine for a few seconds of glory.

Being an image recognition company, especially focused on auto-tagging, it seems to us like a piece of cake to detect if there is a tiger on the image! Here is an example:

 

Tinder, Tigers, Tagging
Tinder, tigers, and tagging

You can see the sample test here and upload/paste a tiger selfie (not yours of course) to try it out.

And this could be used via API access by Tinder to warn users... or by the state assembly to detect them ;)

Just another (weird) validation how widespread image recognition could be nowadays... In any types of apps and use-cases, as images are becoming the ultimate way to communicate and express ourselves so easily, thanks to the cameras in our pockets.

Have an awesome idea that would greatly benefit from automated image tagging? Just sign up for free here and give our auto-tagging API a try.


What we are after in 2014 - democratizing machine learning as a service and applying it in practice

2013 was such an exciting year for us! We partnered multiple photo-related hackathons (Seedhack 3Startup Weekend Mobile Sofia and Photo Hack Day Menlo ParkPhoto Hack Day BerlinSeedhack 4; plus one more coming in a less than two weeks - Photo Hack Day Tokyo!) and created a lot of friends there.

We also closed our seed round from LAUNCHub and several angel investors, extended our team with two great software engineers, visited several leading industry and technology conferences (Tech Crunch Disrupt BerlinWeb Summit DublinMicroStock Expo BerlinleWeb Paris), and made a major leap in our core technology:

Auto-categorization of images for different use-cases
Auto-categorization of images for different use-cases

We on-boarded new customers and partnered with two great image processing and management services - Blitline and Cloudinary that now offer our smart cropping as part of their feature sets (the latter, still in private beta).

Now 2014 has already come, and it's time to roll out several awesome products, enabled by our recent technology advancements. There is a huge hype around A.I. and machine learning these days. But for us this isn't just a hype... it's what we've been working on hard in the last year. And we want to bring this to the people (and start-ups, and companies), empowering them to take advantage of machine learning for better understanding and organization of their imagery in the easiest possible way.

We are aiming to keep the lean/iterative approach so we'll definitely rely on your active feedback, ideas, and inclusion in the process. Happy to share that we already have multiple successful pilots with customers taking advantage of our machine-learning-based auto-categorization, as in the example image above, and some more customers in the pipeline. Now it's your turn! If you are interested in auto-categorization and you think it can help your image-centric businesses or projects (and believe me, it will help them for sure) give a try to our auto-categorization "playground".

Mobile is also going to be bigger and bigger and this is something we are definitely interested in as the development of our smart photo organization app Sliki proves. Sliki was recently selected to join the AppCampus programme so we'll release it on Windows Phone first (which is a great platform for development BTW), but we also conduct some closed tests on Android. Sign up here and we'll keep you updated on how Sliki goes. Funny enough, the (hardware-enabled) future seems bright even for complex computer vision on mobile as explained in this video.

All in all, It's a really exciting journey and you are more than welcome to join it as an advisor, investor, employee, partner, customer or just a friend :)


Python API client and Color Search in Instagram

We are excited to have our API available for out-of-the-box development in one more major platform – Python!

Python

Ivan Penchev was enthusiastic to port the PHP client in Python and no sooner said than done – here it is https://github.com/ivanpenchev/imagga-py.

In no time Georgi Kostadinov put it at work, and what a better way to try it than prototyping basic tool that searches among recent Instagram photos based on colors, using Imagga Color API. He was kind to publish his code as well: https://github.com/gkostadinov/Instagram-Color-Search-Python.

Instagram Color Search

Instagram Color Search prototype

Thank you guys, you’re awesome!

You can try our APIs by applying for trial account at www.imagga.com. Currently we have PHP, Java, Ruby and Python clients for our APIs.


Imagga partners with Blitline to jointly offer Smart Cropping

We are excited to announce that starting today we are partnering with Blitline, one of the best and most lightweight and easy to integrate image processing services in the cloud!

Blitline& Imagga

Our cooperation starts with the opportunity for Blitline users to take advantage of our smart-cropping, as applied in our cropping API and cropping tool Cropp.me. The guys at Blitline have produced a very easy to understand example why Imagga’s smart cropping is better than just center cropping:

How Imagga smart cropping works

Imagga Smart Cropping as explained by Blitline

Funny enough, the idea for the cooperation came a month ago from an existing user of Blitline who approached us and asked if we can provide them with the same seamless integration that Blitline offers for regular cropping, but with our smart cropping, or ideally – can we offer it via Blitline? No sooner said than done! We got in contact and things simply worked out.

Now Blitline users who subscribe for the special Blitline + Imagga plan have access to the imagga_smart_crop function for their image processing pipeline. The pricing sticks to the pay-as-you-go model (per cropped image) plus a very low monthly subscription fee.

Blitline Imagga Pricng Plan

Blitline + Imagga Pricing Plan

We do believe this is going to be a great example of co-opetition!


Come hack with Imagga APIs at Google I/O Extended Sofia

Google I/O 2013 in Sofia

We will be partnering with Eleven for Google I/O Extended Sofia event. It’s exciting you can not only see live the great sessions during the event but also do something – write a bit of code may be

We will be facilitating specially designated hacker’s corner at SOHO, where you can stop by and hack for an hour or a day. It’s up to you but feel welcomed to stay as long as you wish and start making your great ideas into working prototypes. If you do not have an idea but feel like coding, here are some ideas we come up:

  • Picture mosaic of images, that form any national flag. You can use Imagga Color API and Google Images for the collage creation.
  • Guess what’s on the picture – use Imagga Crop API to find the most prominent part of the image and blur it. Then serve the blurred images so people can make their guesses.

These are just two ideas to help you start hacking. We will be more than please to help you with our APIs for some other great ideas connected to image manipulation that you might have.

For the most diligent there will be in-kind price of $500 in commercial API usage. Eleven, who’s hosting the event is offering wildcard for live interview for their next investment round.

More about Imagga APIs and how to hack using them can be found here – http://imagga.com/api/docs/

Even more detailed information:

We will be extremely happy to see you at Google I/O Extended Sofia and specially if you stop by the hacking corner. Most probably there you will find some Imagga team members, but if you need more information or if you want to reach out, pls, email to info@imagga.com or send message to Georgi – https://plus.google.com/u/0/110303707514543533758/


Partnering Photo Hack Day Berlin in the first days of June

Photo Hack Day 3 Berlin

Continuing our tradition to partner image-related hackathons, we are happy to announce that we’ll provide Imagga API access and prizes for the competitors in the upcoming Photo Hack Day Berlin hackathon in June 1-2! The lead organizers are our friends from EyeEm.

PHD3 Imagga Prize

In addition to awarding API credits and cash prizes, we are planning to announce some amazing news at the end of the event! If you are keen about images, hacking and starting startups – make sure to come around and hack with us and the other great partners of the event:

PHD3 Sponsors

Photo Hack Day Berlin Sponsors & Friends

See you at the arty Platoon Kunsthalle venue!


Imagga API kits in Ruby and Java, now looking for your platforms!

I guess most of you agree that nothing is as motivating as seeing people being enthusiastic about what you do. And that’s why we feel privileged to have some real supporters among you guys!

We are happy to announce that now we have some great community-supported kit/clients for Imagga API in Ruby and Java!

Trying to stick to the MVP approach when launching our platform in the end of this January, we decided that it’s absolutely OK to have only a PHP client and a well written concise documentation that still allows developers integrate the API in other platforms, until we manage to implement multiple platform kits later on.

We thought that if hackers are eager enough to try and use our API it should be OK for them to spend an hour or two figuring out how to make the proper HTTP calls on their own, in their development platforms of choice. Happily enough, this turned out to be right!

 

Ruby

The first version of the Ruby client was implemented in about two hours by Mart Karu during Seedhack in February! The ColourTag.me team formed during the hackathon was eager to use Imagga’s color extraction and they were using Ruby, so Mart did the ‘hackwork’. He was kind to publish it on GitHub – https://github.com/martkaru/imagga - and to continue supporting it after that. Big Thanks Mart!

 

Java (registered trademark of ORACLE)

The Java API kit is implemented and constantly updated by Jakob Vad Nielsen. He contacted us long time ago, when we still haven’t launched Imagga API publicly, and we took the chance to contact him back once we were ready. Soon after he shared that he has implemented and published a Java kit, available in GitHub again – https://github.com/lazee/imagga-java-kit. Big Thanks to Jakob, also for his feature and tweak requests that make a lot of sense, and for being that rapid in keeping the kit up to date with the constant changes we apply to the API!

Now it’s your turn!  We are currently focusing the majority of our technical efforts to providing more advanced and scalable technology. That’s why porting the Imagga API client/kit to some other platforms unfortunately is out of our very-short-term backlog. But that’s where you can help! Do you feel enthusiastic about what we do and want to try it out, but your preferred platform is neither PHP, nor Ruby, nor Java? You are more than welcome to wrap a client for it and share it with others! Node.js, .NET/C# and Python for example would be very nice additions to our kit-supported platforms. Of course, we will help as much as possible in providing relevant info and support, in addition to the color and cropping API docs that are already there.

We are starting to hire soon, and implementing a tidy kit for Imagga API in a new platform is definitely a plus for those who want to apply. And the good karma should be enough for the others? Please contact us if you think so :)


Partnering Photo Hack Day 4 in Facebook HQ this April

We are very excited to partner the 4th edition of Photo Hack Day to be held April 6-7 in the Facebook HQ in Menlo Park! Photo Hack Day 4 Photo Hack Day This is “THE hackathon” when we talk about images. The last edtion has gathered more than 350 developers who’ve produced the impressive 72 innovate image related hacks! What better place than that to offer our APIs for some heavy hacking?!? It’s a privilege for us to be among lots of great API sponsors:   Photo Hack Day – API Sponsors We do hope to see a lot of creative hacks using all these APIs. We’re offering prizes for all who integrate the Imagga API, plus a special cash prize for the the most creative integration! If you are around make sure to join the party and make some great use our APIs