Gets an important discount for purchasing WPeMatico Essentials that includes WPeMatico Professional plus Full Content addons.
Lot of new features with contents, images, tags, filters, custom fields and much more extends in WPeMatico free plugin, going further than RSS feed limits and takes you to a new experience.
Click on each item to see more details about it
(Almost) all WPeMatico’s Features | FREE | PRO |
Feeds and options are organized into campaigns.
Use WordPress custom post types for campaigns. Comfortable interface like Worpress posts editing for every campaign. You can move and close metaboxes. You can paginate and filter campaigns list by name. Feed list with scroll into campaign. Feed search filter. Inline smaller help on every metabox. Colored boxes for knowing what I’m doing.
|
||
Multiple feeds / categories / tags.
It’s possible to add as many feeds as you want, and add them to multiple already created categories or create new ones.
|
||
Auto add categories from source posts.
Categories found on source item can be added to the post; If category does not exist, then will be created.
|
||
Integrated with Simplepie library in WordPress.
Integrated with the Simplepie library that come with WordPress. This includes RSS 0.91 and RSS 1.0 formats, the popular RSS 2.0 format, Atom…
|
||
Feed autodiscovery from domains.
Lets you add feeds without even knowing the exact URL. Just type the domain of the site and will try to autodetect the feed. (Thanks Simplepie!)
|
||
External cron or WordPress cron jobs.
For maximum performance, you can make the RSS fetching process be called by a Unix or external cron job, or simply let WordPress handle it.
|
||
Max items, comments, author and lot of options.
Assigns options in campaign like max items to fetch every time, comments open/closed, current or original date, author, trackbacks, etc.
|
||
Custom post type, status, post formats and lot of options.
You can assign every item as post, page or another custom post type you have on your wordpress. Draft, pending or published Status and also assign a Post Format that your theme supports.
|
||
Image processing integrated with WordPress.
Images caching are integrated with WordPress Media Library and attach to posts for featured images. Upload remote images to default Uploads folder set on WordPress settings or link to source to save resources. Fully configurable in campaign.
|
||
Featured Image of post.
First image attached to a post enable as Featured Image.
|
||
Strip links from content.
You can strip all links from content and leaves them as text.
|
||
Strip HTML from content.
You can strip all HTML tags from content and saves it as pure text.
|
||
Post templating before save.
Campaign post template allow to modify the content fetched by adding extra information, such as text, images, campaign data, etc. before save it as post content. You can use some tags that will be replaced for current value.
|
||
Words Rewriting. Regular expressions supported.
The rewrite feature allow you to replace words or phrases of the content with the text you specify.
|
||
Words Relinking. Define custom links for words in content.
The Relinking feature allow you to make simple links from some words with origin and re-link fields.
|
||
Words to Category.
Define custom words to search into content or title to assign the post to specified category.
|
||
Detailed Log on campaign.
You can set to see the log on popup in campaign list or send to custom e-mail, with SMTP or WordPress php mail function on every executed cron or only on errors with campaign items.
|
||
WordPress permalinks to Source site.
Option to replace title links (Permalink) to external source. (This feature depends on others filters that can call permalink for themes or plugins installed on your site).
|
||
Dashboard Widget with campaigns summary.
A widget on WordPress dashboard with processed and next campaigns to run. You can choose what role can see the dashboard widget.
|
||
Multilanguage ready.
English and spanish languages included. Also .po and .mo files to translate are included. You can see detail of other custom transations that are included on free version readme file.
|
||
Attempt to get Full Content of source site.
This add-on takes the title and permalink of every feed item and scratches its web page to find the full content. Works automatically with almost all sites, but is also configurable. Do not pay monthly fees for what you can get by one purchase
|
||
Fix and correct wrong HTML on content.
You can enable this on txt config file when you get the content through Full content feature.
|
||
Support Custom taxonomies for Custom Post Types.
Just activate the Professional plugin and your campaign will show the metaboxes to select the custom taxonomies for the Custom Post Type selected.
|
||
Delete last HTML tag option.
Many sites add own custom data on the last html tag. May be <p> or <div> or <span>, anyway, you can take off here.
|
||
Strip HTML from content.
You can strip all HTML tags from content and saves it as pure text.
|
||
Delete last portion of the content after a phrase.
With this option you could delete all the content after a word or phrase until the end.
|
||
Supports Multifeeds, paged RSS feeds.
WordPress make paged feeds for its websites like /feed?paged=2. Since 1.5 version, the addon Professional allows fetch as many pages as you want from every feed URL.
|
||
Import the URL feed list into a campaign.
If you have a list of feed that you want to add into a campaign, you can import all of them with a few simple clicks pasting the list as txt format.
|
||
Automatic assign ‘per feed’ author name.
Automatic assigns author names based on source feed or custom typed author.
|
||
Automatic assign the author from <author> tags.
Get the author names based on every <author> tag from the source feed items in the RSS. If the user does not exists then creates it as a WP user.
|
||
Words counters filters.
Strip the HTML and count how many words or letters are in content and allows assign a category, cut the content or skip the post.
|
||
Keywords filtering. Include filters by source Categories. Regular expressions supported.
You can determine if skip or publish the post for certain words in title, content or in the source item categories.
|
||
Custom title with/out counter.
PRO Version allow change the title of original post and also you can add a counter in the title name to don’t get duplicated titles.
|
||
Extra filters to check Duplicates with Custom titles.
PRO Version allow enable an extra query when fetching to check the titles before insert the new post in database to skip inserting the post if gets duplicated titles.
|
||
AUTO Tags Feature.
Generate tags automatically taken from content words. You can filter bad tags and how many tags do you want on every post. (Also you can see our Cats2Tags Add-on, getting 50% discount buying PRO version)
|
||
Custom fields with dynamic values.
Feature Custom fields with dynamic values allow you to add as many fields as you want with the possibility of add values as word templates replaced on the fly when the campaign is running. This allow add custom fields values like permalink, images urls, etc.
|
||
Import and export multiple campaigns.
This feature allow you to export and download a file from a single or a list of campaigns, then later you can upload and import the campaigns in another or same wordpress with WPeMatico professional version installed.
|
||
Default Featured image.
You can set the URL of a default Featured image if not found image on content.
|
||
Filter images by width or height.
You can set the min o max width or height to set the Featured image. Also Filter and delete images in posts content just by width or height of every image.
|
||
Images renamer.
Rename all the images uploaded to the website with a mask field where you can type or use the post name.
|
||
Get audio and video from the enclosures.
This feature allows you to get the audio and video files from the feed enclosures and podcasts.
|
||
Adds support for extra video and audio file types.
This feature allows you to import media files for audio and video with the extensions mp3, ogg, wav, wma, m4a and mp4, m4v, mov, wmv, avi, mpg, ogv, 3gp, 3g2.
|
||
Adds support for partial downloads of big video and audio files.
This feature allows you to import big media files for audio and video uploading them by ranges of kbytes instead upload the entire size at once.
|
||
Tweak the audio and video files.
Strip the queries variables in the URLs of audio and video links. Audio and video filenames renamer. Strip audios and videos html tags from the content.
|
||
Get WPeMatico Right Now! | GetDownload Free version from WordPress repository |
BuyGo to select license type and buy now PRO Version! |
All features are working on almost all servers. Try WPeMatico FREE Version to be sure before buy.
ffc82b3f4a72b15f06061e5bee9d0bf248f38a2421cfcf5c60c242b25da34dad.{"blockName":null,"attrs":{"disableCache":false},"innerBlocks":[],"innerHTML":"<div>\n<div class=\"su-quote su-quote-style-default\">\n<div class=\"su-quote-inner su-u-clearfix su-u-trim\">WPeMatico is for autoblogging. Automatically create posts from the RSS\/Atom feeds you choose, which are organized into campaigns.<\/div>\n<\/div>\nGets an important discount for purchasing WPeMatico Essentials that includes WPeMatico Professional plus Full Content addons.\n\nLot of new features with contents, images, tags, filters, custom fields and much more extends in WPeMatico free plugin, going further than RSS feed limits and takes you to a new experience.\n\n<small><strong>Click on each item to see more details about it<\/strong><\/small>\n<table class=\"su_freepro\">\n<tbody>\n<tr>\n<td>(Almost) all <strong>WPeMatico\u2019s Features<\/strong><\/td>\n<td class=\"\">FREE<\/td>\n<td class=\"\">PRO<\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Feeds and options are organized into campaigns.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Use WordPress custom post types for campaigns. Comfortable interface like Worpress posts editing for every campaign. You can move and close metaboxes. You can paginate and filter campaigns list by name. Feed list with scroll into campaign. Feed search filter. Inline smaller help on every metabox. Colored boxes for knowing what I\u2019m doing.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Multiple feeds \/ categories \/ tags.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> It\u2019s possible to add as many feeds as you want, and add them to multiple already created categories or create new ones.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Auto add categories from source posts.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Categories found on source item can be added to the post; If category does not exist, then will be created.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Integrated with Simplepie library in WordPress.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Integrated with the Simplepie library that come with WordPress. This includes RSS 0.91 and RSS 1.0 formats, the popular RSS 2.0 format, Atom\u2026<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Feed autodiscovery from domains.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Lets you add feeds without even knowing the exact URL. Just type the domain of the site and will try to autodetect the feed. (Thanks Simplepie!)<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>External cron or WordPress cron jobs.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> For maximum performance, you can make the RSS fetching process be called by a Unix or external cron job, or simply let WordPress handle it.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Max items, comments, author and lot of options.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Assigns options in campaign like max items to fetch every time, comments open\/closed, current or original date, author, trackbacks, etc.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Custom post type, status, post formats and lot of options.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can assign every item as post, page or another custom post type you have on your wordpress. Draft, pending or published Status and also assign a Post Format that your theme supports.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Image processing integrated with WordPress.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Images caching are integrated with WordPress Media Library and attach to posts for featured images. Upload remote images to default Uploads folder set on WordPress settings or link to source to save resources. Fully configurable in campaign.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Featured Image of post.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> First image attached to a post enable as Featured Image.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Strip links from content.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can strip all links from content and leaves them as text.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Strip HTML from content.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can strip all HTML tags from content and saves it as pure text.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Post templating before save.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Campaign post template allow to modify the content fetched by adding extra information, such as text, images, campaign data, etc. before save it as post content. You can use some tags that will be replaced for current value.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Words Rewriting. Regular expressions supported.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> The rewrite feature allow you to replace words or phrases of the content with the text you specify.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Words Relinking. Define custom links for words in content.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> The Relinking feature allow you to make simple links from some words with origin and re-link fields.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Words to Category.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Define custom words to search into content or title to assign the post to specified category.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Detailed Log on campaign.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can set to see the log on popup in campaign list or send to custom e-mail, with SMTP or WordPress php mail function on every executed cron or only on errors with campaign items.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Wordpress permalinks to Source site.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Option to replace title links (Permalink) to external source. (This feature depends on others filters that can call permalink for themes or plugins installed on your site).<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Dashboard Widget with campaigns summary.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> A widget on WordPress dashboard with processed and next campaigns to run. You can choose what role can see the dashboard widget.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Multilanguage ready.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> English and spanish languages included. Also .po and .mo files to translate are included. You can see detail of other custom transations that are included on free version readme file.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Attempt to get Full Content of source site.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> This add-on takes the title and permalink of every feed item and scratches its web page to find the full content. Works automatically with almost all sites, but is also configurable. Do not pay monthly fees for what you can get by one purchase <imgsrc=\"\" alt=\"\ud83d\ude09\" class=\"wp-smiley\" style=\"height: 1em; max-height: 1em;\"> See more details on single Add on Page <a href=\"http:\/\/etruel.com\/downloads\/wpematico-full-content\/ref\/2\/?campaign=wpematicosite\" target=\"_blank\" rel=\"noopener noreferrer\">WPeMatico Full Content<\/a><\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Fix and correct wrong HTML on content.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can enable this on txt config file when you get the content through Full content feature.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Support Custom taxonomies for Custom Post Types.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Just activate the Professional plugin and your campaign will show the metaboxes to select the custom taxonomies for the Custom Post Type selected.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Delete last HTML tag option.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Many sites add own custom data on the last html tag. May be &lt;p&gt; or &lt;div&gt; or &lt;span&gt;, anyway, you can take off here.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Strip HTML from content.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can strip all HTML tags from content and saves it as pure text.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Delete last portion of the content after a phrase.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> With this option you could delete all the content <em>after<\/em> a word or phrase until the end.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Supports Multifeeds, paged RSS feeds.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> WordPress make paged feeds for its websites like \/feed?paged=2. Since 1.5 version, the addon Professional allows fetch as many pages as you want from every feed URL.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Import the URL feed list into a campaign.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> If you have a list of feed that you want to add into a campaign, you can import all of them with a few simple clicks pasting the list as txt format.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Automatic assign 'per feed' author name.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Automatic assigns author names based on source feed or custom typed author.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Automatic assign the author from &lt;author&gt; tags.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Get the author names based on every &lt;author&gt; tag from the source feed items in the RSS. If the user does not exists then creates it as a WP user.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Words counters filters.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Strip the HTML and count how many words or letters are in content and allows assign a category, cut the content or skip the post.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Keywords filtering. Include filters by source Categories. Regular expressions supported.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can determine if skip or publish the post for certain words in title, content or in the source item categories.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Custom title with\/out counter.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> PRO Version allow change the title of original post and also you can add a counter in the title name to don\u2019t get duplicated titles.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Extra filters to check Duplicates with Custom titles.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> PRO Version allow enable an extra query when fetching to check the titles before insert the new post in database to skip inserting the post if gets duplicated titles.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>AUTO Tags Feature.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Generate tags automatically taken from content words. You can filter bad tags and how many tags do you want on every post. (Also you can see our Cats2Tags Add-on, getting 50% discount buying PRO version)<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Custom fields with dynamic values.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Feature Custom fields with dynamic values allow you to add as many fields as you want with the possibility of add values as word templates replaced on the fly when the campaign is running. This allow add custom fields values like permalink, images urls, etc.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Import and export multiple campaigns.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> This feature allow you to export and download a file from a single or a list of campaigns, then later you can upload and import the campaigns in another or same wordpress with WPeMatico professional version installed.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Default Featured image.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can set the URL of a default Featured image if not found image on content.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Filter images by width or height.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can set the min o max width or height to set the Featured image. Also Filter and delete images in posts content just by width or height of every image.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Images renamer.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Rename all the images uploaded to the website with a mask field where you can type or use the post name.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Get audio and video from the enclosures.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> This feature allows you to get the audio and video files from the feed enclosures and podcasts.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Adds support for extra video and audio file types.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> This feature allows you to import media files for audio and video with the extensions <strong>mp3, ogg, wav, wma, m4a<\/strong> and <strong>mp4, m4v, mov, wmv, avi, mpg, ogv, 3gp, 3g2<\/strong>.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Adds support for partial downloads of big video and audio files.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> This feature allows you to import big media files for audio and video uploading them by ranges of kbytes instead upload the entire size at once.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Tweak the audio and video files.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Strip the queries variables in the URLs of audio and video links. Audio and video filenames renamer. Strip audios and videos html tags from the content.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td style=\"vertical-align: middle; text-align: center; font-size: 1.4em;\"><strong>Get WPeMatico Right Now!<\/strong><\/td>\n<td class=\"\"><span id=\"su_tooltip_64f0f4a687076_button\" class=\"su-tooltip-button su-tooltip-button-outline-yes\" aria-describedby=\"su_tooltip_64f0f4a687076\" data-settings='{\"position\":\"left\",\"behavior\":\"hover\",\"hideDelay\":0}' tabindex=\"0\"><a href=\"https:\/\/downloads.wordpress.org\/plugin\/wpematico.zip\" class=\"su-button su-button-style-default\" style=\"color:#FFFFFF;background-color:#2D89EF;border-color:#246ec0;border-radius:4px;-moz-border-radius:4px;-webkit-border-radius:4px\" target=\"_self\" rel=\"nofollow noopener\"><span style=\"color:#FFFFFF;padding:5px 14px;font-size:12px;line-height:18px;border-color:#6cadf4;border-radius:4px;-moz-border-radius:4px;-webkit-border-radius:4px;text-shadow:none;-moz-text-shadow:none;-webkit-text-shadow:none\"><i class=\"sui sui-wordpress\" style=\"font-size:12px;color:#FFFFFF\"><\/i> Get<\/span><\/a><\/span><span style=\"display:none;z-index:100\" id=\"su_tooltip_64f0f4a687076\" class=\"su-tooltip\" role=\"tooltip\"><span class=\"su-tooltip-inner su-tooltip-shadow-no\" style=\"z-index:100;background:#CAED9E;color:#3F6219;font-size:16px;border-radius:5px;text-align:left;max-width:300px;line-height:1.25\"><span class=\"su-tooltip-title\"><\/span><span class=\"su-tooltip-content su-u-trim\">Download Free version\nfrom WordPress repository<\/span><\/span><span id=\"su_tooltip_64f0f4a687076_arrow\" class=\"su-tooltip-arrow\" style=\"z-index:100;background:#CAED9E\" data-popper-arrow><\/span><\/span><\/td>\n<td class=\"\"><span id=\"su_tooltip_64f0f4a6871cd_button\" class=\"su-tooltip-button su-tooltip-button-outline-yes\" aria-describedby=\"su_tooltip_64f0f4a6871cd\" data-settings='{\"position\":\"right\",\"behavior\":\"hover\",\"hideDelay\":0}' tabindex=\"0\"><a href=\"https:\/\/etruel.com\/downloads\/wpematico-essentials\/ref\/2\/?campaign=wpematicosite\" class=\"su-button su-button-style-default\" style=\"color:#FFFFFF;background-color:#2D89EF;border-color:#246ec0;border-radius:4px;-moz-border-radius:4px;-webkit-border-radius:4px\" target=\"_self\" rel=\"noopener\"><span style=\"color:#FFFFFF;padding:5px 14px;font-size:12px;line-height:18px;border-color:#6cadf4;border-radius:4px;-moz-border-radius:4px;-webkit-border-radius:4px;text-shadow:none;-moz-text-shadow:none;-webkit-text-shadow:none\"><i class=\"sui sui-graduation-cap\" style=\"font-size:12px;color:#FFFFFF\"><\/i> Buy<\/span><\/a><\/span><span style=\"display:none;z-index:100\" id=\"su_tooltip_64f0f4a6871cd\" class=\"su-tooltip\" role=\"tooltip\"><span class=\"su-tooltip-inner su-tooltip-shadow-no\" style=\"z-index:100;background:#CAED9E;color:#3F6219;font-size:16px;border-radius:5px;text-align:left;max-width:300px;line-height:1.25\"><span class=\"su-tooltip-title\"><\/span><span class=\"su-tooltip-content su-u-trim\">Go to select license type\nand buy now PRO Version!<\/span><\/span><span id=\"su_tooltip_64f0f4a6871cd_arrow\" class=\"su-tooltip-arrow\" style=\"z-index:100;background:#CAED9E\" data-popper-arrow><\/span><\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\nAll features are working on almost all servers. Try <a title=\"WPeMatico on WordPress\" href=\"http:\/\/wordpress.org\/plugins\/wpematico\/\" target=\"_blank\" rel=\"noopener noreferrer\">WPeMatico FREE Version<\/a> to be sure before buy.\n\n<\/div>\n<a href=\"https:\/\/etruel.com\/downloads\/wpematico-essentials\/ref\/2\/?campaign=wpematicosite\" class=\"btn\" target=\"_blank\" rel=\"noopener\">See Licenses and prices at\u00a0etruel.com<\/a>","innerContent":["<div>\n<div class=\"su-quote su-quote-style-default\">\n<div class=\"su-quote-inner su-u-clearfix su-u-trim\">WPeMatico is for autoblogging. Automatically create posts from the RSS\/Atom feeds you choose, which are organized into campaigns.<\/div>\n<\/div>\nGets an important discount for purchasing WPeMatico Essentials that includes WPeMatico Professional plus Full Content addons.\n\nLot of new features with contents, images, tags, filters, custom fields and much more extends in WPeMatico free plugin, going further than RSS feed limits and takes you to a new experience.\n\n<small><strong>Click on each item to see more details about it<\/strong><\/small>\n<table class=\"su_freepro\">\n<tbody>\n<tr>\n<td>(Almost) all <strong>WPeMatico\u2019s Features<\/strong><\/td>\n<td class=\"\">FREE<\/td>\n<td class=\"\">PRO<\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Feeds and options are organized into campaigns.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Use WordPress custom post types for campaigns. Comfortable interface like Worpress posts editing for every campaign. You can move and close metaboxes. You can paginate and filter campaigns list by name. Feed list with scroll into campaign. Feed search filter. Inline smaller help on every metabox. Colored boxes for knowing what I\u2019m doing.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Multiple feeds \/ categories \/ tags.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> It\u2019s possible to add as many feeds as you want, and add them to multiple already created categories or create new ones.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Auto add categories from source posts.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Categories found on source item can be added to the post; If category does not exist, then will be created.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Integrated with Simplepie library in WordPress.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Integrated with the Simplepie library that come with WordPress. This includes RSS 0.91 and RSS 1.0 formats, the popular RSS 2.0 format, Atom\u2026<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Feed autodiscovery from domains.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Lets you add feeds without even knowing the exact URL. Just type the domain of the site and will try to autodetect the feed. (Thanks Simplepie!)<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>External cron or WordPress cron jobs.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> For maximum performance, you can make the RSS fetching process be called by a Unix or external cron job, or simply let WordPress handle it.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Max items, comments, author and lot of options.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Assigns options in campaign like max items to fetch every time, comments open\/closed, current or original date, author, trackbacks, etc.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Custom post type, status, post formats and lot of options.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can assign every item as post, page or another custom post type you have on your wordpress. Draft, pending or published Status and also assign a Post Format that your theme supports.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Image processing integrated with WordPress.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Images caching are integrated with WordPress Media Library and attach to posts for featured images. Upload remote images to default Uploads folder set on WordPress settings or link to source to save resources. Fully configurable in campaign.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Featured Image of post.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> First image attached to a post enable as Featured Image.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Strip links from content.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can strip all links from content and leaves them as text.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Strip HTML from content.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can strip all HTML tags from content and saves it as pure text.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Post templating before save.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Campaign post template allow to modify the content fetched by adding extra information, such as text, images, campaign data, etc. before save it as post content. You can use some tags that will be replaced for current value.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Words Rewriting. Regular expressions supported.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> The rewrite feature allow you to replace words or phrases of the content with the text you specify.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Words Relinking. Define custom links for words in content.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> The Relinking feature allow you to make simple links from some words with origin and re-link fields.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Words to Category.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Define custom words to search into content or title to assign the post to specified category.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Detailed Log on campaign.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can set to see the log on popup in campaign list or send to custom e-mail, with SMTP or WordPress php mail function on every executed cron or only on errors with campaign items.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Wordpress permalinks to Source site.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Option to replace title links (Permalink) to external source. (This feature depends on others filters that can call permalink for themes or plugins installed on your site).<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Dashboard Widget with campaigns summary.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> A widget on WordPress dashboard with processed and next campaigns to run. You can choose what role can see the dashboard widget.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Multilanguage ready.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> English and spanish languages included. Also .po and .mo files to translate are included. You can see detail of other custom transations that are included on free version readme file.<\/div>\n<\/div><\/td>\n<td class=\"have\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Attempt to get Full Content of source site.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> This add-on takes the title and permalink of every feed item and scratches its web page to find the full content. Works automatically with almost all sites, but is also configurable. Do not pay monthly fees for what you can get by one purchase <imgsrc=\"\" alt=\"\ud83d\ude09\" class=\"wp-smiley\" style=\"height: 1em; max-height: 1em;\"> See more details on single Add on Page <a href=\"http:\/\/etruel.com\/downloads\/wpematico-full-content\/ref\/2\/?campaign=wpematicosite\" target=\"_blank\" rel=\"noopener noreferrer\">WPeMatico Full Content<\/a><\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Fix and correct wrong HTML on content.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can enable this on txt config file when you get the content through Full content feature.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Support Custom taxonomies for Custom Post Types.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Just activate the Professional plugin and your campaign will show the metaboxes to select the custom taxonomies for the Custom Post Type selected.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Delete last HTML tag option.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Many sites add own custom data on the last html tag. May be &lt;p&gt; or &lt;div&gt; or &lt;span&gt;, anyway, you can take off here.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Strip HTML from content.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can strip all HTML tags from content and saves it as pure text.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Delete last portion of the content after a phrase.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> With this option you could delete all the content <em>after<\/em> a word or phrase until the end.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Supports Multifeeds, paged RSS feeds.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> WordPress make paged feeds for its websites like \/feed?paged=2. Since 1.5 version, the addon Professional allows fetch as many pages as you want from every feed URL.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Import the URL feed list into a campaign.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> If you have a list of feed that you want to add into a campaign, you can import all of them with a few simple clicks pasting the list as txt format.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Automatic assign 'per feed' author name.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Automatic assigns author names based on source feed or custom typed author.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Automatic assign the author from &lt;author&gt; tags.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Get the author names based on every &lt;author&gt; tag from the source feed items in the RSS. If the user does not exists then creates it as a WP user.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Words counters filters.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Strip the HTML and count how many words or letters are in content and allows assign a category, cut the content or skip the post.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Keywords filtering. Include filters by source Categories. Regular expressions supported.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can determine if skip or publish the post for certain words in title, content or in the source item categories.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Custom title with\/out counter.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> PRO Version allow change the title of original post and also you can add a counter in the title name to don\u2019t get duplicated titles.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Extra filters to check Duplicates with Custom titles.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> PRO Version allow enable an extra query when fetching to check the titles before insert the new post in database to skip inserting the post if gets duplicated titles.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>AUTO Tags Feature.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Generate tags automatically taken from content words. You can filter bad tags and how many tags do you want on every post. (Also you can see our Cats2Tags Add-on, getting 50% discount buying PRO version)<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Custom fields with dynamic values.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Feature Custom fields with dynamic values allow you to add as many fields as you want with the possibility of add values as word templates replaced on the fly when the campaign is running. This allow add custom fields values like permalink, images urls, etc.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Import and export multiple campaigns.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> This feature allow you to export and download a file from a single or a list of campaigns, then later you can upload and import the campaigns in another or same wordpress with WPeMatico professional version installed.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Default Featured image.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can set the URL of a default Featured image if not found image on content.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Filter images by width or height.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> You can set the min o max width or height to set the Featured image. Also Filter and delete images in posts content just by width or height of every image.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Images renamer.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Rename all the images uploaded to the website with a mask field where you can type or use the post name.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Get audio and video from the enclosures.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> This feature allows you to get the audio and video files from the feed enclosures and podcasts.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Adds support for extra video and audio file types.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> This feature allows you to import media files for audio and video with the extensions <strong>mp3, ogg, wav, wma, m4a<\/strong> and <strong>mp4, m4v, mov, wmv, avi, mpg, ogv, 3gp, 3g2<\/strong>.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Adds support for partial downloads of big video and audio files.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> This feature allows you to import big media files for audio and video uploading them by ranges of kbytes instead upload the entire size at once.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td>\n<div class=\"su-spoiler su-spoiler-style-default su-spoiler-icon-arrow-circle-1 freepro su-spoiler-closed\" data-scroll-offset=\"0\" data-anchor-in-url=\"no\">\n<div class=\"su-spoiler-title\" tabindex=\"0\" role=\"button\"><span class=\"su-spoiler-icon\"><\/span>Tweak the audio and video files.<\/div>\n<div class=\"su-spoiler-content su-u-clearfix su-u-trim\"> Strip the queries variables in the URLs of audio and video links. Audio and video filenames renamer. Strip audios and videos html tags from the content.<\/div>\n<\/div><\/td>\n<td class=\"dont\"><\/td>\n<td class=\"have\"><\/td>\n<\/tr>\n<tr>\n<td style=\"vertical-align: middle; text-align: center; font-size: 1.4em;\"><strong>Get WPeMatico Right Now!<\/strong><\/td>\n<td class=\"\"><span id=\"su_tooltip_64f0f4a687076_button\" class=\"su-tooltip-button su-tooltip-button-outline-yes\" aria-describedby=\"su_tooltip_64f0f4a687076\" data-settings='{\"position\":\"left\",\"behavior\":\"hover\",\"hideDelay\":0}' tabindex=\"0\"><a href=\"https:\/\/downloads.wordpress.org\/plugin\/wpematico.zip\" class=\"su-button su-button-style-default\" style=\"color:#FFFFFF;background-color:#2D89EF;border-color:#246ec0;border-radius:4px;-moz-border-radius:4px;-webkit-border-radius:4px\" target=\"_self\" rel=\"nofollow noopener\"><span style=\"color:#FFFFFF;padding:5px 14px;font-size:12px;line-height:18px;border-color:#6cadf4;border-radius:4px;-moz-border-radius:4px;-webkit-border-radius:4px;text-shadow:none;-moz-text-shadow:none;-webkit-text-shadow:none\"><i class=\"sui sui-wordpress\" style=\"font-size:12px;color:#FFFFFF\"><\/i> Get<\/span><\/a><\/span><span style=\"display:none;z-index:100\" id=\"su_tooltip_64f0f4a687076\" class=\"su-tooltip\" role=\"tooltip\"><span class=\"su-tooltip-inner su-tooltip-shadow-no\" style=\"z-index:100;background:#CAED9E;color:#3F6219;font-size:16px;border-radius:5px;text-align:left;max-width:300px;line-height:1.25\"><span class=\"su-tooltip-title\"><\/span><span class=\"su-tooltip-content su-u-trim\">Download Free version\nfrom WordPress repository<\/span><\/span><span id=\"su_tooltip_64f0f4a687076_arrow\" class=\"su-tooltip-arrow\" style=\"z-index:100;background:#CAED9E\" data-popper-arrow><\/span><\/span><\/td>\n<td class=\"\"><span id=\"su_tooltip_64f0f4a6871cd_button\" class=\"su-tooltip-button su-tooltip-button-outline-yes\" aria-describedby=\"su_tooltip_64f0f4a6871cd\" data-settings='{\"position\":\"right\",\"behavior\":\"hover\",\"hideDelay\":0}' tabindex=\"0\"><a href=\"https:\/\/etruel.com\/downloads\/wpematico-essentials\/ref\/2\/?campaign=wpematicosite\" class=\"su-button su-button-style-default\" style=\"color:#FFFFFF;background-color:#2D89EF;border-color:#246ec0;border-radius:4px;-moz-border-radius:4px;-webkit-border-radius:4px\" target=\"_self\" rel=\"noopener\"><span style=\"color:#FFFFFF;padding:5px 14px;font-size:12px;line-height:18px;border-color:#6cadf4;border-radius:4px;-moz-border-radius:4px;-webkit-border-radius:4px;text-shadow:none;-moz-text-shadow:none;-webkit-text-shadow:none\"><i class=\"sui sui-graduation-cap\" style=\"font-size:12px;color:#FFFFFF\"><\/i> Buy<\/span><\/a><\/span><span style=\"display:none;z-index:100\" id=\"su_tooltip_64f0f4a6871cd\" class=\"su-tooltip\" role=\"tooltip\"><span class=\"su-tooltip-inner su-tooltip-shadow-no\" style=\"z-index:100;background:#CAED9E;color:#3F6219;font-size:16px;border-radius:5px;text-align:left;max-width:300px;line-height:1.25\"><span class=\"su-tooltip-title\"><\/span><span class=\"su-tooltip-content su-u-trim\">Go to select license type\nand buy now PRO Version!<\/span><\/span><span id=\"su_tooltip_64f0f4a6871cd_arrow\" class=\"su-tooltip-arrow\" style=\"z-index:100;background:#CAED9E\" data-popper-arrow><\/span><\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\nAll features are working on almost all servers. Try <a title=\"WPeMatico on WordPress\" href=\"http:\/\/wordpress.org\/plugins\/wpematico\/\" target=\"_blank\" rel=\"noopener noreferrer\">WPeMatico FREE Version<\/a> to be sure before buy.\n\n<\/div>\n<a href=\"https:\/\/etruel.com\/downloads\/wpematico-essentials\/ref\/2\/?campaign=wpematicosite\" class=\"btn\" target=\"_blank\" rel=\"noopener\">See Licenses and prices at\u00a0etruel.com<\/a>"],"context_type":"single"}