diff --git a/src/app/community/page.tsx b/src/app/community/page.tsx
index a47cb47..764e358 100644
--- a/src/app/community/page.tsx
+++ b/src/app/community/page.tsx
@@ -55,7 +55,7 @@
   useEffect(() => {
     const fetchHotCommunity = async () => {
       try {
-        const { data } = await axios.get(`http://127.0.0.1:4523/m1/6387307-6083949-default/community/hot`);
+        const { data } = await axios.get(process.env.PUBLIC_URL + `/community/hot`);
         setHotCommunities(data.communityList);
       } catch (err) {
         console.error(err);
@@ -69,7 +69,7 @@
   useEffect(() => {
     const fetchCommunity = async () => {
       try {
-        const { data } = await axios.get(`http://127.0.0.1:4523/m1/6387307-6083949-default/community/common`);
+        const { data } = await axios.get(process.env.PUBLIC_URL + `/community/common`);
         setCommunities(data.communityList);
         console.log(data.communityList);
       } catch (err) {
@@ -106,7 +106,7 @@
                         width="24"
                         height="24"
                       /></div>
-                    <Image src={process.env.NEXT_PUBLIC_NGINX_URL + item.communityPicture} alt={item.communityName}  height="200" className="w-full h-48 object-cover" />
+                    <Image src={process.env.NEXT_PUBLIC_NGINX_URL + item.communityPicture} alt={item.communityName} height="200" className="w-full h-48 object-cover" />
                   </div>
                 }
               >
