Given a list of numbers and a number, return whether any two numbers from the list add up to
Indents
PEP 8: Use 4 spaces per indentation level.

True if condition else False
The pattern True if condition else False can be replaced by condition if it evaluates to a bool. If you are checking for truthy and falsey values you can replace the pattern by bool(condition).
While this lets us simplify the return statement
return any([sum(pair) == k for pair in c_k_2])

it actually performs worse (as pointed out by Manuel in the comments) without implementing further improvements (see the next point). While you originally create a list of only True values, this simplification will create a list that also includes all the False values, which we do not need at all.

Drop the list
You convert to a list twice in your code, once explicitly by calling the list(...) constructor and once implicitly by wrapping a generator expression with [...]. In your particular use case, both are unnecessary.
When dropping the call to the list constructor, combinations(numbers, 2) will provide an itertools.combinations object, which I would assume behaves similiarly to a generator, which is a lazily evaluated iterable. This way we don't compute and store all possible combinations of numbers in advance, which is perfect for us because we

only need one pair of numbers at a time
want to stop evaluating the expression once we find a pair that matches our criteria

Dropping the brackets [] around our generator expression follows the same logic.
Generator expressions vs. list comprehensions on StackOverflow

Applying these improvements will make the code more efficient, more readable and more concise:
def any_two_elements_add_up_to(numbers, k):
    pairs = combinations(numbers, 2)
    return any(sum(pair) == k for pair in pairs)

# or as a one-liner

def any_two_elements_add_up_to(numbers, k):
    return any(sum(pair) == k for pair in combinations(numbers, 2))


EDIT: Algorithm
I've tried my hand at a faster approach, this is the first solution I came up with. Although it's really simple it still outperforms the above solution by orders of magnitude as it runs in O(n).
Here's the code:
def new_approach(numbers, target):
    counterparts = set()

    for num in numbers:
        if num in counterparts:
            return True

        counterparts.add(target - num)

    return False

Since every number only has one counterpart k - x that would make it add up to k, we can keep a set of all possible counterparts that we've identified so far. Once we come across a number that is in our set of counterparts (i.e. adds up to k with a previous number) we return True. If we don't come across one such number, we simply return False.