Chain Responsibility Pattern to filtering messages
Chain of Responsibility

Rather than building the chain on instantiation, make the creation of the chain a function.
This can allow you to chain the creation, which is easier to read and nicer to look at.

I'd also make the chain return, rather than mutate a foreign object.
This removes side effects, which lead to hard to understand code, and potential bugs.

has_successor is a poor function, it's simpler to read and understand using if self._next is not None, rather than using that abstraction.
And so I'd remove it, I'd favour writing out the non-function way anyway.


And so I'd come to:
class Filter(object):
    _next = None
    def add_filter(self, next_filter):
        self._next = next_filter
        return next_filter

    def filter_message(self, message):
        if self._next is None:
            return True
        return self._next.filter_message(message)

class SlangFilter(Filter):
    def filter_message(self, message):
        for word in message.content:
            for bad_word in bad_words:
                if bad_word == word.lower():
                    return False

        if self._next is None:
            return True
        return self._next.filter_message(message)

class Website_Filter(Filter):
    def filter_message(self, message):
        if re.findall(urlmarker.URL_REGEX, message.content) is not None:
            return False

        if self._next is None:
            return True
        return self._next.filter_message(message)

This then lets you create the chain as:
def main():
    new_message = Message(&quot;This is full of fucking shit www.google.com&quot;)
    filter = WebsiteFilter()
        .add_filter(SlangFilter())
    print filter.filter_message(new_message)


Going forward, you'd want to change your classes in a couple of other ways too.

Rather than relying on a global bad words variable, SlangFilter should be passed these words on instantiation.
Rather than manually re-creating in, you can use it to reduce code complexity, and for a performance boost, if you were to change the list of words to a set.
Your code shouldn't rely on an unneeded model, as a string is good enough for this.

And so I'd use:
import urlmarker
import re


class Filter(object):
    _next = None
    def add_filter(self, next_filter):
        self._next = next_filter
        return next_filter

    def filter_message(self, message):
        if self._next is None:
            return True
        return self._next.filter_message(message)


class SlangFilter(Filter):
    def __init__(self, bad_words):
        self._bad_words = {word.lower() for word in bad_words}
    
    def filter_message(self, message):
        for word in message.lower().split():
            if word in self._bad_words:
                return False

        if self._next is None:
            return True
        return self._next.filter_message(message)


class Website_Filter(Filter):
    def filter_message(self, message):
        if re.findall(urlmarker.URL_REGEX, message) is not None:
            return False

        if self._next is None:
            return True
        return self._next.filter_message(message)


def main():
    with open(&quot;bad-words.txt&quot;) as file:
        bad_words = [word.strip() for word in file]
    
    message = &quot;This is full of fucking shit www.google.com&quot;
    filter = WebsiteFilter()
        .add_filter(SlangFilter(bad_words))
    print filter.filter_message(message)


if __name__ == '__main__':
    main()