My current code to detect circle circle intersection looks like this:

        private List<Point> intersect(Circle c1, Circle c2)
        {
            List<Point> rLp = new List<Point>();
            double d = new Point(c1.p.X - c2.p.X, c1.p.Y - c2.p.Y).dist();

            if (d > (c1.radius + c2.radius))
                return rLp;
            else if (d == 0 && c1.radius == c2.radius)
                return rLp;
            else if ((d + Math.Min(c1.radius, c2.radius)) < Math.Max(c1.radius, c2.radius))
                return rLp;
            else
            {
                double a = (c1.radius * c1.radius - c2.radius * c2.radius + d * d) / (2 * d);
                double h = Math.Sqrt(c1.radius * c1.radius - a * a);

                Point p2 = new Point(Convert.ToInt32(c1.p.X + (a * (c2.p.X - c1.p.X)) / d), Convert.ToInt32(c1.p.Y + (a * c2.p.Y - c1.p.Y) / d));

                Point i1 = new Point(Convert.ToInt32(p2.X + (h * (c2.p.Y - c1.p.Y)) / d), Convert.ToInt32(p2.Y - (h * (c2.p.X - c1.p.X)) / d));
                Point i2 = new Point(Convert.ToInt32(p2.X - (h * (c2.p.Y - c1.p.Y)) / d), Convert.ToInt32(p2.Y + (h * (c2.p.X - c1.p.X)) / d));

                if (d == (c1.radius + c2.radius))
                    rLp.Add(i1);
                else
                {
                    rLp.Add(i1);
                    rLp.Add(i2);
                }

                return rLp;
            }
        }

The strange thing is:

the intersection is detected correctly but the y-coordinate is wrong. Any idea why that is?

Using float-valued points might be a good start.

        private List<Vector2> intersect(Circle c1, Circle c2)
        {
            List<Vector2> rLp = new List<Vector2>();
            double d = new Vector2(c1.p.X - c2.p.X, c1.p.Y - c2.p.Y).dist();

            if (d > (c1.radius + c2.radius))
                return rLp;
            else if (d == 0 && c1.radius == c2.radius)
                return rLp;
            else if ((d + Math.Min(c1.radius, c2.radius)) < Math.Max(c1.radius, c2.radius))
                return rLp;
            else
            {
                double a = (c1.radius * c1.radius - c2.radius * c2.radius + d * d) / (2 * d);
                double h = Math.Sqrt(c1.radius * c1.radius - a * a);

                Vector2 p2 = new Vector2((float)(c1.p.X + (a * (c2.p.X - c1.p.X)) / d), (float)(c1.p.Y + (a * c2.p.Y - c1.p.Y) / d));

                Vector2 i1 = new Vector2((float)(p2.X + (h * (c2.p.Y - c1.p.Y)) / d), (float)(p2.Y - (h * (c2.p.X - c1.p.X)) / d));
                Vector2 i2 = new Vector2((float)(p2.X - (h * (c2.p.Y - c1.p.Y)) / d), (float)(p2.Y + (h * (c2.p.X - c1.p.X)) / d));

                if (d == (c1.radius + c2.radius))
                    rLp.Add(i1);
                else
                {
                    rLp.Add(i1);
                    rLp.Add(i2);
                }

                return rLp;
            }
        }

Another thing, is that it's totally okay to use some secondary variables to make things clearer. For example c2.p - c1.p looks like it's used enough times that you could make that a vector in the code. If you're worried about speed the compiler will usually optimize them out anyway. And if you're worried about speed you could avoid a square root in the .dist() call by checking the distance squared first.

Those Y's look correct mirrored vertically (over the X-axis) to me. What rendering API are you using? Your data is correct, but you might be interpreting the rendering side of it incorrectly. Most "draw circle/line" API's work where positive Y values move downwards instead of upwards; The top left of the screen is (0, 0) and the bottom left corner is (0, height). Try rendering those points at (x, imageHeight - y) and see if they match up to the circles.

@Bacterius

Thank you very much, now it works correctly :)

Another thing, is that it's totally okay to use some secondary variables to make things clearer. For example c2.p - c1.p looks like it's used enough times that you could make that a vector in the code. If you're worried about speed the compiler will usually optimize them out anyway. And if you're worried about speed you could avoid a square root in the .dist() call by checking the distance squared first.

Okay, i'll try that :)